feat: add transfer tui wizard

Author: codejunkie99

Formula/agentic-stack.rb

@@ -8,7 +8,7 @@ class AgenticStack < Formula
 
   def install
     # install the brain + adapters alongside install.sh so relative paths hold
-    pkgshare.install ".agent", "adapters", "harness_manager", "install.sh",
+    pkgshare.install ".agent", "adapters", "harness_manager", "scripts", "install.sh",
                      "onboard.py", "onboard_ui.py", "onboard_widgets.py",
                      "onboard_render.py", "onboard_write.py",
                      "onboard_features.py"
@@ -23,6 +23,7 @@ def install
   test do
     output = shell_output("#{bin}/agentic-stack 2>&1", 2)
     assert_match "usage", output
+    assert_match "agentic-stack transfer", shell_output("#{bin}/agentic-stack transfer --help")
     # Wizard --yes must write PREFERENCES.md AND .features.json into a temp project dir
     (testpath/".agent/memory/personal").mkpath
     system "#{bin}/agentic-stack", "claude-code", testpath.to_s, "--yes"

README.md

@@ -134,6 +134,7 @@ verb-style subcommands (works with both `install.sh` and `install.ps1`):
 ./install.sh status              # one-screen view: which adapters, brain stats
 ./install.sh doctor              # read-only audit; green / yellow / red per adapter
 ./install.sh manage              # interactive TUI: header pane + menu loop for add/remove/audit
+./install.sh transfer            # onboarding-style wizard: export/import memory as a curl bridge
 ./install.sh remove cursor       # confirm prompt + delete; no quarantine, no undo
 ```
 
@@ -192,6 +193,29 @@ agentic-stack claude-code --reconfigure  # re-run the wizard on an existing proj
 Edit `.agent/memory/personal/PREFERENCES.md` any time to refine your
 conventions, or `.agent/memory/.features.json` to flip feature toggles.
 
+## Transfer wizard
+
+Move the portable parts of one project brain into Codex, Cursor, Windsurf,
+or a terminal-only project with the onboarding-style TUI:
+
+```bash
+./install.sh transfer
+```
+
+The wizard turns a plain-language intent into a transfer plan, lets you
+review target harnesses and memory scopes, redacts risky content by default,
+and emits a one-line curl command the next environment can run. The importer
+unpacks the bundle, verifies its SHA-256 digest, merges preferences and
+accepted lessons, copies selected skills, and installs the matching adapter
+files.
+
+For scripted handoff:
+
+```bash
+./install.sh transfer export --intent "move my preferences and lessons into Codex" --print-curl
+./install.sh transfer import --payload-file transfer.txt --sha256 <digest> --target codex
+```
+
 ## Review protocol (host-agent CLI)
 
 The nightly `auto_dream.py` cycle only **stages** candidate lessons. It
@@ -306,7 +330,7 @@ The index is stored at `.agent/memory/.index/` and gitignored.
 adapters/                       # one small shim per harness, each with adapter.json manifest
 ├── claude-code/   (CLAUDE.md + settings.json hooks — $CLAUDE_PROJECT_DIR wired, closes #18)
 ├── cursor/        (.cursor/rules/*.mdc)
-├── windsurf/      (.windsurfrules)
+├── windsurf/      (.windsurf/rules/*.md + legacy .windsurfrules)
 ├── opencode/      (AGENTS.md + opencode.json)
 ├── openclaw/      (AGENTS.md + system-prompt include; auto-registers per-project agent)
 ├── hermes/        (AGENTS.md)
@@ -323,6 +347,9 @@ harness_manager/                # v0.9.0 manifest-driven Python backend
 ├── remove.py                   # safe uninstall with shared-file detection + ownership handoff
 ├── post_install.py             # named built-ins (openclaw_register_workspace)
 ├── manage_tui.py               # interactive menu loop for add/remove/audit
+├── transfer_tui.py             # onboarding-style memory transfer wizard
+├── transfer_plan.py            # natural-language target/scope planning
+├── transfer_bundle.py          # export/import bundle codec + merge logic
 └── cli.py                      # argparse dispatcher for install.sh / install.ps1
 
 docs/                           # architecture, getting-started, per-harness

adapters/windsurf/.windsurf/rules/agentic-stack.md

@@ -0,0 +1,40 @@
+---
+trigger: always_on
+---
+
+# Windsurf rules — agentic-stack portable brain
+
+This project uses a portable brain in `.agent/`. It is authoritative for
+memory, skills, and protocols.
+
+## Startup sequence
+1. Read `.agent/AGENTS.md`
+2. Read `.agent/memory/personal/PREFERENCES.md`
+3. Read `.agent/memory/semantic/LESSONS.md`
+4. Read `.agent/protocols/permissions.md`
+
+## Recall before non-trivial tasks
+For deploy / ship / release / migration / schema / timestamp / timezone /
+date / failing test / debug / investigate / refactor, run recall first:
+
+```bash
+python3 .agent/tools/recall.py "<short description>"
+```
+
+Show surfaced lessons in a `Consulted lessons before acting:` block and
+follow them.
+
+## During work
+- Consult `.agent/skills/_index.md`. Load a full `SKILL.md` only when its
+  triggers match the current task.
+- Update `.agent/memory/working/WORKSPACE.md` as the task evolves.
+- After significant actions, call
+  `python3 .agent/tools/memory_reflect.py <skill> <action> <outcome>`.
+- Quick state: `python3 .agent/tools/show.py`.
+- Teach a rule in one shot:
+  `python3 .agent/tools/learn.py "<rule>" --rationale "<why>"`.
+
+## Hard rules
+- Never force push to `main`, `production`, or `staging`.
+- Never delete memory entries; archive only.
+- Never modify `.agent/protocols/permissions.md`.

adapters/windsurf/README.md

@@ -2,6 +2,8 @@
 
 ## Install
 ```bash
+mkdir -p .windsurf/rules
+cp adapters/windsurf/.windsurf/rules/agentic-stack.md ./.windsurf/rules/agentic-stack.md
 cp adapters/windsurf/.windsurfrules ./.windsurfrules
 ```
 
@@ -11,8 +13,9 @@ Or:
 ```
 
 ## What it wires up
-Windsurf's Cascade reads `.windsurfrules` from the project root on every
-session and prepends it to the system prompt.
+Windsurf's Cascade reads workspace rules from `.windsurf/rules/*.md`.
+The adapter also writes legacy `.windsurfrules` for users on older
+Windsurf builds.
 
 ## Verify
 Ask Cascade "What's in your lessons file?" — it should read

adapters/windsurf/adapter.json

@@ -1,7 +1,12 @@
 {
   "name": "windsurf",
-  "description": "Windsurf — .windsurfrules instruction text. No hooks today.",
+  "description": "Windsurf — modern .windsurf/rules instruction file plus legacy .windsurfrules compatibility. No hooks today.",
   "files": [
+    {
+      "src": ".windsurf/rules/agentic-stack.md",
+      "dst": ".windsurf/rules/agentic-stack.md",
+      "merge_policy": "overwrite"
+    },
     {
       "src": ".windsurfrules",
       "dst": ".windsurfrules",

docs/per-harness/windsurf.md

@@ -1,16 +1,20 @@
 # Windsurf setup
 
 ## What the adapter installs
-- `.windsurfrules` at project root
+- `.windsurf/rules/agentic-stack.md` for current Windsurf workspace rules
+- `.windsurfrules` at project root for legacy Windsurf compatibility
 
 ## Install
 ```bash
 ./install.sh windsurf
 ```
 
 ## How it works
-Windsurf's Cascade reads `.windsurfrules` on session start and prepends it
-to the system prompt. Keep the file under ~200 lines; it's read every time.
+Windsurf's Cascade discovers workspace rules in `.windsurf/rules/` and
+uses their frontmatter to decide activation. The agentic-stack rule is
+`always_on`, so Cascade receives it every session. The legacy
+`.windsurfrules` file remains installed so older Windsurf builds still
+see the portable brain.
 
 ## Logging note
 Windsurf does not have a first-class post-tool hook. The rule file asks
@@ -19,5 +23,7 @@ want automatic logging, wrap Windsurf in a watcher or run the standalone-
 python conductor as a side channel.
 
 ## Troubleshooting
-- If the agent ignores the file, make sure it's at the exact project root
-  (Windsurf doesn't search subdirectories).
+- If the agent ignores the modern rule, make sure
+  `.windsurf/rules/agentic-stack.md` exists in the workspace.
+- If you're on an older Windsurf build, make sure `.windsurfrules` exists
+  at the project root.

docs/superpowers/plans/2026-05-02-transfer-tui-wizard.md

@@ -0,0 +1,116 @@
+# Transfer TUI Wizard Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build `agentic-stack transfer` as an onboarding-style TUI wizard that exports/imports portable `.agent` memory bundles and wires Codex, Cursor, Windsurf, or terminal adapters.
+
+**Architecture:** Add pure transfer planning and bundle modules under `harness_manager/`, then wrap them with an onboarding-style wizard that reuses `onboard_ui.py` and `onboard_widgets.py`. Route the new `transfer` verb through `harness_manager.cli`, use existing adapter manifests for installation, and add shell/PowerShell import bootstrap scripts.
+
+**Tech Stack:** Python stdlib, existing `harness_manager`, existing onboarding TUI primitives, unittest, bash, PowerShell.
+
+---
+
+### Task 1: Transfer Planning
+
+**Files:**
+- Create: `harness_manager/transfer_plan.py`
+- Create: `test_transfer_plan.py`
+
+- [x] **Step 1: Write failing tests for target, operation, and scope parsing**
+
+Cover Codex/Cursor/Windsurf/terminal aliases, `all`, curl/export/apply intent, default scopes, sensitive scope opt-in, and adapter preview paths from manifests.
+
+- [x] **Step 2: Run `python3 -m unittest test_transfer_plan.py -v` and verify it fails because `harness_manager.transfer_plan` is missing**
+
+- [x] **Step 3: Implement `transfer_plan.py` with dataclasses, deterministic keyword parsing, target normalization, default scope selection, and manifest-backed adapter preview**
+
+- [x] **Step 4: Run `python3 -m unittest test_transfer_plan.py -v` and verify it passes**
+
+### Task 2: Bundle Export/Import
+
+**Files:**
+- Create: `harness_manager/transfer_bundle.py`
+- Create: `test_transfer_bundle.py`
+
+- [x] **Step 1: Write failing tests for bundle round-trip, digest verification, preferences merge, accepted lesson idempotency, and secret scan blocking**
+
+- [x] **Step 2: Run `python3 -m unittest test_transfer_bundle.py -v` and verify it fails because `harness_manager.transfer_bundle` is missing**
+
+- [x] **Step 3: Implement canonical JSON, gzip/base64 payloads, SHA-256 digests, safe file allowlisting, export from `.agent`, and import into temp projects**
+
+- [x] **Step 4: Run `python3 -m unittest test_transfer_bundle.py -v` and verify it passes**
+
+### Task 3: CLI and Wizard
+
+**Files:**
+- Create: `harness_manager/transfer_tui.py`
+- Modify: `harness_manager/cli.py`
+- Create: `test_transfer_cli.py`
+
+- [x] **Step 1: Write failing tests for non-interactive `transfer --help`, `transfer export`, `transfer import`, and non-TTY wizard refusal**
+
+- [x] **Step 2: Run `python3 -m unittest test_transfer_cli.py -v` and verify it fails because the verb is absent**
+
+- [x] **Step 3: Add the `transfer` verb, argparse routing, non-interactive export/import helpers, and onboarding-style wizard flow**
+
+- [x] **Step 4: Run `python3 -m unittest test_transfer_cli.py -v` and verify it passes**
+
+### Task 4: Bootstrap Scripts and Windsurf Modernization
+
+**Files:**
+- Create: `scripts/import-transfer.sh`
+- Create: `scripts/import-transfer.ps1`
+- Create: `adapters/windsurf/.windsurf/rules/agentic-stack.md`
+- Modify: `adapters/windsurf/adapter.json`
+- Modify: `adapters/windsurf/README.md`
+- Modify: `docs/per-harness/windsurf.md`
+- Modify: `Formula/agentic-stack.rb`
+- Create: `test_transfer_scripts.py`
+
+- [x] **Step 1: Write failing tests that assert scripts exist, Windsurf manifest installs both modern and legacy rule files, and Formula packages scripts**
+
+- [x] **Step 2: Run `python3 -m unittest test_transfer_scripts.py -v` and verify expected failures**
+
+- [x] **Step 3: Add import bootstrap scripts, add modern Windsurf rule file, update manifest/docs, and ensure Formula packages `scripts`**
+
+- [x] **Step 4: Run `python3 -m unittest test_transfer_scripts.py -v` and verify it passes**
+
+### Task 5: Full Verification
+
+**Files:**
+- All touched code and docs
+
+- [x] **Step 1: Run focused transfer tests**
+
+Command:
+
+```bash
+python3 -m unittest test_transfer_plan.py test_transfer_bundle.py test_transfer_cli.py test_transfer_scripts.py -v
+```
+
+- [x] **Step 2: Run existing relevant regression tests**
+
+Command:
+
+```bash
+python3 -m unittest test_memory_search.py test_data_layer_export.py test_data_flywheel_export.py -v
+```
+
+- [x] **Step 3: Run repository smoke checks**
+
+Command:
+
+```bash
+python3 -m harness_manager.cli transfer --help
+python3 -m harness_manager.cli transfer export --target codex --print-curl --yes
+git diff --check
+```
+
+- [x] **Step 4: Commit implementation**
+
+Command:
+
+```bash
+git add docs/superpowers/plans/2026-05-02-transfer-tui-wizard.md harness_manager/transfer_plan.py harness_manager/transfer_bundle.py harness_manager/transfer_tui.py harness_manager/cli.py scripts/import-transfer.sh scripts/import-transfer.ps1 adapters/windsurf/.windsurf/rules/agentic-stack.md adapters/windsurf/adapter.json adapters/windsurf/README.md docs/per-harness/windsurf.md Formula/agentic-stack.rb test_transfer_plan.py test_transfer_bundle.py test_transfer_cli.py test_transfer_scripts.py
+git commit -m "feat: add transfer tui wizard"
+```

harness_manager/cli.py

@@ -1,6 +1,6 @@
 """Argparse dispatcher. install.sh and install.ps1 invoke this.
 
-Verbs (subcommands): add, remove, doctor, status.
+Verbs (subcommands): add, remove, doctor, status, manage, transfer.
 Anything else in first position → treated as an adapter name (existing
 `./install.sh <adapter>` UX preserved).
 """
@@ -19,7 +19,7 @@
 from . import __version__
 
 
-VERBS = {"add", "remove", "doctor", "status", "manage"}
+VERBS = {"add", "remove", "doctor", "status", "manage", "transfer"}
 
 
 def _stack_root() -> Path:
@@ -247,6 +247,11 @@ def cmd_manage(target: Path) -> int:
     return manage_tui.run(target_root=target, stack_root=_stack_root())
 
 
+def cmd_transfer(args: list[str], target: Path) -> int:
+    from . import transfer_tui
+    return transfer_tui.run(args, target_root=target, stack_root=_stack_root())
+
+
 def cmd_bare(target: Path, wizard_flags: list[str]) -> int:
     """`./install.sh` with no args.
 
@@ -319,7 +324,8 @@ def cmd_bare(target: Path, wizard_flags: list[str]) -> int:
     print("  ./install.sh status      # quick read-only view")
     print("  ./install.sh add <name>  # install another adapter")
     print("  ./install.sh remove <name>  # remove an adapter (with confirm)")
-    print("  ./install.sh manage      # interactive TUI for everything")
+    print("  ./install.sh manage      # interactive TUI for adapter management")
+    print("  ./install.sh transfer    # onboarding-style memory transfer wizard")
     return 2
 
 
@@ -450,6 +456,8 @@ def main(argv: list[str] | None = None) -> int:
         if verb == "manage":
             target = Path(rest[1]) if len(rest) >= 2 else Path.cwd()
             return cmd_manage(target)
+        if verb == "transfer":
+            return cmd_transfer(rest[1:], Path.cwd())
 
     # Treat as adapter name (existing UX)
     adapter = first

harness_manager/doctor.py

@@ -29,7 +29,10 @@
         (".claude/settings.json", "strong"),
     ],
     "cursor": [(".cursor/rules/agentic-stack.mdc", "strong")],
-    "windsurf": [(".windsurfrules", "strong")],
+    "windsurf": [
+        (".windsurf/rules/agentic-stack.md", "strong"),
+        (".windsurfrules", "strong"),
+    ],
     "openclaw": [(".openclaw-system.md", "strong")],
     "pi": [(".pi/extensions/memory-hook.ts", "strong")],
     "codex": [(".agents/skills", "strong")],