@wenrwa/marketplace-cli 0.6.5 → 0.7.0

package/dist/bridge/checkoutInventory.js

@@ -39,41 +39,178 @@
  * (Promise.all) per checkout, and why the whole scan is fire-and-forget from
  * relayClient's point of view.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVENTORY_SCAN_VERSION = void 0;
+exports.stripManagedRegion = stripManagedRegion;
+exports.inspectDirty = inspectDirty;
 exports.checkDirty = checkDirty;
 exports.scanCheckoutInventory = scanCheckoutInventory;
 exports.createCheckoutInventoryReporter = createCheckoutInventoryReporter;
+/** `cmd args...` runner — same shape used across repoCheckout.ts /
+ *  changesReport.ts's injected `run` (git invoked as `git -C <path> ...`,
+ *  never via a shell cwd option, so this stays a flat argv runner). */
+const fs = __importStar(require("fs"));
+const contextWriter_1 = require("./contextWriter");
+/**
+ * Inventory format version. 2 (cli 0.6.9) adds `dirtyKinds`/`noUpstream`, a
+ * dirty check that ignores the bridge's own CLAUDE.md region, and the
+ * `park-save` / `inventory-scan` frames. Stamped on EVERY entry so the arena
+ * and backend can tell a box that understands Save from one that does not —
+ * an old bridge would treat an unknown frame as an error, never as a park.
+ */
+exports.INVENTORY_SCAN_VERSION = 2;
+const defaultReadText = (absPath) => {
+    try {
+        return fs.readFileSync(absPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+};
+/** `run`, with a rejection folded into a non-zero exit. The production
+ *  runner (commands/bridge.ts execRunner) REJECTS on a failed command with no
+ *  stdout — the old dirty check let that escape, so a branch with no upstream
+ *  surfaced as "Could not read this checkout: Command failed: git … rev-list
+ *  @{u}..HEAD" instead of as a checkout with unpushed work. */
+async function tryRun(run, args) {
+    try {
+        return await run('git', args);
+    }
+    catch (err) {
+        return { stdout: err instanceof Error ? err.message : String(err), code: 1 };
+    }
+}
+/** CLAUDE.md with the bridge's managed region (contextWriter.ts) cut out. */
+function stripManagedRegion(text) {
+    const start = text.indexOf(contextWriter_1.CONTEXT_START_MARKER);
+    const end = text.indexOf(contextWriter_1.CONTEXT_END_MARKER);
+    if (start === -1 || end === -1 || end < start)
+        return text.trim();
+    return (text.slice(0, start) + text.slice(end + contextWriter_1.CONTEXT_END_MARKER.length)).trim();
+}
+/**
+ * Is this porcelain line the bridge's OWN write, not the user's work?
+ *
+ * The bridge rewrites a fenced region of `CLAUDE.md` every time a session
+ * opens (wmr-07) and keeps `.hiveop/` for itself. Counting either as "unsaved
+ * work" marked nearly every checkout dirty — owner report 2026-10-02: finished
+ * Practice match copies, all pushed, all "Unsaved work". Only the managed
+ * region is forgiven: any user text in CLAUDE.md still counts.
+ */
+async function isBridgeManagedChange(path, line, run, readText) {
+    const code = line.slice(0, 2);
+    const file = line.slice(3).trim().replace(/^"|"$/g, '');
+    if (file === '.hiveop' || file.startsWith('.hiveop/'))
+        return true;
+    if (file !== 'CLAUDE.md')
+        return false;
+    const working = readText(`${path}/CLAUDE.md`);
+    if (working === null)
+        return false;
+    const rest = stripManagedRegion(working);
+    if (code === '??')
+        return rest === '';
+    if (!/^[ M][ M]$/.test(code))
+        return false; // added/deleted/renamed — the user's
+    const head = await tryRun(run, ['-C', path, 'show', 'HEAD:CLAUDE.md']);
+    if (head.code !== 0)
+        return false;
+    return stripManagedRegion(head.stdout) === rest;
+}
 /**
- * PRD "Dirty means" section: uncommitted changes (`git status --porcelain`
- * non-empty), unpushed commits (`git rev-list @{u}..HEAD --count` > 0), OR
- * stashes (`git stash list` non-empty) — any ONE independently marks the
- * checkout dirty. `status`/`stash` failing outright (non-zero exit) means the
- * directory isn't a usable git checkout at all — 'unparseable', not clean.
- * `rev-list @{u}..HEAD` failing is the ordinary "no upstream configured"
- * case (a branch with nothing to compare against) and is treated as simply
- * "not unpushed" rather than a parse failure — every real checkout has a
- * working `status`/`stash`, so those two staying reliable is what actually
- * distinguishes a healthy checkout from a broken one.
+ * PRD "Dirty means" section: uncommitted changes, unpushed commits, OR
+ * stashes — any ONE independently marks the checkout dirty.
+ *
+ *   uncommitted — `git status --porcelain`, minus the bridge's own writes
+ *                 (isBridgeManagedChange).
+ *   unpushed    — commits on HEAD that no remote-tracking ref contains
+ *                 (`rev-list HEAD --not --remotes`). NOT `@{u}..HEAD`: that
+ *                 failed outright with no upstream, and counted work pushed
+ *                 to any other branch (a park branch included) as unpushed —
+ *                 so park-and-remove's own pre-delete re-check aborted every
+ *                 park that had committed something.
+ *   stashed     — `git stash list` non-empty.
  *
- * Exported (hcs-05) — checkoutReclaim.ts reuses this EXACT function for its
- * immediate-pre-delete dirty re-check, rather than reimplementing the three
- * conditions a second time. One dirty definition, two callers.
+ * `status`/`stash` failing means the directory isn't a usable git checkout —
+ * 'unparseable', not clean.
  */
-async function checkDirty(path, run) {
-    const status = await run('git', ['-C', path, 'status', '--porcelain']);
+async function inspectDirty(path, run, readText = defaultReadText) {
+    const status = await tryRun(run, ['-C', path, 'status', '--porcelain']);
     if (status.code !== 0)
         return 'unparseable';
-    const stash = await run('git', ['-C', path, 'stash', 'list']);
+    const stash = await tryRun(run, ['-C', path, 'stash', 'list']);
     if (stash.code !== 0)
         return 'unparseable';
-    const ahead = await run('git', ['-C', path, 'rev-list', '@{u}..HEAD', '--count']);
+    const lines = status.stdout.split('\n').filter((l) => l.trim().length > 0);
+    let uncommitted = false;
+    for (const line of lines) {
+        if (!(await isBridgeManagedChange(path, line, run, readText))) {
+            uncommitted = true;
+            break;
+        }
+    }
+    const ahead = await tryRun(run, ['-C', path, 'rev-list', 'HEAD', '--not', '--remotes', '--count']);
+    // A repo with no commits at all has no HEAD — nothing to push.
     const unpushed = ahead.code === 0 && parseInt(ahead.stdout.trim(), 10) > 0;
-    const uncommitted = status.stdout.trim().length > 0;
+    const upstream = await tryRun(run, ['-C', path, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
     const stashed = stash.stdout.trim().length > 0;
-    return uncommitted || unpushed || stashed;
+    const kinds = [];
+    if (uncommitted)
+        kinds.push('uncommitted');
+    if (unpushed)
+        kinds.push('unpushed');
+    if (stashed)
+        kinds.push('stashed');
+    return { dirty: kinds.length > 0, kinds, noUpstream: upstream.code !== 0 };
+}
+/**
+ * The boolean form — checkoutReclaim.ts's immediate-pre-delete re-check uses
+ * this EXACT definition rather than reimplementing it. One dirty definition,
+ * every caller.
+ */
+async function checkDirty(path, run, readText) {
+    const r = await inspectDirty(path, run, readText);
+    return r === 'unparseable' ? r : r.dirty;
 }
 async function scanOne(reposBaseDir, workspaceId, deps, cache) {
     const path = `${reposBaseDir}/${workspaceId}`;
+    const unparseable = (reason) => {
+        cache?.delete(workspaceId);
+        return { workspaceId, unparseable: true, reason, scanVersion: exports.INVENTORY_SCAN_VERSION };
+    };
     let mtimeMs;
     try {
         mtimeMs = deps.statMtimeMs(path);
@@ -81,37 +218,35 @@ async function scanOne(reposBaseDir, workspaceId, deps, cache) {
     catch {
         mtimeMs = null;
     }
-    if (mtimeMs === null) {
-        cache?.delete(workspaceId);
-        return { workspaceId, unparseable: true, reason: 'checkout directory is missing or unreadable' };
-    }
-    // Unchanged since the last scan — reuse the cached entry rather than
-    // re-running du/git for it (PRD: "Unchanged checkouts should not be
-    // re-scanned — cache keyed on mtime").
+    if (mtimeMs === null)
+        return unparseable('checkout directory is missing or unreadable');
+    // The SIZE is reused while the directory mtime is unchanged (PRD: "cache
+    // keyed on mtime" — `du` is the expensive half). The dirty state is NOT:
+    // a commit or a push lands inside .git and never touches the top-level
+    // mtime, so a cached dirty flag outlived the push that cleared it.
     const cached = cache?.get(workspaceId);
-    if (cached && cached.mtimeMs === mtimeMs) {
-        return cached;
-    }
     try {
         const [bytes, dirty] = await Promise.all([
-            deps.sizeBytes(path),
-            checkDirty(path, deps.run),
+            cached && cached.mtimeMs === mtimeMs ? Promise.resolve(cached.bytes) : deps.sizeBytes(path),
+            inspectDirty(path, deps.run, deps.readText),
         ]);
-        if (dirty === 'unparseable') {
-            cache?.delete(workspaceId);
-            return { workspaceId, unparseable: true, reason: 'git status failed — not a usable checkout' };
-        }
-        const entry = { workspaceId, unparseable: false, bytes, dirty, mtimeMs };
+        if (dirty === 'unparseable')
+            return unparseable('git status failed — not a usable checkout');
+        const entry = {
+            workspaceId,
+            unparseable: false,
+            bytes,
+            dirty: dirty.dirty,
+            mtimeMs,
+            dirtyKinds: dirty.kinds,
+            noUpstream: dirty.noUpstream,
+            scanVersion: exports.INVENTORY_SCAN_VERSION,
+        };
         cache?.set(workspaceId, entry);
         return entry;
     }
     catch (err) {
-        cache?.delete(workspaceId);
-        return {
-            workspaceId,
-            unparseable: true,
-            reason: err instanceof Error ? err.message : String(err),
-        };
+        return unparseable(err instanceof Error ? err.message : String(err));
     }
 }
 /**
@@ -149,10 +284,17 @@ async function scanCheckoutInventory(reposBaseDir, deps, cache) {
  */
 function createCheckoutInventoryReporter(opts) {
     let inFlight = false;
+    // A trigger that lands mid-scan (a Save finishing, the arena asking for a
+    // fresh report) is remembered and run ONCE after the current pass — the
+    // pass in flight may have read the checkout before the change, and dropping
+    // the request left the Storage view showing the old state for good.
+    let again = false;
     const cache = new Map();
     function trigger() {
-        if (inFlight)
-            return; // already running — not restarted
+        if (inFlight) {
+            again = true;
+            return;
+        } // not restarted — queued once
         inFlight = true;
         scanCheckoutInventory(opts.reposBaseDir, opts.deps, cache)
             .then((checkouts) => {
@@ -163,6 +305,10 @@ function createCheckoutInventoryReporter(opts) {
         })
             .finally(() => {
             inFlight = false;
+            if (again) {
+                again = false;
+                trigger();
+            }
         });
     }
     return { trigger };

package/dist/bridge/checkoutParkAndRemove.d.ts

@@ -37,6 +37,19 @@
  *     against the same working tree would race git itself, not merely the
  *     delete — hcs-05's set alone only covers the delete step.
  *
+ * SAVE (cli 0.6.9, owner request "why can't I get these things to save
+ * without removing?"): `park(id, onPhase, { remove: false })` runs the same
+ * commit -> push -> verify and stops there — outcome `saved`, checkout kept.
+ * Remove on a checkout with nothing to park now removes it (through the
+ * reclaimer, which re-checks clean + unattached first): everything in it is
+ * already on a remote, so refusing left clean match copies with no way out
+ * but the 14-day automatic sweep.
+ *
+ * After a verified push the parking branch is recorded as a remote-tracking
+ * ref (`refs/remotes/origin/park/<id>`). The clone is `--single-branch`, so
+ * git does not do this itself, and without it the dirty check (commits no
+ * remote ref contains) could never see that the work is now saved.
+ *
  * PHASES: `committing` / `pushing` / `removing`, reported through the
  * optional `onPhase` callback as each begins — the wire layer
  * (relayClient.ts) turns these into `park-remove-progress` frames so a UI
@@ -55,6 +68,10 @@ export type ParkAndRemoveOutcome = {
     workspaceId: string;
     outcome: 'nothing-to-park';
     branch: string;
+} | {
+    workspaceId: string;
+    outcome: 'saved';
+    branch: string;
 } | {
     workspaceId: string;
     outcome: 'retained';
@@ -87,13 +104,17 @@ export interface CheckoutParkAndRemoveDeps {
      *  hcs-05 already proved. */
     reclaimer: CheckoutReclaimer;
 }
+export interface ParkOptions {
+    /** false = Save: back the work up and keep the checkout. Default true. */
+    remove?: boolean;
+}
 export interface CheckoutParker {
     /** Park (commit + push + remove-on-verified-push) one checkout.
      *  `onPhase`, when given, is called once per phase as it BEGINS —
      *  'committing' first, always; 'pushing' and 'removing' only if the
      *  operation reaches them. Never throws — every failure mode is a typed
      *  outcome, same discipline as CheckoutReclaimer#reclaim. */
-    park(workspaceId: string, onPhase?: (phase: ParkPhase) => void): Promise<ParkAndRemoveOutcome>;
+    park(workspaceId: string, onPhase?: (phase: ParkPhase) => void, opts?: ParkOptions): Promise<ParkAndRemoveOutcome>;
 }
 /**
  * Deterministic from the workspace id alone (no timestamp) — PURE, so a

package/dist/bridge/checkoutParkAndRemove.js

@@ -41,6 +41,19 @@ exports.createCheckoutParker = createCheckoutParker;
  *     against the same working tree would race git itself, not merely the
  *     delete — hcs-05's set alone only covers the delete step.
  *
+ * SAVE (cli 0.6.9, owner request "why can't I get these things to save
+ * without removing?"): `park(id, onPhase, { remove: false })` runs the same
+ * commit -> push -> verify and stops there — outcome `saved`, checkout kept.
+ * Remove on a checkout with nothing to park now removes it (through the
+ * reclaimer, which re-checks clean + unattached first): everything in it is
+ * already on a remote, so refusing left clean match copies with no way out
+ * but the 14-day automatic sweep.
+ *
+ * After a verified push the parking branch is recorded as a remote-tracking
+ * ref (`refs/remotes/origin/park/<id>`). The clone is `--single-branch`, so
+ * git does not do this itself, and without it the dirty check (commits no
+ * remote ref contains) could never see that the work is now saved.
+ *
  * PHASES: `committing` / `pushing` / `removing`, reported through the
  * optional `onPhase` callback as each begins — the wire layer
  * (relayClient.ts) turns these into `park-remove-progress` frames so a UI
@@ -81,7 +94,8 @@ function createCheckoutParker(deps) {
     // must cover the WHOLE operation (commit+push+remove) and not merely the
     // delete step, which is a SEPARATE lock (hcs-05's reclaimer, reused below).
     const inFlight = new Set();
-    async function park(workspaceId, onPhase) {
+    async function park(workspaceId, onPhase, opts = {}) {
+        const remove = opts.remove !== false;
         // Path safety — resolved from workspaceId ALONE, reusing hcs-05's exact
         // resolver rather than a second implementation. There is no path on the
         // wire to trust in the first place.
@@ -132,14 +146,25 @@ function createCheckoutParker(deps) {
             // A failure here (no upstream configured, detached HEAD, ...) is NOT
             // a hard failure — it just means "assume there might be something to
             // push" and let the push step itself be the source of truth.
-            const ahead = await runGit(deps.run, target, ['rev-list', '@{u}..HEAD', '--count']);
+            // Commits no remote-tracking ref contains — the same definition the
+            // dirty check uses (checkoutInventory.ts inspectDirty).
+            const ahead = await runGit(deps.run, target, ['rev-list', 'HEAD', '--not', '--remotes', '--count']);
             const hasUnpushed = ahead.code === 0 ? parseInt(ahead.stdout.trim(), 10) > 0 : true;
             if (!committedSomething && !hasUnpushed) {
-                // Genuinely nothing to park. Per the issue's acceptance criterion,
-                // this reports "nothing to park" rather than guessing at a delete —
-                // the invariant is "delete only after a PROVEN push", and there is
-                // no push to prove here, so the checkout is retained.
-                return { workspaceId, outcome: 'nothing-to-park', branch };
+                // Genuinely nothing to park: everything here is already on a remote.
+                // Save reports that. Remove goes straight to the reclaimer, whose
+                // own immediate re-check (clean, unattached) still guards the delete.
+                if (!remove)
+                    return { workspaceId, outcome: 'nothing-to-park', branch };
+                phase = 'removing';
+                onPhase?.(phase);
+                const [cleanResult] = await deps.reclaimer.reclaim([
+                    { workspaceId, verdict: 'RECLAIM', reason: 'park-and-remove: nothing unsaved' },
+                ]);
+                if (cleanResult.outcome === 'removed') {
+                    return { workspaceId, outcome: 'removed', branch, bytesFreed: cleanResult.bytesFreed };
+                }
+                return { workspaceId, outcome: 'retained', branch, phase, reason: cleanResult.reason };
             }
             // ---- PUSHING --------------------------------------------------------
             phase = 'pushing';
@@ -167,6 +192,11 @@ function createCheckoutParker(deps) {
             if (remoteSha !== localSha) {
                 return { workspaceId, outcome: 'retained', branch, phase, reason: `push reported success but the remote ref points at a different commit (${remoteSha.slice(0, 8)} != ${localSha.slice(0, 8)}) — refusing to trust it` };
             }
+            // Record what the remote just proved, so the dirty check sees the work
+            // as saved. Best-effort: the push is already verified either way.
+            await runGit(deps.run, target, ['update-ref', `refs/remotes/origin/${branch}`, localSha]);
+            if (!remove)
+                return { workspaceId, outcome: 'saved', branch };
             // ---- REMOVING -------------------------------------------------------
             // The work is now PROVABLY on the remote. Only past this point may
             // anything be deleted, and only via hcs-05's own executor — see the

package/dist/bridge/claudeTrust.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Playtest 2026-10-01 (Qubit Forge, hosted lane) — pre-trust the workspace
+ * checkouts this bridge itself clones, so Claude Code never opens on its
+ * folder-trust dialog in them.
+ *
+ * Claude Code (2.1.28x) shows "Quick safety check: Is this a project you
+ * created or one you trust? … ❯ No, exit / Yes, I trust this folder" on any
+ * folder its config has not trusted — EVEN under --dangerously-skip-
+ * permissions — and the default is "No, exit". Every match / workspace gets a
+ * fresh /data/repos/<workspaceId>, so every first agent there met it, and a
+ * queued first message (Send to agent) answered it with the default: Claude
+ * exited to a bare shell.
+ *
+ * The container is ours, the bridge cloned the folder from the workspace's own
+ * repo, and the agent was launched in bypass mode by the pilot's own spawn
+ * choice — the trust question has nobody meaningful to ask. So the bridge
+ * records the answer Claude would: `projects[<dir>].hasTrustDialogAccepted =
+ * true` in `$CLAUDE_CONFIG_DIR/.claude.json` (where Claude keeps its global
+ * config when CLAUDE_CONFIG_DIR is set — verified against 2.1.286).
+ *
+ * The entry must name the checkout itself: inside a git repo Claude only walks
+ * up to the repo ROOT looking for a trusted entry, so trusting /data/repos
+ * would not count.
+ *
+ * Scope: HOSTED LANE ONLY (commands/bridge.ts wires it into the container's
+ * clone-on-demand path, and only when CLAUDE_CONFIG_DIR is set), and only for
+ * folders strictly inside the bridge's repos dir. A local-lane user's own
+ * Claude config is never touched.
+ *
+ * Never clobbers: an unparseable config (it also carries onboarding/login
+ * state) is left alone; every other key is preserved; the write is tmp+rename.
+ */
+export type ClaudeTrustResult = 'trusted' | 'already' | 'skipped';
+export declare function trustClaudeProjectDir(dir: string, opts: {
+    configDir: string;
+    reposBaseDir: string;
+}): ClaudeTrustResult;

package/dist/bridge/claudeTrust.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trustClaudeProjectDir = trustClaudeProjectDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function trustClaudeProjectDir(dir, opts) {
+    const base = path.resolve(opts.reposBaseDir);
+    const target = path.resolve(dir);
+    if (!target.startsWith(base + path.sep))
+        return 'skipped';
+    const file = path.join(opts.configDir, '.claude.json');
+    let cfg = {};
+    let raw = null;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch {
+        raw = null; // no config yet — Claude merges its defaults over what we write
+    }
+    if (raw !== null) {
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                return 'skipped';
+            cfg = parsed;
+        }
+        catch {
+            return 'skipped';
+        }
+    }
+    const projects = cfg.projects && typeof cfg.projects === 'object' && !Array.isArray(cfg.projects)
+        ? cfg.projects
+        : {};
+    const entry = projects[target] && typeof projects[target] === 'object' ? projects[target] : {};
+    if (entry.hasTrustDialogAccepted === true)
+        return 'already';
+    const next = { ...cfg, projects: { ...projects, [target]: { ...entry, hasTrustDialogAccepted: true } } };
+    fs.mkdirSync(opts.configDir, { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch (err) {
+        try {
+            fs.rmSync(tmp, { force: true });
+        }
+        catch { /* best effort */ }
+        throw err;
+    }
+    return 'trusted';
+}

package/dist/bridge/config.d.ts

@@ -1,7 +1,7 @@
 export interface BridgeConfig {
     connectToken: string;
     /** lws-03: set once this machine auto-registers as a device (first
-     *  `wen-market bridge` run) — persisted so re-registration is idempotent. */
+     *  `hiveop bridge` run) — persisted so re-registration is idempotent. */
     deviceId?: string;
 }
 export interface DiscoveryInfo {

package/dist/bridge/contextWriter.d.ts

@@ -32,6 +32,8 @@ export declare function writeContext(input: {
     /** Absent only for a pointers-only refresh (wmr-07). */
     content?: string;
     workGraphAvailable?: boolean;
+    /** 2026-10-02 — a match workspace: MATCH_POINTER replaces the work-queue pointer (workSection). */
+    match?: boolean;
     /**
      * wmr-01 — whether to carry the workspace-memory guidance. Decided by the
      * caller on the same signal as workGraphAvailable (WENRWA_CONNECT_TOKEN),

package/dist/bridge/contextWriter.js

@@ -148,8 +148,9 @@ function writeContext(input, deps) {
         return existing.slice(s0 + exports.CONTEXT_START_MARKER.length, e0).trim();
     })();
     const pointers = [];
-    if (input.workGraphAvailable)
-        pointers.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    const work = (0, workGraphPointer_1.workSection)(input);
+    if (work)
+        pointers.push(work);
     if (input.memoryAvailable)
         pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
     // wmr-07: a pointers-only refresh keeps the region's existing file content

package/dist/bridge/deviceRegistration.d.ts

@@ -1,5 +1,5 @@
 /**
- * lws-03 — "Connect this machine": on first `wen-market bridge` run with a
+ * lws-03 — "Connect this machine": on first `hiveop bridge` run with a
  * Connect Token configured, auto-register the device and persist its id
  * into bridge-config.json so re-registration is skipped thereafter (a
  * pure resolver, mirroring resolveRelayMode in commands/bridge.ts, so the

package/dist/bridge/envSanitize.d.ts

@@ -20,7 +20,7 @@ export declare const STRIPPED_ENV_PREFIXES: readonly ["CLAUDE_CODE_"];
  * fcct-27 — the RELAY CREDENTIALS are stripped here too, for a different and
  * sharper reason than the session markers above.
  *
- * `wen-market bridge` reads `CREW_RELAY_TOKEN` / `RELAY_TOKEN` from its own
+ * `hiveop bridge` reads `CREW_RELAY_TOKEN` / `RELAY_TOKEN` from its own
  * environment (the launch agent sets them), and every PTY it spawns inherits
  * that environment. Seen live 2026-08-16: a crew member's `claude` process had
  * the device-bound connect token sitting in plain view in `ps eww`. Nothing

package/dist/bridge/envSanitize.js

@@ -24,7 +24,7 @@ exports.STRIPPED_ENV_PREFIXES = ['CLAUDE_CODE_'];
  * fcct-27 — the RELAY CREDENTIALS are stripped here too, for a different and
  * sharper reason than the session markers above.
  *
- * `wen-market bridge` reads `CREW_RELAY_TOKEN` / `RELAY_TOKEN` from its own
+ * `hiveop bridge` reads `CREW_RELAY_TOKEN` / `RELAY_TOKEN` from its own
  * environment (the launch agent sets them), and every PTY it spawns inherits
  * that environment. Seen live 2026-08-16: a crew member's `claude` process had
  * the device-bound connect token sitting in plain view in `ps eww`. Nothing

package/dist/bridge/folderRegistry.js

@@ -41,7 +41,7 @@ exports.removeEntryByWorkspaceId = removeEntryByWorkspaceId;
 exports.findEntryByPath = findEntryByPath;
 exports.findEntryByWorkspaceId = findEntryByWorkspaceId;
 /**
- * lws-03 — folder→workspace registry. Backs `wen-market local add/list/
+ * lws-03 — folder→workspace registry. Backs `hiveop local add/list/
  * remove` and the discovery advertisement (server.ts). Lives alongside the
  * bridge's other dotfiles under ~/.wen-market/ rather than a second dotdir,
  * matching config.ts's convention. File-backed so it survives daemon

package/dist/bridge/localAdd.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addLocalWorkspaceCore = addLocalWorkspaceCore;
 /**
  * lws-05 — bridge-side idempotent add core, behind POST /local/add. Mirrors
- * `wen-market local add`'s behavior (commands/local.ts) so the arena
+ * `hiveop local add`'s behavior (commands/local.ts) so the arena
  * create-modal's Browse/typed-path attach mechanisms (PRD D3b/D3c) end at the
  * exact same registered-workspace outcome as the CLI mechanism (D3a) —
  * deps-injected so server.ts can wire it without this module knowing about

package/dist/bridge/localContextWriter.d.ts

@@ -29,6 +29,8 @@ export declare function writeLocalContext(input: {
     /** Absent only for a pointers-only refresh (wmr-07). */
     content?: string;
     workGraphAvailable?: boolean;
+    /** 2026-10-02 — a match workspace: MATCH_POINTER replaces the work-queue pointer (workSection). */
+    match?: boolean;
     /** wmr-04 — two-lane parity with contextWriter.ts. Gated by the caller on
      *  the local lane's own honest signal (did THIS bridge run register the
      *  MCP server), not on a container env var that does not exist here. */

package/dist/bridge/localContextWriter.js

@@ -89,8 +89,9 @@ function writeLocalContext(input, deps) {
     // this would be a two-lane bug nobody would notice until a local pilot
     // reported missing memory.
     const pointers = [];
-    if (input.workGraphAvailable)
-        pointers.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    const work = (0, workGraphPointer_1.workSection)(input);
+    if (work)
+        pointers.push(work);
     if (input.memoryAvailable)
         pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
     // wmr-07 — the whole local file is bridge-owned, so "preserve the pushed