@wenrwa/marketplace-cli 0.6.6 → 0.7.0

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

package/dist/bridge/memoryBrief.d.ts

@@ -33,9 +33,21 @@ export interface FetchMemoryBriefOpts {
     timeoutMs?: number;
 }
 /**
- * Fetch the workspace memory brief for `workspaceId`. See the module
- * header for the full failure contract — every branch below returns null
- * rather than propagating an error or letting a slow response block the
- * caller.
+ * The brief reply as the bridge uses it: the brief text (null when empty) and
+ * whether the workspace is a MATCH (2026-10-02 — the reply's `match: true`;
+ * absent on an ordinary workspace and from an older backend).
+ */
+export interface WorkspaceBriefInfo {
+    brief: string | null;
+    match: boolean;
+}
+/**
+ * Fetch the brief reply for `workspaceId`. Same failure contract as the module
+ * header: never throws, never hangs — any failure resolves null (unknown).
+ */
+export declare function fetchWorkspaceBrief(workspaceId: string, opts?: FetchMemoryBriefOpts): Promise<WorkspaceBriefInfo | null>;
+/**
+ * Fetch the workspace memory brief for `workspaceId` — the brief text only
+ * (wmr-02's contract, unchanged: null on any failure or an empty brief).
  */
 export declare function fetchMemoryBrief(workspaceId: string, opts?: FetchMemoryBriefOpts): Promise<string | null>;

package/dist/bridge/memoryBrief.js

@@ -16,17 +16,16 @@
  * point of failure for opening a terminal.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWorkspaceBrief = fetchWorkspaceBrief;
 exports.fetchMemoryBrief = fetchMemoryBrief;
 const DEFAULT_API_URL = 'https://api.wenrwa.com/api/v1';
 /** Bounded so a hanging backend can never stall a terminal open. */
 const DEFAULT_TIMEOUT_MS = 4000;
 /**
- * Fetch the workspace memory brief for `workspaceId`. See the module
- * header for the full failure contract — every branch below returns null
- * rather than propagating an error or letting a slow response block the
- * caller.
+ * Fetch the brief reply for `workspaceId`. Same failure contract as the module
+ * header: never throws, never hangs — any failure resolves null (unknown).
  */
-async function fetchMemoryBrief(workspaceId, opts = {}) {
+async function fetchWorkspaceBrief(workspaceId, opts = {}) {
     const token = process.env.WENRWA_CONNECT_TOKEN;
     if (!token)
         return null; // missing/empty token — never even attempt the call
@@ -47,10 +46,12 @@ async function fetchMemoryBrief(workspaceId, opts = {}) {
         if (!res.ok)
             return null;
         const body = (await res.json());
-        if (body?.success !== true || typeof body.brief !== 'string' || body.brief.length === 0) {
-            return null; // malformed/missing body — never a fabricated brief
-        }
-        return body.brief;
+        if (body?.success !== true)
+            return null;
+        return {
+            brief: typeof body.brief === 'string' && body.brief.length > 0 ? body.brief : null,
+            match: body.match === true,
+        };
     }
     catch {
         // network error, abort/timeout, or json() throwing on malformed JSON —
@@ -61,3 +62,10 @@ async function fetchMemoryBrief(workspaceId, opts = {}) {
         clearTimeout(timer);
     }
 }
+/**
+ * Fetch the workspace memory brief for `workspaceId` — the brief text only
+ * (wmr-02's contract, unchanged: null on any failure or an empty brief).
+ */
+async function fetchMemoryBrief(workspaceId, opts = {}) {
+    return (await fetchWorkspaceBrief(workspaceId, opts))?.brief ?? null;
+}

package/dist/bridge/pairing.d.ts

@@ -1,6 +1,6 @@
 /**
  * lws-14 — device-code pairing (GitHub-CLI / Apple-TV pattern), replacing
- * "mint a Connect Token, copy it, paste it into a shell". `wen-market pair`
+ * "mint a Connect Token, copy it, paste it into a shell". `hiveop pair`
  * requests a code, prints it, and polls until a human approves it in the
  * browser — no secret is ever typed or pasted by the user.
  *

package/dist/bridge/relayClient.js

@@ -1300,7 +1300,13 @@ function startRelayClient(opts) {
                         });
                         break;
                     }
+                    case 'inventory-scan': {
+                        checkoutInventoryReporter?.trigger();
+                        break;
+                    }
+                    case 'park-save':
                     case 'park-remove': {
+                        const removeAfter = frame.t === 'park-remove';
                         // hcs-06: ALWAYS user-initiated (see the frame's own doc comment
                         // in the ClientFrame union above) — commit + push + (only on a
                         // verified push) remove, reporting real phases as
@@ -1320,9 +1326,13 @@ function startRelayClient(opts) {
                         parker
                             .park(frame.workspaceId, (phase) => {
                             send(socket, { t: 'park-remove-progress', workspaceId: frame.workspaceId, ...sidFields, phase });
-                        })
+                        }, { remove: removeAfter })
                             .then((result) => {
                             send(socket, { t: 'park-remove-result', ...sidFields, ...result });
+                            // The row's truth is the inventory, not this result: re-scan
+                            // so a saved checkout reads "Saved" without waiting for the
+                            // next connect.
+                            checkoutInventoryReporter?.trigger();
                         })
                             .catch((err) => {
                             console.error('[bridge] park-and-remove failed:', err);

package/dist/bridge/server.d.ts

@@ -19,7 +19,7 @@ export interface BridgeServerOpts {
      *  (cloned on first use). Absent/null result → shell opens in $HOME. */
     resolveCwd?: (repoUrl: string) => Promise<string | null>;
     /** lws-03: the registered local workspaces to advertise on /discovery, so
-     *  the arena create-modal can live-detect `wen-market local add` without a
+     *  the arena create-modal can live-detect `hiveop local add` without a
      *  daemon restart. A GETTER (not a static array) — server.ts calls it on
      *  every /discovery request, so callers should back it with a fresh
      *  folderRegistry.loadFolderRegistry() read (or an in-memory cache kept

package/dist/bridge/workGraphPointer.d.ts

@@ -32,3 +32,22 @@
  * spec — never "skip the spec, the queue replaces it."
  */
 export declare const WORK_GRAPH_POINTER: string;
+/**
+ * Qubit Forge playtest 2026-10-02 — the guidance a MATCH workspace gets INSTEAD
+ * of the work-queue pointer. An agent in a practice match read "the HiveOp work
+ * queue decides what to work on" and went looking for issues to claim. A match
+ * has no queue to work: its missions are scored by hidden tests when the pilot
+ * presses Submit, against the code on the default branch. So: commit and push,
+ * and leave the issue tools alone (claiming or finishing a mission issue does
+ * not score it).
+ */
+export declare const MATCH_POINTER: string;
+/**
+ * The work section of the pointer block: match guidance for a match
+ * workspace, else the work-queue pointer when its tools are registered.
+ * One function so the hosted and local writers cannot diverge.
+ */
+export declare function workSection(input: {
+    workGraphAvailable?: boolean;
+    match?: boolean;
+}): string | null;

package/dist/bridge/workGraphPointer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WORK_GRAPH_POINTER = void 0;
+exports.MATCH_POINTER = exports.WORK_GRAPH_POINTER = void 0;
+exports.workSection = workSection;
 /**
  * wgcp-01 — the one piece of guidance that tells an agent the workspace work
  * graph exists at all. Nothing today does: the MCP tools (`list_ready_issues`,
@@ -39,3 +40,27 @@ exports.WORK_GRAPH_POINTER = [
     'The HiveOp work queue — not the repo — decides WHAT to work on next: `list_ready_issues` to see what is ready, `claim_issue` before starting, `finish_issue` when done.',
     'Repo files (including `issues/*.md`) may hold the spec for an item you claimed — read them for detail; just do not pick work from them.',
 ].join('\n');
+/**
+ * Qubit Forge playtest 2026-10-02 — the guidance a MATCH workspace gets INSTEAD
+ * of the work-queue pointer. An agent in a practice match read "the HiveOp work
+ * queue decides what to work on" and went looking for issues to claim. A match
+ * has no queue to work: its missions are scored by hidden tests when the pilot
+ * presses Submit, against the code on the default branch. So: commit and push,
+ * and leave the issue tools alone (claiming or finishing a mission issue does
+ * not score it).
+ */
+exports.MATCH_POINTER = [
+    '## Match',
+    'This workspace is a HiveOp match. Missions are scored when the pilot presses Submit: hidden tests run against the code committed and pushed to the default branch.',
+    'Commit and push your work when it is ready. Do not use the issue tools (`list_ready_issues`, `claim_issue`, `finish_issue`) — there is no queue to work here; the mission files (MISSIONS.md, README.md) say what to build.',
+].join('\n');
+/**
+ * The work section of the pointer block: match guidance for a match
+ * workspace, else the work-queue pointer when its tools are registered.
+ * One function so the hosted and local writers cannot diverge.
+ */
+function workSection(input) {
+    if (input.match)
+        return exports.MATCH_POINTER;
+    return input.workGraphAvailable ? exports.WORK_GRAPH_POINTER : null;
+}

package/dist/commands/apps.js

@@ -26,7 +26,7 @@ exports.appsCommand
         const data = await client.get(`/projects?${params}`);
         const projects = data.projects || [];
         if (projects.length === 0) {
-            console.log('No apps found. Create one with: wen-market apps create');
+            console.log('No apps found. Create one with: hiveop apps create');
             return;
         }
         console.log(`${chalk_1.default.dim(`Showing ${projects.length} of ${data.total || projects.length} apps`)}\n`);

package/dist/commands/auth.d.ts

@@ -1,6 +1,6 @@
 /**
  * wha-08 (docs/prd/retire-wallet-header-auth.md, docs/CONTEXT-identity.md) —
- * `wen-market auth login` / `auth logout` / `auth whoami`.
+ * `hiveop auth login` / `auth logout` / `auth whoami`.
  *
  * `login` runs the device-code flow (lws-14's mechanism, purpose=cli_login —
  * see auth/login.ts): a code is minted and printed with the approval URL

package/dist/commands/auth.js

@@ -39,7 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.authCommand = void 0;
 /**
  * wha-08 (docs/prd/retire-wallet-header-auth.md, docs/CONTEXT-identity.md) —
- * `wen-market auth login` / `auth logout` / `auth whoami`.
+ * `hiveop auth login` / `auth logout` / `auth whoami`.
  *
  * `login` runs the device-code flow (lws-14's mechanism, purpose=cli_login —
  * see auth/login.ts): a code is minted and printed with the approval URL
@@ -131,7 +131,7 @@ exports.authCommand
     .action(async () => {
     const config = (0, config_1.loadConfig)();
     if (!config) {
-        (0, format_1.error)('Not signed in. Run: wen-market auth login');
+        (0, format_1.error)('Not signed in. Run: hiveop auth login');
         process.exit(1);
         return;
     }
@@ -151,7 +151,7 @@ exports.authCommand
 async function confirmReplaceExistingLogin(existing) {
     const label = (0, apiKeyFormat_1.shortenKey)(existing.apiKey);
     if (!(0, prompt_1.isInteractive)()) {
-        (0, format_1.error)(`Already signed in (${label}). Run this in an interactive terminal to confirm, or \`wen-market auth logout\` first.`);
+        (0, format_1.error)(`Already signed in (${label}). Run this in an interactive terminal to confirm, or \`hiveop auth logout\` first.`);
         return false;
     }
     const yes = await (0, prompt_1.confirm)(`Already signed in as ${label}. Sign in again? (y/N) `, false);
@@ -163,12 +163,12 @@ async function confirmReplaceExistingLogin(existing) {
 // ── --api-key (CI) path ─────────────────────────────────────────────────
 async function loginWithApiKey(key, apiUrl) {
     if ((0, apiKeyFormat_1.looksLikeWalletPubkey)(key)) {
-        (0, format_1.error)(`That's a wallet address, not an API key. Run \`wen-market auth login\` or create a key at ${SETTINGS_KEYS_URL}`);
+        (0, format_1.error)(`That's a wallet address, not an API key. Run \`hiveop auth login\` or create a key at ${SETTINGS_KEYS_URL}`);
         process.exit(1);
         return;
     }
     if (!(0, apiKeyFormat_1.isRealApiKey)(key)) {
-        (0, format_1.error)(`Not a valid API key (expected one starting with wm_sk_). Run \`wen-market auth login\` or create a key at ${SETTINGS_KEYS_URL}`);
+        (0, format_1.error)(`Not a valid API key (expected one starting with wm_sk_). Run \`hiveop auth login\` or create a key at ${SETTINGS_KEYS_URL}`);
         process.exit(1);
         return;
     }
@@ -228,7 +228,7 @@ async function reportLoginOutcome(outcome, apiUrl) {
             return;
         case 'expired':
         case 'timeout':
-            (0, format_1.error)('Code expired — run `wen-market auth login` again.');
+            (0, format_1.error)('Code expired — run `hiveop auth login` again.');
             return;
         case 'cancelled':
         default: