squadrant 0.9.0 → 0.9.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "squadrant",
   "packageManager": "pnpm@10.30.3",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Multi-project orchestration for your coding agents (Claude, Codex, opencode, Gemini)",
   "type": "module",
   "bin": {

package/scripts/migrate-to-squadrant.sh

@@ -2,10 +2,16 @@
 #
 # migrate-to-squadrant.sh — one-time live cutover from claude-cockpit → squadrant.
 #
-# Renames the runtime config dir, hub vault, daemon launchd label, and rewrites
-# config.json to the new brand. Idempotent (safe to re-run) and supports
-# --dry-run (prints every action and a concrete config-rewrite preview WITHOUT
-# mutating anything).
+# Renames the runtime config dir, hub vault, this project's spoke vault, the
+# repo folder, the local project key (projects.cockpit -> projects.squadrant),
+# the daemon launchd label, Claude Code's per-project session/memory dirs, and
+# rewrites config.json to the new brand.
+# Idempotent (safe to re-run) and supports --dry-run (prints every action and a
+# concrete config-rewrite preview WITHOUT mutating anything).
+#
+# The repo folder cannot mv itself while it is the running checkout, so Step 0
+# guards that: if invoked from the old repo it prints the exact `mv` to run and
+# exits. Re-run from the new path ($HOME/me/squadrant) to do the full cutover.
 #
 # This is run MANUALLY by the user at cutover — it terminates the live captain
 # session and bounces the daemon. The old daemon keeps running old `dist` until
@@ -24,14 +30,32 @@ case "${1:-}" in
   * ) echo "usage: $0 [--dry-run]" >&2; exit 2 ;;
 esac
 
+# Claude Code munges a project's absolute path into its state-dir name by
+# replacing every '/' and '.' with '-' (e.g. /Users/me/claude-cockpit ->
+# -Users-me-claude-cockpit, and the inner /.worktrees/ -> --worktrees-).
+munge_path() { local p="${1//\//-}"; printf '%s' "${p//./-}"; }
+
 OLD_CONFIG="$HOME/.config/cockpit"
 NEW_CONFIG="$HOME/.config/squadrant"
 OLD_HUB="$HOME/cockpit-hub"
 NEW_HUB="$HOME/squadrant-hub"
+OLD_REPO="$HOME/me/claude-cockpit"
+NEW_REPO="$HOME/me/squadrant"
+# Spoke vault for THIS project, addressed after the hub move (step 3).
+OLD_SPOKE="$NEW_HUB/spokes/cockpit"
+NEW_SPOKE="$NEW_HUB/spokes/squadrant"
 OLD_LABEL="com.cockpit.daemon"
 NEW_LABEL="com.squadrant.daemon"
 OLD_PLIST="$HOME/Library/LaunchAgents/${OLD_LABEL}.plist"
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+# Claude Code's per-project state (session .jsonl transcripts + memory/ auto-memory)
+# is keyed by the munged repo path, so the folder rename orphans it (the new path
+# starts empty). Renaming the state dir prefix re-links it to the renamed repo.
+CLAUDE_PROJECTS="$HOME/.claude/projects"
+OLD_MUNGED="$(munge_path "$OLD_REPO")"
+NEW_MUNGED="$(munge_path "$NEW_REPO")"
+# MIGRATE_REPO_ROOT lets --dry-run simulate running from the renamed repo
+# (to preview the full plan past the Step-0 guard); unset in real runs.
+REPO_ROOT="${MIGRATE_REPO_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
 UID_NUM="$(id -u)"
 TS="$(date +%Y%m%d-%H%M%S)"
 BACKUP="$HOME/squadrant-migration-backup-${TS}.tgz"
@@ -40,8 +64,9 @@ step() { printf '\n\033[1m== %s\033[0m\n' "$*"; }
 run() { printf '  $ %s\n' "$*"; [ "$DRY_RUN" -eq 1 ] || eval "$@"; }
 note() { printf '  · %s\n' "$*"; }
 
-# ---- config.json rewrite (pure, no claude-cockpit collisions: none of the
-#      rules match inside "claude-cockpit", so the real repo path is untouched).
+# ---- config.json rewrite (pure). Rules are scoped so only THIS project's
+#      brand strings change: "me/claude-cockpit" + "spokes/cockpit" are unique
+#      to the cockpit project, so the other 20+ projects' paths are untouched.
 rewrite_config() {  # $1=src json  $2=mode (apply <dest> | preview)
   local src="$1" mode="$2" dest="${3:-}"
   SRC="$src" MODE="$mode" DEST="$dest" python3 - <<'PY'
@@ -51,6 +76,8 @@ with open(src) as f:
     d = json.load(f)
 RULES = [("cockpit-hub", "squadrant-hub"),
          (".config/cockpit", ".config/squadrant"),
+         ("me/claude-cockpit", "me/squadrant"),
+         ("spokes/cockpit", "spokes/squadrant"),
          ("⚓ cockpit-captain", "⚓ squadrant-captain")]
 changes = []
 def fix(s):
@@ -69,6 +96,11 @@ def walk(o):
         return fix(o)
     return o
 d = walk(d)
+# Rename the project key projects.cockpit -> projects.squadrant (preserve order).
+if isinstance(d.get("projects"), dict) and "cockpit" in d["projects"]:
+    d["projects"] = {("squadrant" if k == "cockpit" else k): v
+                     for k, v in d["projects"].items()}
+    changes.append(("key:projects.cockpit", "key:projects.squadrant"))
 if "_cockpitVersion" in d:
     d["_squadrantVersion"] = d.pop("_cockpitVersion")
     changes.append(("key:_cockpitVersion", "key:_squadrantVersion"))
@@ -85,10 +117,14 @@ PY
 }
 
 printf '\033[1mSquadrant migration%s\033[0m\n' "$([ "$DRY_RUN" -eq 1 ] && echo ' (DRY RUN — nothing will change)')"
-note "repo:        $REPO_ROOT"
+note "repo:        $OLD_REPO  ->  $NEW_REPO"
 note "config:      $OLD_CONFIG  ->  $NEW_CONFIG"
 note "hub:         $OLD_HUB  ->  $NEW_HUB"
+note "spoke:       $OLD_SPOKE  ->  $NEW_SPOKE"
+note "project key: projects.cockpit  ->  projects.squadrant"
+note "sessions:    $CLAUDE_PROJECTS/$OLD_MUNGED*  ->  $NEW_MUNGED*"
 note "daemon:      $OLD_LABEL  ->  $NEW_LABEL"
+note "running from: $REPO_ROOT"
 
 # Already migrated? (new dir present, old gone) — nothing to do.
 if [ -d "$NEW_CONFIG" ] && [ ! -d "$OLD_CONFIG" ]; then
@@ -96,6 +132,31 @@ if [ -d "$NEW_CONFIG" ] && [ ! -d "$OLD_CONFIG" ]; then
   exit 0
 fi
 
+# ---- Step 0: the repo folder must already live at its new name. The script
+#      cannot mv its own running checkout, so if we are not in $NEW_REPO we
+#      print the exact move + re-run command and stop here.
+step "0. Repo folder rename (must run from the NEW path)"
+if [ "$REPO_ROOT" != "$NEW_REPO" ]; then
+  note "running from: $REPO_ROOT"
+  note "expected:     $NEW_REPO"
+  cat <<EOF
+
+  The repo folder still needs to be renamed, and this script cannot move its own
+  running checkout. Do it manually, then re-run from the new location:
+
+    # 1. close captains (cmux) so nothing holds the old path open
+    # 2. move the repo folder:
+    mv '$OLD_REPO' '$NEW_REPO'
+    # 3. re-run this script from the renamed repo:
+    bash '$NEW_REPO/scripts/migrate-to-squadrant.sh'$([ "$DRY_RUN" -eq 1 ] && echo ' --dry-run')
+
+  (The daemon plist and the global npm link both point at the repo dir; moving it
+   first lets steps 6-7 relink and bootstrap from the new location.)
+EOF
+  exit 0
+fi
+note "running from $NEW_REPO ✓"
+
 step "1. Backup ~/.config/cockpit and ~/cockpit-hub"
 # Archive with paths RELATIVE to $HOME so rollback is `tar xzf <backup> -C $HOME`.
 BACKUP_RELS=()
@@ -112,11 +173,13 @@ step "2. Stop captains + bootout the old daemon"
 note "Captains are cmux workspaces — close them in cmux, or let the relaunch below recreate them."
 run "launchctl bootout gui/${UID_NUM}/${OLD_LABEL} 2>/dev/null || true"
 
-step "3. Move config dir and hub vault"
+step "3. Move config dir, hub vault, and this project's spoke vault"
 if [ -d "$OLD_CONFIG" ] && [ ! -d "$NEW_CONFIG" ]; then run "mv '$OLD_CONFIG' '$NEW_CONFIG'"; else note "config move skipped (old absent or new exists)"; fi
 if [ -d "$OLD_HUB" ] && [ ! -d "$NEW_HUB" ]; then run "mv '$OLD_HUB' '$NEW_HUB'"; else note "hub move skipped (old absent or new exists)"; fi
+# Spoke lives under the hub; source check covers both pre- and post-hub-move location.
+if { [ -d "$OLD_SPOKE" ] || [ -d "$OLD_HUB/spokes/cockpit" ]; } && [ ! -d "$NEW_SPOKE" ]; then run "mv '$OLD_SPOKE' '$NEW_SPOKE'"; else note "spoke move skipped (source absent or target exists)"; fi
 
-step "4. Rewrite config.json (cockpit-hub→squadrant-hub, .config/cockpit→.config/squadrant, ⚓ cockpit-captain→⚓ squadrant-captain, _cockpitVersion key)"
+step "4. Rewrite config.json (cockpit-hub→squadrant-hub, .config/cockpit→.config/squadrant, me/claude-cockpit→me/squadrant, spokes/cockpit→spokes/squadrant, ⚓ cockpit-captain→⚓ squadrant-captain, projects.cockpit→projects.squadrant key, _cockpitVersion key)"
 if [ "$DRY_RUN" -eq 1 ]; then
   CFG_SRC="$OLD_CONFIG/config.json"; [ -f "$CFG_SRC" ] || CFG_SRC="$NEW_CONFIG/config.json"
   if [ -f "$CFG_SRC" ]; then rewrite_config "$CFG_SRC" preview; else note "no config.json found to preview"; fi
@@ -131,10 +194,69 @@ else
   fi
 fi
 
+step "4.5 Preserve Claude Code session history + auto-memory (rename per-project state dirs)"
+# The main project dir ($OLD_MUNGED) holds the session .jsonl transcripts and the
+# memory/ subdir; its worktree dirs ($OLD_MUNGED--worktrees-*) share the prefix and
+# are orphaned by the SAME folder rename. Swap the prefix on each so the renamed
+# repo finds them. Pure rename — no data is copied or deleted (idempotent: skips
+# any dir whose new-name target already exists).
+if [ -d "$CLAUDE_PROJECTS" ] && [ -n "$OLD_MUNGED" ]; then
+  main_dir="$CLAUDE_PROJECTS/$OLD_MUNGED"
+  if [ -d "$main_dir" ]; then
+    sessions="$(find "$main_dir" -maxdepth 1 -name '*.jsonl' 2>/dev/null | wc -l | tr -d ' ')"
+    mem="$([ -d "$main_dir/memory" ] && find "$main_dir/memory" -type f 2>/dev/null | wc -l | tr -d ' ' || echo 0)"
+    note "main project dir: $sessions session transcript(s), $mem auto-memory file(s) to preserve"
+  fi
+  migrated=0; skipped=0
+  shopt -s nullglob
+  for src in "$CLAUDE_PROJECTS/$OLD_MUNGED" "$CLAUDE_PROJECTS/$OLD_MUNGED-"*; do
+    [ -d "$src" ] || continue
+    base="$(basename "$src")"
+    dest="$CLAUDE_PROJECTS/${NEW_MUNGED}${base#"$OLD_MUNGED"}"
+    if [ -e "$dest" ]; then note "skip (target exists): $base"; skipped=$((skipped + 1)); continue; fi
+    run "mv '$src' '$dest'"
+    migrated=$((migrated + 1))
+  done
+  shopt -u nullglob
+  note "$([ "$DRY_RUN" -eq 1 ] && echo 'would migrate' || echo 'migrated') $migrated state dir(s) (main + worktrees); skipped $skipped"
+else
+  note "no $CLAUDE_PROJECTS dir — skipping session/memory preservation"
+fi
+
+step "4.6 Rewrite stale 'cockpit crew _hook' commands in Claude Code settings files"
+# The hook-generation source already emits `squadrant crew _hook`, but settings
+# files written on disk BEFORE the rebrand still invoke the removed `cockpit`
+# binary, so every Stop/PostToolUse hook in the captain (and any pre-rebrand crew)
+# fails with "cockpit: command not found". Rewrite the command token in place.
+# Scoped to the leading "cockpit crew _hook" so permission patterns like
+# Bash(cockpit:*) are left untouched. Idempotent (a second run matches nothing).
+HOOK_SETTINGS=(
+  "$NEW_REPO/.claude/settings.json"
+  "$NEW_REPO/.claude/settings.local.json"
+  "$HOME/.claude/settings.json"
+  "$HOME/.claude/settings.local.json"
+)
+hooks_fixed=0
+for sf in "${HOOK_SETTINGS[@]}"; do
+  [ -f "$sf" ] || continue
+  if grep -q 'cockpit crew _hook' "$sf" 2>/dev/null; then
+    run "sed -i '' 's/cockpit crew _hook/squadrant crew _hook/g' '$sf'"
+    hooks_fixed=$((hooks_fixed + 1))
+  else
+    note "ok (no stale hook): $sf"
+  fi
+done
+note "$([ "$DRY_RUN" -eq 1 ] && echo 'would rewrite' || echo 'rewrote') hook command in $hooks_fixed settings file(s)"
+
 step "5. Remove old launchd plist (the rebuilt daemon installs com.squadrant.daemon.plist on first run)"
 [ -f "$OLD_PLIST" ] && run "rm -f '$OLD_PLIST'" || note "old plist absent"
 
 step "6. Build the rebranded binary + relink the global 'squadrant'/'squad' bin"
+# Reinstall FIRST: the repo-folder rename (Step 0) leaves pnpm's workspace symlinks
+# pointing at the old @cockpit/* package dirs, so a build before `install` aborts
+# with hundreds of unresolved-import errors. `install` regenerates the links for
+# the @squadrant/* packages at their new path; only then can the build resolve them.
+run "pnpm -C '$REPO_ROOT' install"
 run "pnpm -C '$REPO_ROOT' build"
 run "pnpm -C '$REPO_ROOT' link --global"
 note "removes the old global 'cockpit' bin; 'squadrant' and 'squad' now resolve to $REPO_ROOT/dist/index.js"
@@ -150,9 +272,15 @@ cat <<EOF
     2. Verify CLI:      squadrant --version   (expect 0.9.0)   and   squad --help
     3. Relaunch captains:  squadrant launch <project>   (recreates the ⚓ squadrant-captain workspaces)
     4. Tail the log:    tail -f ${NEW_CONFIG}/squadrantd.log
+    5. Verify sessions: ls ${CLAUDE_PROJECTS}/${NEW_MUNGED}/   (your history + memory/ should be here)
   Rollback (if needed):
     launchctl bootout gui/${UID_NUM}/${NEW_LABEL} 2>/dev/null || true
     rm -rf ${NEW_CONFIG} ${NEW_HUB}
     tar xzf ${BACKUP} -C ${HOME}
+    mv ${NEW_REPO} ${OLD_REPO}    # move the repo folder back
+    # session/memory dirs are pure renames — move them back by prefix:
+    for d in ${CLAUDE_PROJECTS}/${NEW_MUNGED} ${CLAUDE_PROJECTS}/${NEW_MUNGED}-*; do
+      [ -d "\$d" ] && mv "\$d" "${CLAUDE_PROJECTS}/${OLD_MUNGED}\${d#${CLAUDE_PROJECTS}/${NEW_MUNGED}}"
+    done
     # then reinstall the old plist + relink the old 'cockpit' bin
 EOF

package/scripts/remap-claude-mem.sh

@@ -0,0 +1,206 @@
+#!/usr/bin/env bash
+#
+# remap-claude-mem.sh — unify a claude-mem project slug after a repo rebrand.
+#
+# Usage:
+#   scripts/remap-claude-mem.sh [--dry-run] [OLD_SLUG] [NEW_SLUG]
+#   scripts/remap-claude-mem.sh --dry-run                 # preview, mutate nothing
+#   scripts/remap-claude-mem.sh                           # claude-cockpit -> squadrant
+#   scripts/remap-claude-mem.sh --dry-run cockpit-old squadrant
+#
+# WHAT IT DOES
+#   Makes a claude-mem project's history follow a rebrand so that, when you work
+#   in the renamed repo, the old project's memory surfaces under the new slug.
+#
+#   Default mapping (after the claude-cockpit -> squadrant rebrand):
+#       claude-cockpit            -> squadrant          (the main project)
+#       claude-cockpit/<worktree> -> squadrant/<worktree> (per-worktree subslugs)
+#       cwd .../me/claude-cockpit -> .../me/squadrant    (pending_messages queue)
+#
+# APPROACH — native `merged_into_project`, NOT a destructive project rewrite
+#   claude-mem already ships a "worktree adoption" mechanism that unifies slugs by
+#   setting observations.merged_into_project / session_summaries.merged_into_project
+#   to the target, and its read path resolves it everywhere:
+#       - session-start injection (context-generator) queries SQLite directly with
+#         `WHERE (o.project = ? OR o.merged_into_project = ?)`
+#       - semantic search (chroma) filters `{$or:[{project},{merged_into_project}]}`
+#   So pointing merged_into_project at the new slug surfaces the old rows under it.
+#   This is the approach claude-mem itself supports — chosen over rewriting
+#   `project` because it is additive, non-destructive, and reversible (the column
+#   was NULL before; the .db backup restores the exact prior state).
+#
+#   Tables WITHOUT a merge column (sdk_sessions.project, pending_messages.cwd) are
+#   session/queue metadata, not searchable memory, and are not vector-stored — for
+#   those we rewrite the literal value (the only mechanism available, FTS-safe).
+#
+# FTS5 — no rebuild needed
+#   observations_fts / session_summaries_fts / user_prompts_fts index only CONTENT
+#   columns (title, narrative, text, ...), NOT project/merged_into_project. We
+#   change no FTS-indexed column, and the AFTER UPDATE triggers re-sync FTS from
+#   the (unchanged) content automatically. So FTS stays consistent with zero work.
+#
+# CHROMA (vector store) — intentionally NOT touched (see below)
+#   claude-mem's chroma runs as an EMBEDDED persistent store
+#   (`chroma-mcp --client-type persistent --data-dir ~/.claude-mem/chroma`), held
+#   EXCLUSIVELY by the running claude-mem worker. There is no HTTP endpoint. The
+#   only supported write path is the worker's own `chroma_update_documents`, which
+#   is invoked exclusively during worktree adoption — there is NO claude-mem CLI
+#   command to re-attribute existing docs, and a second process writing the
+#   persistent store (or raw-editing chroma.sqlite3) risks corruption. We therefore
+#   do NOT mutate chroma here.
+#
+#   Impact: the SQLite change above fully fixes the PRIMARY surface — the memory
+#   injected at session start (which reads SQLite directly). The only gap is that
+#   EXPLICIT semantic search (mem-search / smart_search MCP tools) will keep
+#   attributing pre-rebrand observations to the OLD slug until their chroma
+#   metadata is patched. Safest fallback for that, when it matters:
+#       - new post-rebrand observations are searchable under the new slug already;
+#       - to re-attribute the historical vectors, ask claude-mem upstream for a
+#         re-sync/merge command, or stop the worker and run a one-off
+#         chroma_update_documents pass — do NOT edit chroma.sqlite3 by hand.
+#
+# TESTING — never touches the live DB unless you point it there
+#   Set CLAUDE_MEM_HOME to a temp dir containing a COPY of claude-mem.db to dry-run
+#   and apply against the copy. Make a consistent snapshot copy with:
+#       sqlite3 "file:$HOME/.claude-mem/claude-mem.db?immutable=1" \
+#               "VACUUM INTO '/tmp/cm-test/claude-mem.db'"
+#       CLAUDE_MEM_HOME=/tmp/cm-test scripts/remap-claude-mem.sh --dry-run
+#
+# WHEN TO RUN (live)
+#   Run this ONCE, AFTER the repo cutover, while claude-mem is quiet. First confirm
+#   the real new slug claude-mem assigns to the renamed repo (run any session in
+#   .../me/squadrant and check `project` in a fresh observation), then run this with
+#   that slug as NEW_SLUG. Idempotent: safe to re-run; a second run changes 0 rows.
+#
+set -euo pipefail
+
+DRY_RUN=0
+POS=()
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY_RUN=1 ;;
+    -h|--help) sed -n '2,80p' "$0" | sed 's/^#//'; exit 0 ;;
+    --*) echo "unknown flag: $arg" >&2; echo "usage: $0 [--dry-run] [OLD_SLUG] [NEW_SLUG]" >&2; exit 2 ;;
+    *) POS+=("$arg") ;;
+  esac
+done
+
+OLD_SLUG="${POS[0]:-claude-cockpit}"
+NEW_SLUG="${POS[1]:-squadrant}"
+
+# Slugs are interpolated into SQL; restrict to a safe charset (no quotes/slashes).
+slug_ok() { [[ "$1" =~ ^[A-Za-z0-9._-]+$ ]]; }
+slug_ok "$OLD_SLUG" || { echo "invalid OLD_SLUG: '$OLD_SLUG' (allowed: A-Za-z0-9._-)" >&2; exit 2; }
+slug_ok "$NEW_SLUG" || { echo "invalid NEW_SLUG: '$NEW_SLUG' (allowed: A-Za-z0-9._-)" >&2; exit 2; }
+[ "$OLD_SLUG" = "$NEW_SLUG" ] && { echo "OLD_SLUG and NEW_SLUG are identical — nothing to do." >&2; exit 2; }
+
+CLAUDE_MEM_HOME="${CLAUDE_MEM_HOME:-$HOME/.claude-mem}"
+DB="$CLAUDE_MEM_HOME/claude-mem.db"
+# Repo working-copy paths recorded in pending_messages.cwd (overridable for tests).
+OLD_CWD="${OLD_CWD:-$HOME/me/$OLD_SLUG}"
+NEW_CWD="${NEW_CWD:-$HOME/me/$NEW_SLUG}"
+TS="$(date +%Y%m%d-%H%M%S)"
+BACKUP="$DB.bak-rebrand-$TS"
+
+step() { printf '\n\033[1m== %s\033[0m\n' "$*"; }
+note() { printf '  · %s\n' "$*"; }
+
+command -v sqlite3 >/dev/null || { echo "sqlite3 not found on PATH" >&2; exit 1; }
+[ -f "$DB" ] || { echo "claude-mem DB not found: $DB" >&2; exit 1; }
+
+# Read-only count helper (immutable open: never creates/locks WAL on the source).
+roq() { sqlite3 "file:$DB?immutable=1" "$1"; }
+
+printf '\033[1mclaude-mem slug remap%s\033[0m\n' "$([ "$DRY_RUN" -eq 1 ] && echo ' (DRY RUN — nothing will change)')"
+note "db:       $DB"
+note "old slug: $OLD_SLUG   (+ subslugs $OLD_SLUG/<worktree>)"
+note "new slug: $NEW_SLUG"
+note "cwd:      $OLD_CWD  ->  $NEW_CWD"
+
+# ---- Per-table counts of rows that WOULD change (same predicates as the UPDATEs).
+OBS_N=$(roq "SELECT COUNT(*) FROM observations WHERE (project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%' OR merged_into_project='$OLD_SLUG') AND (merged_into_project IS NULL OR merged_into_project<>'$NEW_SLUG');")
+SUM_N=$(roq "SELECT COUNT(*) FROM session_summaries WHERE (project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%' OR merged_into_project='$OLD_SLUG') AND (merged_into_project IS NULL OR merged_into_project<>'$NEW_SLUG');")
+SDK_N=$(roq "SELECT COUNT(*) FROM sdk_sessions WHERE project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%';")
+PEND_N=$(roq "SELECT COUNT(*) FROM pending_messages WHERE cwd='$OLD_CWD' OR cwd LIKE '$OLD_CWD/%';")
+
+OBS_TOTAL_BEFORE=$(roq "SELECT COUNT(*) FROM observations;")
+RESOLVE_BEFORE=$(roq "SELECT COUNT(*) FROM observations WHERE project='$NEW_SLUG' OR merged_into_project='$NEW_SLUG';")
+
+step "Rows that would change"
+note "observations.merged_into_project -> $NEW_SLUG : $OBS_N"
+note "session_summaries.merged_into_project -> $NEW_SLUG : $SUM_N"
+note "sdk_sessions.project rewrite : $SDK_N"
+note "pending_messages.cwd rewrite : $PEND_N"
+note "(observations resolvable under '$NEW_SLUG' now: $RESOLVE_BEFORE of $OBS_TOTAL_BEFORE total)"
+
+if [ "$((OBS_N + SUM_N + SDK_N + PEND_N))" -eq 0 ]; then
+  step "Nothing to remap — already unified under '$NEW_SLUG' (idempotent no-op)."
+  exit 0
+fi
+
+if [ "$DRY_RUN" -eq 1 ]; then
+  step "Dry run complete — no changes written."
+  exit 0
+fi
+
+# ---- Backup is mandatory. Refuse to proceed if it fails. (Chroma is not touched,
+#      so only the .db is backed up — see header.)
+step "Backup claude-mem.db (required)"
+cp "$DB" "$BACKUP" || { echo "backup failed — aborting, nothing changed" >&2; exit 1; }
+note "backup -> $BACKUP   (rollback: cp '$BACKUP' '$DB')"
+
+# ---- Apply, single transaction. busy_timeout tolerates a briefly-active worker;
+#      still, run this while claude-mem is quiet (see header).
+step "Apply remap (single transaction)"
+sqlite3 "$DB" <<SQL
+.timeout 10000
+BEGIN IMMEDIATE;
+
+UPDATE observations
+   SET merged_into_project='$NEW_SLUG'
+ WHERE (project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%' OR merged_into_project='$OLD_SLUG')
+   AND (merged_into_project IS NULL OR merged_into_project<>'$NEW_SLUG');
+
+UPDATE session_summaries
+   SET merged_into_project='$NEW_SLUG'
+ WHERE (project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%' OR merged_into_project='$OLD_SLUG')
+   AND (merged_into_project IS NULL OR merged_into_project<>'$NEW_SLUG');
+
+-- sdk_sessions has no merge column: rewrite the literal project (main + subslugs).
+UPDATE sdk_sessions SET project='$NEW_SLUG' WHERE project='$OLD_SLUG';
+UPDATE sdk_sessions
+   SET project='$NEW_SLUG' || substr(project, length('$OLD_SLUG') + 1)
+ WHERE project LIKE '$OLD_SLUG/%';
+
+-- pending_messages queue: re-point the repo working-copy path.
+UPDATE pending_messages
+   SET cwd='$NEW_CWD' || substr(cwd, length('$OLD_CWD') + 1)
+ WHERE cwd='$OLD_CWD' OR cwd LIKE '$OLD_CWD/%';
+
+COMMIT;
+SQL
+note "transaction committed"
+
+# ---- Verify: history now resolves under the new slug and nothing was lost.
+step "Verify"
+OBS_TOTAL_AFTER=$(roq "SELECT COUNT(*) FROM observations;")
+RESOLVE_AFTER=$(roq "SELECT COUNT(*) FROM observations WHERE project='$NEW_SLUG' OR merged_into_project='$NEW_SLUG';")
+OLD_LEFT=$(roq "SELECT COUNT(*) FROM sdk_sessions WHERE project='$OLD_SLUG' OR project LIKE '$OLD_SLUG/%';")
+
+note "observations total: $OBS_TOTAL_BEFORE -> $OBS_TOTAL_AFTER"
+note "observations resolvable under '$NEW_SLUG': $RESOLVE_BEFORE -> $RESOLVE_AFTER"
+note "sdk_sessions still on old slug: $OLD_LEFT (expect 0)"
+
+# Data loss = the total DECREASED. A live observer can legitimately INSERT new
+# rows mid-remap (we never DELETE), so AFTER > BEFORE is expected and fine; only
+# AFTER < BEFORE means rows were lost. (Strict `-ne` here false-alarmed on that.)
+if [ "$OBS_TOTAL_AFTER" -lt "$OBS_TOTAL_BEFORE" ]; then
+  echo "FATAL: observation count dropped ($OBS_TOTAL_BEFORE -> $OBS_TOTAL_AFTER) — DATA LOSS. Restore: cp '$BACKUP' '$DB'" >&2
+  exit 1
+fi
+if [ "$OLD_LEFT" -ne 0 ]; then
+  echo "WARN: $OLD_LEFT sdk_sessions still on old slug (unexpected)." >&2
+fi
+
+step "Done — '$OLD_SLUG' history now resolves under '$NEW_SLUG'."
+note "Re-run is a safe no-op. Chroma semantic search re-attribution: see header (intentionally not modified)."

package/scripts/notify-relay-placement-smoke.mjs

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-// Live E2E for #117: spawnInjector("hidden") must NOT create a split-pane and
-// must NOT steal focus. Drives the real built cmux driver against a throwaway
-// cmux workspace, then inspects `cmux tree` to assert:
-//   1. the workspace has exactly ONE pane (a split would create a second)
-//   2. the relay surface exists as a background tab in that pane
-//   3. the surface selected before spawn is still [selected] afterward
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { join } from "node:path";
-
-const CMUX = "/Applications/cmux.app/Contents/Resources/bin/cmux";
-const cmux = (args) => execFileSync(CMUX, args, { encoding: "utf-8" }).trim();
-const __dirname = fileURLToPath(new URL(".", import.meta.url));
-const { createCmuxDriver } = await import(
-  "file://" + join(__dirname, "..", "dist", "runtimes", "cmux.js")
-);
-
-let failures = 0;
-const assert = (cond, label) => {
-  console.log(`  ${cond ? "✓" : "✗"} ${label}`);
-  if (!cond) failures++;
-};
-
-const out = cmux(["new-workspace", "--cwd", "/tmp", "--command", "bash"]);
-const ws = out.match(/workspace:\d+/)?.[0];
-cmux(["rename-workspace", "--workspace", ws, "zz-117-smoke"]);
-const driver = createCmuxDriver();
-
-try {
-  const treeBefore = cmux(["tree", "--workspace", ws]);
-  const capSurface = treeBefore.match(/(surface:\d+)\s+\[terminal\][^\n]*\[selected\]/)?.[1];
-  console.log(`workspace=${ws} captain surface=${capSurface}`);
-
-  const pane = await driver.spawnInjector({
-    captainWorkspace: { id: ws, name: "zz-117-smoke", status: "running" },
-    command: "echo notify-relay-stub; sleep 30",
-    title: "✉ notify-relay",
-    placement: "hidden",
-  });
-  console.log(`spawnInjector returned ${pane.surfaceId}`);
-
-  const tree = cmux(["tree", "--workspace", ws]);
-  console.log("--- tree after spawnInjector(hidden) ---\n" + tree);
-
-  const paneCount = (tree.match(/^\s*[├└]?[─ ]*pane\s+pane:\d+/gm) || []).length;
-  assert(paneCount === 1, `exactly ONE pane — no split (got ${paneCount})`);
-
-  const surfaces = (tree.match(/surface:\d+/g) || []);
-  assert(surfaces.includes(pane.surfaceId), `relay surface ${pane.surfaceId} present as a tab`);
-
-  const selected = tree.match(/(surface:\d+)\s+\[terminal\][^\n]*\[selected\]/)?.[1];
-  assert(selected === capSurface, `captain surface ${capSurface} still [selected] (relay did NOT steal focus; got ${selected})`);
-
-  console.log(`\n${failures === 0 ? "✔ PLACEMENT SMOKE PASSED" : `✗ ${failures} FAILURES`}`);
-} finally {
-  cmux(["close-workspace", "--workspace", ws]);
-  process.exit(failures > 0 ? 1 : 0);
-}