fix(tmux): confirm delivery by draft transition, not by prompt glyph (#1257)

send-message.sh located the REPL input box with grep -E '❯|^>|│ >'. That set is
Claude Code's box. A pi seat renders a bare U+2500 rule with no glyph, so on every
idle pi seat the capture succeeded, the grep matched nothing, status stayed
"unconfirmed", and the tool exited 2 "may be UNDELIVERED" with the paste and the
Enter both landed. The stderr tells the operator to retry, and that retry is the
duplicate delivery reported against the same tool.

Confirmation is now runtime-agnostic: our message tail sits on the input line
(located by cursor row, no glyph) before Enter and has left it after. That
transition is positive proof of submission.

Absence still proves nothing, which is the guard the 2026-08 fix was reaching for
and got backwards. Two positive checks keep it:

  - a prompt box that IS locatable and still carries our tail => draft, exit 2.
    This covers the cursor-row blind spot: a cooked pane whose foreground process
    never reads stdin echoes the paste through the kernel line discipline and
    moves the cursor off it on Enter, which by cursor row alone is indistinguishable
    from a real submit.
  - no draft ever observed on the input line => unconfirmed, non-zero.

Tests, both red-first against the shipping blob d397907:

  test-send-message-glyph-agnostic.sh (new, 6 fixtures)  4/6 -> 6/6
  test-send-message-verdict.sh (fixture 2 reshaped, 2b added)  3/4 -> 4/4

Fixture 2 of the verdict suite asserted exit 2 for a glyphless pane that submits
and was labelled "false-positive FIXED". A pi seat is that fixture, so the suite
was locking the bug in. It is reshaped deliberately, and the guard it was credited
with moves to new fixture 2b (glyphless AND non-submitting, raw/no-echo) so the
"never infer delivered from absence" property is tested positively rather than as
a side effect.

Measured on tmux 3.7b (sb-it-1-dt), 3.5a (fomo-lin), and dragon-lin.

Co-authored-by: scooby <[email protected]>

packages/mosaic/framework/tools/tmux/send-message.sh

@@ -97,13 +97,34 @@ printf '%s' "$MSG" | "${tmux_cmd[@]}" load-buffer -b "$BUF" -
 #   would otherwise accumulate forever.
 sleep 0.5
 
-# 2) Submit, then POSITIVELY confirm submission; flush with another Enter if it is
-#    still a draft. Success requires positive evidence — the queued banner, OR the
-#    REPL input box located AND clear of our message tail. The historical bug was
-#    treating ABSENCE of a draft as delivery: if the prompt glyph was never matched
-#    (wrong pane / prompt-glyph drift), an unsubmitted message read as "delivered"
-#    and worker->lead relays stalled silently. We now default to UNCONFIRMED and only
-#    upgrade to delivered on positive evidence; anything we cannot confirm fails loud.
+# 2) Submit, then POSITIVELY confirm submission by DRAFT TRANSITION, not by prompt
+#    glyph. The historical bug was treating ABSENCE of a draft as delivery; the
+#    2026-08 fix over-corrected to glyph inference (grep '❯|^>|│ >'), which locates
+#    only Claude Code's box and false-NEGATIVES every glyphless REPL (pi renders a
+#    U+2500 rule, no glyph) — a delivered message reported "UNDELIVERED", driving a
+#    retry that duplicates it. Runtime-agnostic evidence: our message tail sits on
+#    the INPUT line (located by the cursor row, not a glyph) BEFORE Enter, and has
+#    LEFT it AFTER — that transition is positive proof of submission and needs no
+#    glyph. Absence alone still never means delivered: if we never saw our draft on
+#    the input line we stay UNCONFIRMED (wrong/dead pane), and a draft that never
+#    leaves the input line stays a DRAFT (exit 2), preserving both historical guards.
+_cursor_line() { # echo the pane's current input (cursor) line, glyph-free
+  local cy line
+  cy=$("${tmux_cmd[@]}" display-message -p -t "$EFFECTIVE_TARGET" -F '#{cursor_y}' 2>/dev/null) || return 1
+  [ -n "$cy" ] || return 1
+  "${tmux_cmd[@]}" capture-pane -t "$EFFECTIVE_TARGET" -p 2>/dev/null | sed -n "$((cy + 1))p"
+}
+_draft_on_input() { # true iff our message tail is sitting on the input line now
+  [ -n "$snippet" ] || return 1
+  printf '%s' "$(_cursor_line)" | grep -qF "$snippet"
+}
+
+# Baseline: after the paste, our draft must be on the input line. This is positive
+# proof we are on the right pane and the paste landed — the anchor the transition
+# check measures against.
+saw_draft=0
+_draft_on_input && saw_draft=1
+
 status="unconfirmed"
 for attempt in $(seq 1 $((RETRIES + 1))); do
   "${tmux_cmd[@]}" send-keys -t "$EFFECTIVE_TARGET" Enter
@@ -113,20 +134,26 @@ for attempt in $(seq 1 $((RETRIES + 1))); do
   if printf '%s' "$pane" | grep -qF "$QUEUED_RE"; then
     status="queued"; break
   fi
-  # Locate the REPL input box (prompt glyph). If we cannot see it, we have NO
-  # evidence of submission state — stay UNCONFIRMED and retry; never infer delivery.
+  # POSITIVE draft evidence from a located prompt box, when one exists. This is the
+  # cursor-row check's blind spot: a pane in COOKED mode (a plain shell whose
+  # foreground process never reads stdin) echoes our paste via the kernel line
+  # discipline and moves the cursor off it on Enter, which is indistinguishable from
+  # a real submit by cursor row alone. If a prompt box IS locatable and still carries
+  # our tail, that is affirmative proof the message was not consumed. Absence of a
+  # glyph is still never used for anything — that inference is the original E7 bug.
   promptline=$(printf '%s' "$pane" | grep -E '❯|^>|│ >' | tail -1)
-  if [ -z "$promptline" ]; then
-    status="unconfirmed"; continue
-  fi
-  # Input box located AND still carrying our tail => unsubmitted draft. Flush + retry.
-  # (Submitted messages scroll up into history; a draft stays on the ❯ line.)
-  if [ -n "$snippet" ] && printf '%s' "$promptline" | grep -qF "$snippet"; then
+  if [ -n "$promptline" ] && [ -n "$snippet" ] && printf '%s' "$promptline" | grep -qF "$snippet"; then
     status="draft"; continue
   fi
-  # Input box located AND clear of our tail => positively submitted. This is the
-  # only path to success besides the queued banner.
-  status="delivered"; break
+  if [ "$saw_draft" = 1 ]; then
+    if _draft_on_input; then
+      status="draft"; continue      # still on the input line => not submitted; flush + retry
+    fi
+    status="delivered"; break        # left the input line => positively submitted
+  fi
+  # No confirmed baseline yet: try to (re)acquire it; never infer delivery from absence.
+  if _draft_on_input; then saw_draft=1; status="draft"; continue; fi
+  status="unconfirmed"; continue
 done
 
 [ "$VERBOSE" = 1 ] && { echo "--- pane tail ($TARGET) ---"; printf '%s\n' "$pane" | tail -4; echo "---"; }

packages/mosaic/framework/tools/tmux/test-send-message-glyph-agnostic.sh

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+# Red-first regression test for E7 (#1017 task 2): the confirm-check must bind
+# "delivered" to WHETHER THE MESSAGE WAS SUBMITTED, not to which runtime's prompt
+# glyph is present. A pi seat renders a U+2500 rule input box with no ❯/^>/│ >
+# glyph; send-message.sh:118 locates the box only by glyph, so a genuinely
+# delivered message on a glyphless REPL falsely reports exit 2 "may be UNDELIVERED",
+# and the operator's rc=2-driven retry duplicates it.
+#
+# Parameterized on $SEND: RED against the shipping blob (B and D fail), GREEN
+# against a candidate patch. No pi; no fake HOME; hermetic throwaway socket.
+#
+# Submission counting is EXACT and terminal-echo-independent: the fixture message
+# is `echo <tok> >>SINK`; each real submission appends one line. wc -l SINK ==
+# number of times the REPL actually executed the send. This does not depend on how
+# many times the marker string is painted on screen.
+set -u
+SEND="${SEND:?set SEND=/path/to/send-message.sh}"
+SOCKET="glyphagnostic-$$"
+TMP="$(mktemp -d)"
+tmux() { command tmux -L "$SOCKET" "$@"; }
+cleanup() { command tmux -L "$SOCKET" kill-server 2>/dev/null; rm -rf "$TMP"; }
+trap cleanup EXIT
+pass=0; fail=0
+ok() { printf 'ok   %s\n' "$1"; pass=$((pass+1)); }
+no() { printf 'FAIL %s -- %s\n' "$1" "$2"; fail=$((fail+1)); }
+
+mk() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" "PS1='$2' exec bash --noprofile --norc -i"; sleep 0.5; }
+subs() { [ -f "$1" ] && wc -l <"$1" | tr -d ' ' || echo 0; }  # exact submission count
+
+echo "SEND=$SEND    tmux $(command tmux -V | awk '{print $2}')"
+
+# --- A (control): glyph box (❯) that submits => exit 0, exactly one submission.
+mk ctl '❯ '
+SINK="$TMP/sink.ctl"
+out=$("$SEND" -L "$SOCKET" -t ctl -m "echo x >>'$SINK'" 2>"$TMP/e.ctl"); rc=$?; sleep 0.4
+if [ "$rc" = 0 ] && [ "$(subs "$SINK")" = 1 ]; then
+  ok "control: ❯-box submits => exit 0, exactly one submission"
+else no "control: ❯-box submits => exit 0, one submission" "rc=$rc subs=$(subs "$SINK") err=[$(cat "$TMP/e.ctl")]"; fi
+
+# --- B (THE false-rc regression): glyphless U+2500 box that SUBMITS. Message lands
+#     (subs==1) yet shipping reports exit 2. Must be exit 0.
+mk sub $'──────── \n'
+SINK="$TMP/sink.sub"
+out=$("$SEND" -L "$SOCKET" -t sub -m "echo x >>'$SINK'" 2>"$TMP/e.sub"); rc=$?; sleep 0.4
+if [ "$rc" = 0 ] && [ "$(subs "$SINK")" = 1 ]; then
+  ok "glyphless: U+2500 box that submits => exit 0 (delivered, not 'UNDELIVERED')"
+else no "glyphless: U+2500 box that submits => exit 0" \
+        "rc=$rc subs=$(subs "$SINK")(delivered=$([ "$(subs "$SINK")" -ge 1 ] && echo yes||echo no)) err=[$(cat "$TMP/e.sub")]"; fi
+
+# --- D (duplicate arm): operator follows the rc=2 stderr and retries once. On the
+#     glyphless box, shipping => two submissions (the reported duplicate). The
+#     property: one logical send => exactly one submission. Same fix closes it.
+mk dup $'──────── \n'
+SINK="$TMP/sink.dup"
+tries=0
+for attempt in 1 2; do
+  tries=$((tries+1))
+  out=$("$SEND" -L "$SOCKET" -t dup -m "echo x >>'$SINK'" 2>/dev/null); rc=$?
+  sleep 0.4
+  [ "$rc" = 0 ] && break   # operator stops retrying only when told delivered
+done
+if [ "$(subs "$SINK")" = 1 ]; then
+  ok "duplicate: one logical send (rc-driven retry) => exactly one submission (tries=$tries)"
+else no "duplicate: one logical send => exactly one submission" "submissions=$(subs "$SINK") tries=$tries"; fi
+
+# --- E (faithful hung managed TUI, NOT a cooked shell): raw/no-echo, paints nothing.
+#     A cooked `sleep infinity` echoes the paste via the kernel line discipline and
+#     false-passes a cursor-row fix that is correct on real seats (measured). So: raw.
+mk_rawstuck() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" \
+  "bash --noprofile --norc -c 'stty -echo -icanon min 1 time 0 2>/dev/null; exec sleep infinity'"; sleep 0.5; }
+mk_rawstuck estuck
+SINK="$TMP/sink.estuck"
+out=$("$SEND" -L "$SOCKET" -t estuck -r 1 -m "this stuck draft was never submitted" 2>/dev/null); rc=$?
+sleep 0.3
+if [ "$rc" != 0 ] && [ "$(subs "$SINK")" = 0 ]; then
+  ok "raw/no-echo stuck TUI (not submitted) => non-zero (no false delivered)"
+else no "raw stuck TUI must NOT report delivered" "rc=$rc subs=$(subs "$SINK")"; fi
+
+# --- F (busy/queued branch, your BUSY-not-runtime finding): glyphless pane rendering the
+#     queued banner, never consuming. QUEUED_RE :113 fires before the glyph grep => rc=0.
+mk_busy() { tmux new-session -d -s "$1" -x 120 -y 40 -c "$TMP" \
+  "bash --noprofile --norc -c 'printf \"Press up to edit queued messages\n\"; exec sleep infinity'"; sleep 0.5; }
+mk_busy ebusy
+SINK="$TMP/sink.ebusy"
+out=$("$SEND" -L "$SOCKET" -t ebusy -m "echo x >>'$SINK'" 2>/dev/null); rc=$?; sleep 0.3
+if [ "$rc" = 0 ]; then
+  ok "busy/queued-banner glyphless => exit 0 (queued is delivery; runtime owns custody)"
+else no "busy/queued-banner must report delivered" "rc=$rc"; fi
+
+# --- C (historical-bug guard): unresolvable target. No pane ever carried our draft
+#     => must fail, never infer delivered from absence of a glyph/snippet.
+if out=$("$SEND" -L "$SOCKET" -t "nonexistent-$$" -m "echo x >>'$TMP/sink.wrong'" 2>/dev/null); then
+  no "wrong-pane: unresolvable target must NOT report success" "expected non-zero, got 0"
+else ok "wrong-pane: unresolvable target => non-zero (no false delivered)"; fi
+
+echo "---"; echo "pass=$pass fail=$fail"
+[ "$fail" = 0 ]

packages/mosaic/framework/tools/tmux/test-send-message-verdict.sh

@@ -4,10 +4,13 @@
 #
 #   1. DELIVERED   — a REPL that renders a `❯ ` input box and submits on Enter
 #                    (text scrolls to history, box clears) => exit 0 "✓ delivered".
-#   2. UNCONFIRMED — a pane with NO locatable prompt glyph. This is the exact
-#                    historical FALSE POSITIVE: pre-patch it printed "✓ delivered"
-#                    exit 0; post-patch it MUST fail loud (exit 2, stderr
-#                    "could not confirm submission").
+#   2. DELIVERED   — a pane with NO prompt glyph that DOES submit => exit 0. A pi
+#                    seat is this fixture (U+2500 rule, no glyph). Reshaped for
+#                    #1257; see the note at the fixture for why the old exit-2
+#                    assertion was wrong.
+#   2b. UNCONFIRMED— a glyphless pane that never submits (raw/no-echo hung TUI)
+#                    => must fail loud. This carries the historical
+#                    false-positive guard that fixture 2 used to be credited with.
 #   3. DRAFT       — a `❯ `-prompt pane that never submits (message stays on the
 #                    input line) => exit 2, stderr "unsubmitted draft".
 set -uo pipefail
@@ -37,19 +40,44 @@ else
   no "delivered: ❯-prompt REPL that submits => exit 0 ✓ delivered" "rc=$rc out=[$out] err=[$(cat "$TMP/e1")]"
 fi
 
-# --- Fixture 2: NO prompt glyph (default bash PS1). THE regression: pre-patch this
-#     was a silent false-positive "delivered"; post-patch it must be unconfirmed→exit 2.
+# --- Fixture 2: NO prompt glyph, and the pane DOES submit (interactive bash).
+#     RESHAPED 2026-08-16 (#1257), deliberately. This fixture previously asserted
+#     exit 2 here and was labelled "false-positive FIXED". That assertion was wrong,
+#     and locking it in is what kept E7 alive: the pane submits, so "delivered" is
+#     the truth, and a pi seat — whose input box is a bare U+2500 rule with no glyph
+#     — IS this fixture. Reporting exit 2 for it told operators a delivered message
+#     may be undelivered, and the retry that advice invites is the duplicate.
+#
+#     The guard this fixture was reaching for is real and is NOT dropped: "never
+#     infer delivered from absence" is now enforced positively by fixture 2b below
+#     (glyphless AND not submitting => must fail) and by fixture 3 (locatable box
+#     still carrying our tail => draft). Absence alone decides nothing either way.
 tmux -L "$SOCKET" new-session -d -s noglyph -c "$TMP" \
   'PS1="sh-noglyph$ " exec bash --noprofile --norc -i'
 sleep 0.3
-if out=$("$SEND" -L "$SOCKET" -t "=noglyph" -m "verdict fixture two must fail loud" 2>"$TMP/e2"); then
-  no "unconfirmed: glyphless pane must NOT report success" "expected exit 2, got 0 (out=[$out])"
+out=$("$SEND" -L "$SOCKET" -t "=noglyph" -m "verdict fixture two must fail loud" 2>"$TMP/e2"); rc=$?
+if [ "$rc" -eq 0 ] && printf '%s' "$out" | grep -qF "✓ delivered"; then
+  ok "delivered: glyphless pane that submits => exit 0 (runtime-agnostic, E7 FIXED)"
+else
+  no "delivered: glyphless pane that submits => exit 0" "rc=$rc out=[$out] err=[$(cat "$TMP/e2")]"
+fi
+
+# --- Fixture 2b: NO prompt glyph AND never submits — a hung managed TUI holding the
+#     terminal in raw/no-echo, which is what a stuck agent seat actually is (measured
+#     on live pi: stty -echo -icanon). Nothing is echoed, nothing is consumed, so
+#     there is no positive evidence of submission and the tool MUST fail loud. This
+#     is the historical false-positive guard, kept as a positive test.
+tmux -L "$SOCKET" new-session -d -s rawstuck -c "$TMP" \
+  'bash --noprofile --norc -c "stty -echo -icanon min 1 time 0 2>/dev/null; exec sleep infinity"'
+sleep 0.3
+if out=$("$SEND" -L "$SOCKET" -t "=rawstuck" -r 1 -m "verdict fixture two-b never submitted" 2>"$TMP/e2b"); then
+  no "unconfirmed: glyphless hung TUI must NOT report success" "expected non-zero, got 0 (out=[$out])"
 else
   rc=$?
-  if [ "$rc" -eq 2 ] && grep -qF "could not confirm submission" "$TMP/e2"; then
-    ok "unconfirmed: glyphless pane => exit 2 + 'could not confirm submission' (false-positive FIXED)"
+  if [ "$rc" -ne 0 ] && grep -qF "could not confirm submission" "$TMP/e2b"; then
+    ok "unconfirmed: glyphless hung TUI (raw/no-echo) => non-zero + 'could not confirm submission'"
   else
-    no "unconfirmed: glyphless pane => exit 2 + stderr" "rc=$rc err=[$(cat "$TMP/e2")]"
+    no "unconfirmed: glyphless hung TUI => non-zero + stderr" "rc=$rc err=[$(cat "$TMP/e2b")]"
   fi
 fi
 

packages/mosaic/src/cli.ts

@@ -20,7 +20,6 @@ import { registerMissionCommand } from './commands/mission.js';
 import { registerUninstallCommand } from './commands/uninstall.js';
 import { registerRestoreCommand } from './commands/restore.js';
 import { registerSkillCommand } from './commands/skill.js';
-import { registerStoreCommand } from './commands/store.js';
 // prdy is registered via launch.ts
 import { registerLaunchCommands } from './commands/launch.js';
 import { registerLeaseCapabilityProbe } from './commands/lease-activation-probe.js';
@@ -426,10 +425,6 @@ registerRestoreCommand(program);
 
 registerSkillCommand(program);
 
-// ─── store ───────────────────────────────────────────────────────────────────
-
-registerStoreCommand(program);
-
 // ─── telemetry ───────────────────────────────────────────────────────────────
 
 registerTelemetryCommand(program);

packages/mosaic/src/commands/store.spec.ts

@@ -1,458 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { Command } from 'commander';
-import {
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  symlinkSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  addStoreEntry,
-  getDefaultStorePaths,
-  listStoreEntries,
-  registerStoreCommand,
-  StoreError,
-  storeKindDir,
-  validateStoreKind,
-  validateStoreName,
-  validateStoreVersion,
-  type StorePaths,
-} from './store.js';
-
-/** Assert a typed StoreError with exactly the expected code. */
-function expectStoreError(run: () => unknown, code: string): void {
-  try {
-    run();
-  } catch (error) {
-    expect(error).toBeInstanceOf(StoreError);
-    expect((error as StoreError).code).toBe(code);
-    return;
-  }
-  throw new Error(`expected StoreError ${code}, but nothing threw`);
-}
-
-describe('vetted user store (W-F4)', () => {
-  let root: string;
-  let paths: StorePaths;
-  let sourceRoot: string;
-
-  beforeEach(() => {
-    root = mkdtempSync(join(tmpdir(), 'mosaic-store-cli-'));
-    paths = { userRoot: join(root, '.mosaic') };
-    sourceRoot = join(root, 'sources');
-    mkdirSync(sourceRoot, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(root, { recursive: true, force: true });
-  });
-
-  function createSource(name: string): string {
-    const dir = join(sourceRoot, name);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, 'SKILL.md'), `# ${name}\n`);
-    return dir;
-  }
-
-  describe('name and version validation (before any filesystem call)', () => {
-    const invalidNames = [
-      '../../etc',
-      '/abs/path',
-      'a/b',
-      String.raw`a\b`,
-      '-rf',
-      '..',
-      'safe.',
-      'space name',
-      'line\nbreak',
-      'escape\u001B[31m',
-    ];
-
-    for (const name of invalidNames) {
-      it(`rejects name ${JSON.stringify(name)}`, () => {
-        expect(() => validateStoreName(name)).toThrow(StoreError);
-      });
-    }
-
-    const invalidVersions = ['', '-1', '1..0', 'a/b', '..', '1.0 beta', '/x'];
-    for (const version of invalidVersions) {
-      it(`rejects version ${JSON.stringify(version)}`, () => {
-        expect(() => validateStoreVersion(version)).toThrow(StoreError);
-      });
-    }
-
-    it('accepts semver-shaped versions including prerelease and build metadata', () => {
-      expect(() => validateStoreVersion('0.1.0-beta.1')).not.toThrow();
-      expect(() => validateStoreVersion('1.2.3+build.7')).not.toThrow();
-    });
-
-    it('rejects plural and unknown kinds', () => {
-      expectStoreError(() => validateStoreKind('plugins'), 'STORE_INVALID_KIND');
-      expectStoreError(() => validateStoreKind('widget'), 'STORE_INVALID_KIND');
-    });
-
-    it('accepts the two spec kinds', () => {
-      expect(() => validateStoreKind('plugin')).not.toThrow();
-      expect(() => validateStoreKind('skill')).not.toThrow();
-    });
-  });
-
-  describe('addStoreEntry', () => {
-    it('copies content into a versioned directory and writes the marker last', () => {
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expect(result.status).toBe('added');
-      const entryPath = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      expect(result.entryPath).toBe(entryPath);
-      expect(existsSync(join(entryPath, 'SKILL.md'))).toBe(true);
-      expect(existsSync(join(entryPath, 'store-entry.json'))).toBe(true);
-      const meta = JSON.parse(readFileSync(join(entryPath, 'store-entry.json'), 'utf-8'));
-      expect(meta).toMatchObject({
-        schema: 1,
-        kind: 'skill',
-        name: 'demo',
-        version: '1.0.0',
-        vettedBy: 'op',
-      });
-      expect(typeof meta['vettedAt']).toBe('string');
-    });
-
-    it('writes plugins under plugins/ and skills under skills/', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'op', undefined, paths);
-      addStoreEntry('skill', 'beta', '2.0.0', createSource('beta'), 'op', undefined, paths);
-      expect(existsSync(join(paths.userRoot, 'plugins', 'alpha', '0.1.0'))).toBe(true);
-      expect(existsSync(join(paths.userRoot, 'skills', 'beta', '2.0.0'))).toBe(true);
-    });
-
-    it('is append-only: an existing version with a marker is refused, not overwritten', () => {
-      const sourceA = createSource('demo');
-      const sourceB = join(sourceRoot, 'demo-other');
-      mkdirSync(sourceB, { recursive: true });
-      writeFileSync(join(sourceB, 'SKILL.md'), '# changed\n');
-      addStoreEntry('skill', 'demo', '1.0.0', sourceA, 'op', undefined, paths);
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', sourceB, 'op', undefined, paths),
-        'STORE_ALREADY_PRESENT',
-      );
-      expect(
-        readFileSync(join(paths.userRoot, 'skills', 'demo', '1.0.0', 'SKILL.md'), 'utf-8'),
-      ).toBe('# demo\n');
-    });
-
-    it('allows a second version alongside the first', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.1.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expect(result.status).toBe('added');
-      expect(readdirSync(join(paths.userRoot, 'skills', 'demo')).sort()).toEqual([
-        '1.0.0',
-        '1.1.0',
-      ]);
-    });
-
-    it('refuses an unmarked target directory by default and preserves its content', () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# operator content\n');
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths),
-        'STORE_TARGET_UNMARKED',
-      );
-      // The operator's hand-placed content survives the refusal.
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# operator content\n');
-    });
-
-    it('reclaims an unmarked target only under explicit reclaim opt-in', () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# torn write\n');
-      const result = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-        { reclaim: true },
-      );
-      expect(result.status).toBe('reclaimed-unmarked');
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# demo\n');
-    });
-
-    it('reclaim can never destroy a marked, vetted entry (append-only holds under --reclaim)', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      const marked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      const vettedContent = readFileSync(join(marked, 'SKILL.md'), 'utf-8');
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths, {
-            reclaim: true,
-          }),
-        'STORE_ALREADY_PRESENT',
-      );
-      // Load-bearing half: the throw alone does not prove nothing was deleted
-      // before it. Pins the marker-check-before-reclaim-check ordering against
-      // the guard-clause-migrates-upward refactor (review finding on b2124c6).
-      expect(readFileSync(join(marked, 'SKILL.md'), 'utf-8')).toBe(vettedContent);
-      expect(existsSync(join(marked, 'store-entry.json'))).toBe(true);
-    });
-
-    it('refuses a missing source with a typed error', () => {
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', join(sourceRoot, 'nope'), 'op', undefined, paths),
-        'STORE_SOURCE_MISSING',
-      );
-    });
-
-    it('refuses a file (non-directory) source with a typed error', () => {
-      const filePath = join(sourceRoot, 'file.txt');
-      writeFileSync(filePath, 'x');
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', filePath, 'op', undefined, paths),
-        'STORE_SOURCE_NOT_DIR',
-      );
-    });
-
-    it('refuses a symlinked source with a typed error and writes nothing', () => {
-      const real = createSource('demo');
-      const link = join(sourceRoot, 'demo-link');
-      symlinkSync(real, link);
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', link, 'op', undefined, paths),
-        'STORE_SOURCE_SYMLINK',
-      );
-      expect(existsSync(join(paths.userRoot, 'skills', 'demo'))).toBe(false);
-    });
-
-    it('refuses a source tree containing nested symlinks and writes nothing', () => {
-      const src = createSource('demo');
-      const target = join(sourceRoot, 'elsewhere');
-      mkdirSync(target, { recursive: true });
-      symlinkSync(target, join(src, 'escape'));
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', src, 'op', undefined, paths),
-        'STORE_SOURCE_SYMLINK',
-      );
-      expect(existsSync(join(paths.userRoot, 'skills', 'demo'))).toBe(false);
-    });
-
-    it('refuses adding from inside the store itself', () => {
-      const first = addStoreEntry(
-        'skill',
-        'demo',
-        '1.0.0',
-        createSource('demo'),
-        'op',
-        undefined,
-        paths,
-      );
-      expectStoreError(
-        () => addStoreEntry('skill', 'copy', '1.0.0', first.entryPath, 'op', undefined, paths),
-        'STORE_SOURCE_INSIDE_STORE',
-      );
-    });
-
-    it('refuses a symlinked user root ancestor', () => {
-      const linkedRoot = join(sourceRoot, 'linked-mosaic');
-      symlinkSync(paths.userRoot, linkedRoot);
-      expectStoreError(
-        () =>
-          addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, {
-            userRoot: linkedRoot,
-          }),
-        'STORE_SYMLINK_ROOT',
-      );
-    });
-
-    it('requires a non-empty vetting attribution', () => {
-      expectStoreError(
-        () => addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), '  ', undefined, paths),
-        'STORE_INVALID_VETTER',
-      );
-    });
-  });
-
-  describe('listStoreEntries', () => {
-    it('returns empty for an absent store without creating it', () => {
-      expect(listStoreEntries(paths)).toEqual([]);
-      expect(existsSync(paths.userRoot)).toBe(false);
-    });
-
-    it('lists entries deterministically with vetting metadata', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'fred', undefined, paths);
-      addStoreEntry('skill', 'beta', '2.0.0', createSource('beta'), 'fargo', 'looked fine', paths);
-      addStoreEntry('skill', 'beta', '2.1.0', createSource('beta'), 'fargo', undefined, paths);
-
-      const entries = listStoreEntries(paths);
-      expect(entries.map((e) => `${e.kind}:${e.name}:${e.version}`)).toEqual([
-        'plugin:alpha:0.1.0',
-        'skill:beta:2.0.0',
-        'skill:beta:2.1.0',
-      ]);
-      expect(entries[0]?.meta?.vettedBy).toBe('fred');
-      expect(entries[1]?.meta?.notes).toBe('looked fine');
-    });
-
-    it('classifies markerless version directories as incomplete', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      mkdirSync(join(paths.userRoot, 'skills', 'demo', '2.0.0'), { recursive: true });
-      const entries = listStoreEntries(paths, { kind: 'skill', name: 'demo' });
-      expect(entries.find((e) => e.version === '1.0.0')?.status).toBe('vetted');
-      expect(entries.find((e) => e.version === '2.0.0')?.status).toBe('incomplete');
-    });
-
-    it('classifies malformed marker JSON as invalid-metadata, not vetted', () => {
-      addStoreEntry('skill', 'demo', '1.0.0', createSource('demo'), 'op', undefined, paths);
-      writeFileSync(
-        join(paths.userRoot, 'skills', 'demo', '1.0.0', 'store-entry.json'),
-        '{not json',
-      );
-      const entries = listStoreEntries(paths);
-      expect(entries[0]?.status).toBe('invalid-metadata');
-    });
-
-    it('surfaces foreign files (never mutates them)', () => {
-      mkdirSync(join(paths.userRoot, 'skills'), { recursive: true });
-      writeFileSync(join(paths.userRoot, 'skills', 'stray.txt'), 'x');
-      const entries = listStoreEntries(paths);
-      expect(entries[0]?.status).toBe('foreign');
-      expect(existsSync(join(paths.userRoot, 'skills', 'stray.txt'))).toBe(true);
-    });
-
-    it('filters by kind and name', () => {
-      addStoreEntry('plugin', 'alpha', '0.1.0', createSource('alpha'), 'op', undefined, paths);
-      addStoreEntry('skill', 'beta', '1.0.0', createSource('beta'), 'op', undefined, paths);
-      expect(listStoreEntries(paths, { kind: 'plugin' }).map((e) => e.name)).toEqual(['alpha']);
-      expect(listStoreEntries(paths, { name: 'beta' }).map((e) => e.name)).toEqual(['beta']);
-      expect(() => listStoreEntries(paths, { name: '../escape' })).toThrow(StoreError);
-    });
-  });
-
-  describe('default paths seam', () => {
-    it('honors MOSAIC_USER_HOME', () => {
-      const previous = process.env['MOSAIC_USER_HOME'];
-      try {
-        process.env['MOSAIC_USER_HOME'] = join(root, 'custom-user-home');
-        expect(getDefaultStorePaths().userRoot).toBe(join(root, 'custom-user-home'));
-        expect(storeKindDir('plugin')).toBe(join(root, 'custom-user-home', 'plugins'));
-      } finally {
-        if (previous === undefined) delete process.env['MOSAIC_USER_HOME'];
-        else process.env['MOSAIC_USER_HOME'] = previous;
-      }
-    });
-  });
-
-  describe('CLI', () => {
-    let previousExitCode: string | number | null | undefined;
-
-    beforeEach(() => {
-      previousExitCode = process.exitCode;
-      process.exitCode = undefined;
-    });
-
-    afterEach(() => {
-      process.exitCode = previousExitCode;
-    });
-
-    const parse = (args: string[]) => {
-      const program = new Command().exitOverride();
-      registerStoreCommand(program, paths);
-      return program.parseAsync(['node', 'mosaic', 'store', ...args]);
-    };
-
-    it('registers on the parent program and renders help', () => {
-      const program = new Command().exitOverride();
-      registerStoreCommand(program, paths);
-      const cmd = program.commands.find((c) => c.name() === 'store');
-      expect(cmd).toBeDefined();
-      expect(() => cmd?.helpInformation()).not.toThrow();
-    });
-
-    it('add exits nonzero with a typed code for an invalid name', async () => {
-      await parse([
-        'add',
-        'skill',
-        '../../etc',
-        '1.0.0',
-        '--from',
-        createSource('x'),
-        '--by',
-        'op',
-      ]);
-      expect(process.exitCode).toBe(1);
-    });
-
-    it('add exits nonzero when the kind is plural', async () => {
-      await parse(['add', 'skills', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBe(1);
-    });
-
-    it('add succeeds and creates the entry directory', async () => {
-      await parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBeUndefined();
-      expect(lstatSync(join(paths.userRoot, 'skills', 'demo', '1.0.0')).isDirectory()).toBe(true);
-    });
-
-    it('add requires --by (commander requiredOption)', async () => {
-      await expect(
-        parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo')]),
-      ).rejects.toThrow(/--by/);
-    });
-
-    it('add exits nonzero on an unmarked target without --reclaim, preserving content', async () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# operator\n');
-      await parse(['add', 'skill', 'demo', '1.0.0', '--from', createSource('demo'), '--by', 'op']);
-      expect(process.exitCode).toBe(1);
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# operator\n');
-    });
-
-    it('add --reclaim replaces the unmarked target and succeeds', async () => {
-      const unmarked = join(paths.userRoot, 'skills', 'demo', '1.0.0');
-      mkdirSync(unmarked, { recursive: true });
-      writeFileSync(join(unmarked, 'SKILL.md'), '# torn\n');
-      await parse([
-        'add',
-        'skill',
-        'demo',
-        '1.0.0',
-        '--from',
-        createSource('demo'),
-        '--by',
-        'op',
-        '--reclaim',
-      ]);
-      expect(process.exitCode).toBeUndefined();
-      expect(readFileSync(join(unmarked, 'SKILL.md'), 'utf-8')).toBe('# demo\n');
-    });
-
-    it('list exits 0 on an empty store', async () => {
-      await parse(['list']);
-      expect(process.exitCode).toBeUndefined();
-    });
-  });
-});

packages/mosaic/src/commands/store.ts

@@ -1,544 +0,0 @@
-import {
-  cpSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-  type Dirent,
-  type Stats,
-} from 'node:fs';
-import { isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
-import type { Command } from 'commander';
-import { DEFAULT_MOSAIC_USER_HOME } from '../constants.js';
-
-/**
- * `mosaic store` — the vetted user store under `~/.mosaic/{plugins,skills}` (W-F4).
- *
- * Two roots with distinct ownership (HARNESS-HOMES design, frozen REV3):
- * - `~/.config/mosaic/` is the SYSTEM root: update-owned, replaceable wholesale.
- * - `~/.mosaic/` is the USER root: never touched by installs or updates.
- *
- * This module only ever writes under the USER root. The store is the vetting
- * boundary: content lands here only through an explicit `store add` carrying a
- * named vetting attribution, and every entry is versioned
- * (`store/<kind>s/<name>/<version>/`) with a `store-entry.json` marker written
- * LAST — a version directory without its marker is never a usable entry, and
- * an unmarked target is REFUSED by default: it may be this tool's own debris
- * from an interrupted add, or content the operator placed by hand, and the
- * code cannot tell those apart — so deletion happens only under an explicit
- * `--reclaim` opt-in, and the result status names what was done.
- *
- * Deferred by design (W-F6 and later): activation/symlink-install into agent
- * homes, `current`-pointer pinning, network acquisition. `add` accepts a local
- * source path only — no network, no credentials, ever.
- */
-
-export type StoreKind = 'plugin' | 'skill';
-export const STORE_KINDS: readonly StoreKind[] = ['plugin', 'skill'];
-
-/** On-disk metadata marker; written last so its presence commits an entry. */
-export const STORE_ENTRY_MARKER = 'store-entry.json';
-
-export interface StorePaths {
-  /** User data root, e.g. `~/.mosaic`. */
-  userRoot: string;
-}
-
-export interface StoreEntryMeta {
-  schema: 1;
-  kind: StoreKind;
-  name: string;
-  version: string;
-  /** Absolute source path the content was vetted from, as resolved at add time. */
-  sourcePath: string;
-  /** Operator who vouched for the content — required, non-empty. */
-  vettedBy: string;
-  /** ISO timestamp of the add. */
-  vettedAt: string;
-  /** Free-form vetting notes, if any. */
-  notes?: string;
-}
-
-export type StoreAddStatus = 'added' | 'reclaimed-unmarked';
-
-export interface StoreAddResult {
-  kind: StoreKind;
-  name: string;
-  version: string;
-  status: StoreAddStatus;
-  entryPath: string;
-  sourcePath: string;
-}
-
-export type StoreEntryStatus = 'vetted' | 'incomplete' | 'invalid-metadata' | 'foreign';
-
-export interface StoreListEntry {
-  kind: StoreKind;
-  name: string;
-  /** Undefined for name-level foreign files (not a directory at all). */
-  version?: string;
-  status: StoreEntryStatus;
-  entryPath: string;
-  meta?: StoreEntryMeta;
-}
-
-const SAFE_STORE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const SAFE_STORE_VERSION = /^[A-Za-z0-9][A-Za-z0-9._+-]*$/;
-
-export class StoreError extends Error {
-  public readonly code: string;
-
-  public constructor(code: string, message: string) {
-    super(message);
-    this.name = 'StoreError';
-    this.code = code;
-  }
-}
-
-/** Resolve the user store root while keeping tests injectable. */
-export function getDefaultStorePaths(): StorePaths {
-  const userRoot = process.env['MOSAIC_USER_HOME'] ?? DEFAULT_MOSAIC_USER_HOME;
-  return { userRoot };
-}
-
-/**
- * Reject a user-supplied name before any filesystem operation.
- * A store name identifies one directory under `store/<kind>s/`.
- */
-export function validateStoreName(name: string): void {
-  if (
-    name.length === 0 ||
-    name.startsWith('-') ||
-    name.endsWith('.') ||
-    name.includes('..') ||
-    name.includes('/') ||
-    name.includes('\\') ||
-    isAbsolute(name) ||
-    !SAFE_STORE_NAME.test(name)
-  ) {
-    throw new StoreError(
-      'STORE_INVALID_NAME',
-      `Invalid store name ${JSON.stringify(name)}: use letters, numbers, dots, underscores, or hyphens; start with a letter or number; and do not use paths, "..", or a leading "-".`,
-    );
-  }
-}
-
-/** Versions share the name discipline plus `+` (semver build metadata). */
-export function validateStoreVersion(version: string): void {
-  if (
-    version.length === 0 ||
-    version.startsWith('-') ||
-    version.endsWith('.') ||
-    version.includes('..') ||
-    version.includes('/') ||
-    version.includes('\\') ||
-    isAbsolute(version) ||
-    !SAFE_STORE_VERSION.test(version)
-  ) {
-    throw new StoreError(
-      'STORE_INVALID_VERSION',
-      `Invalid version ${JSON.stringify(version)}: use letters, numbers, dots, underscores, hyphens, or plus; start with a letter or number; and do not use paths, "..", or a leading "-".`,
-    );
-  }
-}
-
-export function validateStoreKind(kind: string): asserts kind is StoreKind {
-  if (!(STORE_KINDS as readonly string[]).includes(kind)) {
-    throw new StoreError(
-      'STORE_INVALID_KIND',
-      `Invalid store kind ${JSON.stringify(kind)}: expected one of ${STORE_KINDS.map((k) => `"${k}"`).join(', ')}.`,
-    );
-  }
-}
-
-function validateVettedBy(vettedBy: string): void {
-  if (vettedBy.trim().length === 0 || vettedBy.includes('\n') || vettedBy.length > 80) {
-    throw new StoreError(
-      'STORE_INVALID_VETTER',
-      'Invalid --by value: name the operator vouching for this content (single line, at most 80 characters).',
-    );
-  }
-}
-
-function lstatIfPresent(path: string): Stats | undefined {
-  try {
-    return lstatSync(path);
-  } catch (error: unknown) {
-    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return undefined;
-    throw error;
-  }
-}
-
-function assertNoSymlinkAncestors(path: string): void {
-  const absolute = resolve(path);
-  const pathRoot = parse(absolute).root;
-  let current = pathRoot;
-
-  for (const segment of relative(pathRoot, absolute).split(sep)) {
-    if (segment.length === 0) continue;
-    current = join(current, segment);
-    const entry = lstatIfPresent(current);
-    if (!entry) break;
-    if (entry.isSymbolicLink()) {
-      throw new StoreError(
-        'STORE_SYMLINK_ROOT',
-        `Refusing symlink ancestor at ${current}; the user store root must resolve without symlink traversal.`,
-      );
-    }
-  }
-}
-
-/** `plugins` for plugin, `skills` for skill — plural on disk per the layout. */
-function kindDirName(kind: StoreKind): string {
-  return kind === 'plugin' ? 'plugins' : 'skills';
-}
-
-export function storeKindDir(kind: StoreKind, paths: StorePaths = getDefaultStorePaths()): string {
-  return join(paths.userRoot, kindDirName(kind));
-}
-
-function entryDir(kind: StoreKind, name: string, version: string, paths: StorePaths): string {
-  return join(storeKindDir(kind, paths), name, version);
-}
-
-function isInsideRoot(candidate: string, root: string): boolean {
-  const rel = relative(resolve(root), resolve(candidate));
-  return rel.length > 0 && rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
-}
-
-/**
- * Refuse any symlink in the source tree — the vetting boundary copies real
- * content only, so a vetted entry can never carry a link that escapes it.
- *
- * NOTE: known check-then-use window between this walk and the `cpSync` below:
- * a symlink created concurrently with the add could slip through. Accepted
- * for a local, operator-run CLI; revisit before any unattended or networked
- * acquisition path exists.
- */
-function assertSourceTreeHasNoSymlinks(sourcePath: string): void {
-  const stack: string[] = [sourcePath];
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    for (const dirent of readdirSync(current, { withFileTypes: true })) {
-      const child = join(current, dirent.name);
-      if (dirent.isSymbolicLink()) {
-        throw new StoreError(
-          'STORE_SOURCE_SYMLINK',
-          `Refusing to vet content containing a symlink: ${child}. Resolve or remove symlinks before adding to the store.`,
-        );
-      }
-      if (dirent.isDirectory()) stack.push(child);
-    }
-  }
-}
-
-/**
- * Vet and add one versioned entry to the user store.
- *
- * Copies the source directory (real content, no symlinks) to
- * `<userRoot>/<kind>s/<name>/<version>/` and writes the `store-entry.json`
- * marker LAST: a crash mid-copy leaves at most a recoverable partial, never a
- * half-vetted entry that lists as present.
- */
-export function addStoreEntry(
-  kind: StoreKind,
-  name: string,
-  version: string,
-  sourcePath: string,
-  vettedBy: string,
-  notes: string | undefined,
-  paths: StorePaths = getDefaultStorePaths(),
-  options: { reclaim?: boolean } = {},
-): StoreAddResult {
-  validateStoreKind(kind);
-  validateStoreName(name);
-  validateStoreVersion(version);
-  validateVettedBy(vettedBy);
-  assertNoSymlinkAncestors(paths.userRoot);
-
-  const resolvedSource = resolve(sourcePath);
-  const source = lstatIfPresent(resolvedSource);
-  if (!source) {
-    throw new StoreError('STORE_SOURCE_MISSING', `Source path does not exist: ${resolvedSource}`);
-  }
-  if (source.isSymbolicLink()) {
-    throw new StoreError(
-      'STORE_SOURCE_SYMLINK',
-      `Refusing to vet a symlink as store content: ${resolvedSource} (points at ${resolve(sourcePath)}). Add the real directory.`,
-    );
-  }
-  if (!source.isDirectory()) {
-    throw new StoreError(
-      'STORE_SOURCE_NOT_DIR',
-      `Source path is not a directory: ${resolvedSource}`,
-    );
-  }
-  if (isInsideRoot(resolvedSource, paths.userRoot)) {
-    throw new StoreError(
-      'STORE_SOURCE_INSIDE_STORE',
-      `Refusing to add store content from inside the store itself: ${resolvedSource}`,
-    );
-  }
-  assertSourceTreeHasNoSymlinks(resolvedSource);
-
-  const target = entryDir(kind, name, version, paths);
-  const existing = lstatIfPresent(target);
-  let status: StoreAddStatus = 'added';
-  if (existing) {
-    if (existsSync(join(target, STORE_ENTRY_MARKER))) {
-      throw new StoreError(
-        'STORE_ALREADY_PRESENT',
-        `${kind} "${name}" version "${version}" is already present at ${target}; stores are append-only — add a new version instead.`,
-      );
-    }
-    // Unmarked target: either this tool's own debris from an interrupted add,
-    // or content the operator placed by hand — indistinguishable on disk. The
-    // USER root's contract is that tooling never destroys operator content,
-    // so deletion requires the explicit --reclaim opt-in (review finding on
-    // c23a71d7: silent rmSync under a benign-sounding status).
-    if (!options.reclaim) {
-      throw new StoreError(
-        'STORE_TARGET_UNMARKED',
-        `Target exists without ${STORE_ENTRY_MARKER}: ${target}. Refusing to delete unmarked content — if this is debris from an interrupted add, re-run with --reclaim to replace it.`,
-      );
-    }
-    rmSync(target, { recursive: true, force: true });
-    status = 'reclaimed-unmarked';
-  }
-
-  mkdirSync(target, { recursive: true });
-  cpSync(resolvedSource, target, { recursive: true });
-
-  const meta: StoreEntryMeta = {
-    schema: 1,
-    kind,
-    name,
-    version,
-    sourcePath: resolvedSource,
-    vettedBy: vettedBy.trim(),
-    vettedAt: new Date().toISOString(),
-    ...(notes === undefined ? {} : { notes }),
-  };
-  writeFileSync(join(target, STORE_ENTRY_MARKER), `${JSON.stringify(meta, null, 2)}\n`);
-
-  return { kind, name, version, status, entryPath: target, sourcePath: resolvedSource };
-}
-
-function readEntryMeta(markerPath: string): { meta?: StoreEntryMeta; status: StoreEntryStatus } {
-  let raw: string;
-  try {
-    raw = readFileSync(markerPath, 'utf-8');
-  } catch {
-    return { status: 'invalid-metadata' };
-  }
-  try {
-    const parsed = JSON.parse(raw) as StoreEntryMeta;
-    if (
-      parsed?.schema === 1 &&
-      (STORE_KINDS as readonly string[]).includes(parsed.kind) &&
-      typeof parsed.name === 'string' &&
-      typeof parsed.version === 'string' &&
-      typeof parsed.vettedBy === 'string' &&
-      typeof parsed.vettedAt === 'string'
-    ) {
-      return { meta: parsed, status: 'vetted' };
-    }
-  } catch {
-    // fall through
-  }
-  return { status: 'invalid-metadata' };
-}
-
-/**
- * Enumerate every store entry deterministically (kind, then name, then
- * version). Version directories without a marker list as `incomplete`; files
- * where directories were expected list as `foreign` — surfaced, never mutated.
- */
-export function listStoreEntries(
-  paths: StorePaths = getDefaultStorePaths(),
-  filter: { kind?: StoreKind; name?: string } = {},
-): StoreListEntry[] {
-  if (filter.name !== undefined) validateStoreName(filter.name);
-  assertNoSymlinkAncestors(paths.userRoot);
-
-  const kinds = filter.kind ? [filter.kind] : [...STORE_KINDS];
-  const entries: StoreListEntry[] = [];
-
-  for (const kind of kinds) {
-    const kindRoot = lstatIfPresent(storeKindDir(kind, paths));
-    if (!kindRoot) continue;
-    if (!kindRoot.isDirectory()) {
-      entries.push({
-        kind,
-        name: kindDirName(kind),
-        status: 'foreign',
-        entryPath: storeKindDir(kind, paths),
-      });
-      continue;
-    }
-
-    for (const nameDirent of readdirSync(storeKindDir(kind, paths), {
-      withFileTypes: true,
-    }).sort(byName) as Dirent[]) {
-      if (filter.name !== undefined && nameDirent.name !== filter.name) continue;
-      const namePath = join(storeKindDir(kind, paths), nameDirent.name);
-
-      if (!nameDirent.isDirectory()) {
-        entries.push({ kind, name: nameDirent.name, status: 'foreign', entryPath: namePath });
-        continue;
-      }
-
-      const versionDirents = readdirSync(namePath, { withFileTypes: true }).sort(byName);
-      if (versionDirents.length === 0) {
-        entries.push({ kind, name: nameDirent.name, status: 'incomplete', entryPath: namePath });
-        continue;
-      }
-      for (const versionDirent of versionDirents) {
-        const versionPath = join(namePath, versionDirent.name);
-        if (!versionDirent.isDirectory()) {
-          entries.push({
-            kind,
-            name: nameDirent.name,
-            version: versionDirent.name,
-            status: 'foreign',
-            entryPath: versionPath,
-          });
-          continue;
-        }
-        const markerPath = join(versionPath, STORE_ENTRY_MARKER);
-        if (!existsSync(markerPath)) {
-          entries.push({
-            kind,
-            name: nameDirent.name,
-            version: versionDirent.name,
-            status: 'incomplete',
-            entryPath: versionPath,
-          });
-          continue;
-        }
-        const { meta, status } = readEntryMeta(markerPath);
-        entries.push({
-          kind,
-          name: nameDirent.name,
-          version: versionDirent.name,
-          status,
-          entryPath: versionPath,
-          ...(meta === undefined ? {} : { meta }),
-        });
-      }
-    }
-  }
-
-  return entries;
-}
-
-function byName(a: Dirent, b: Dirent): number {
-  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
-}
-
-function reportCommandError(error: unknown): void {
-  if (error instanceof StoreError) {
-    console.error(`store: ${error.code}: ${error.message}`);
-  } else {
-    console.error(error instanceof Error ? error.message : String(error));
-  }
-  process.exitCode = 1;
-}
-
-function displayStoreName(name: string): string {
-  return SAFE_STORE_NAME.test(name) ? name : JSON.stringify(name);
-}
-
-/** Register the `mosaic store` command group (W-F4). */
-export function registerStoreCommand(
-  program: Command,
-  paths: StorePaths = getDefaultStorePaths(),
-): void {
-  const store = program
-    .command('store')
-    .description('Manage the vetted user store under ~/.mosaic (plugins, skills)')
-    .configureHelp({ sortSubcommands: true });
-
-  store
-    .command('add <kind> <name> <version>')
-    .description(
-      'Vet and add a local plugin/skill directory to the user store (versioned, append-only)',
-    )
-    .requiredOption('--from <path>', 'Local source directory to vet (no network acquisition)')
-    .requiredOption('--by <operator>', 'Name of the operator vouching for this content')
-    .option('--notes <notes>', 'Vetting notes recorded in the entry metadata')
-    .option(
-      '--reclaim',
-      'Replace an existing UNMARKED target directory (e.g. debris from an interrupted add); refuses without this flag',
-    )
-    .action(
-      async (
-        kind: string,
-        name: string,
-        version: string,
-        opts: {
-          from: string;
-          by: string;
-          notes?: string;
-          reclaim: boolean;
-        },
-      ) => {
-        try {
-          const result = addStoreEntry(
-            kind as StoreKind,
-            name,
-            version,
-            opts.from,
-            opts.by,
-            opts.notes,
-            paths,
-            { reclaim: opts.reclaim },
-          );
-          const suffix =
-            result.status === 'reclaimed-unmarked' ? ' (replaced unmarked directory)' : '';
-          console.log(
-            `${result.kind} ${displayStoreName(result.name)} ${result.version}: added${suffix}`,
-          );
-          console.log(`  entry: ${result.entryPath}`);
-          console.log(`  vetted by ${opts.by.trim()}`);
-        } catch (error: unknown) {
-          reportCommandError(error);
-        }
-      },
-    );
-
-  store
-    .command('list')
-    .description('List store entries with vetting status')
-    .option('--kind <kind>', 'Filter by kind (plugin | skill)')
-    .option('--name <name>', 'Filter by entry name')
-    .action((opts: { kind?: string; name?: string }) => {
-      try {
-        let kind: StoreKind | undefined;
-        if (opts.kind !== undefined) {
-          validateStoreKind(opts.kind);
-          kind = opts.kind;
-        }
-        const entries = listStoreEntries(paths, {
-          ...(kind === undefined ? {} : { kind }),
-          ...(opts.name === undefined ? {} : { name: opts.name }),
-        });
-        if (entries.length === 0) {
-          console.log('No store entries found.');
-          return;
-        }
-        for (const entry of entries) {
-          const version = entry.version ?? '-';
-          const vetter = entry.meta?.vettedBy ?? '-';
-          console.log(
-            `${entry.status.padEnd(17)}${entry.kind.padEnd(8)}${displayStoreName(entry.name).padEnd(24)}${version.padEnd(16)}${vetter}`,
-          );
-        }
-      } catch (error: unknown) {
-        reportCommandError(error);
-      }
-    });
-}

packages/mosaic/src/constants.ts

@@ -5,13 +5,6 @@ export const VERSION = '0.0.2';
 
 export const DEFAULT_MOSAIC_HOME = join(homedir(), '.config', 'mosaic');
 
-/**
- * USER data root (HARNESS-HOMES two-root split): everything under here is user
- * content — never replaced or removed by installs, updates, or uninstallers.
- * Distinct from the SYSTEM root above, which is update-owned.
- */
-export const DEFAULT_MOSAIC_USER_HOME = join(homedir(), '.mosaic');
-
 export const DEFAULTS = {
   agentName: 'Assistant',
   roleDescription: 'execution partner and visibility engine',