@wenrwa/marketplace-cli 0.5.23 → 0.6.2

package/dist/__tests__/config.test.js

@@ -37,6 +37,11 @@ const fs = __importStar(require("fs"));
 const config_1 = require("../utils/config");
 jest.mock('fs');
 const mockedFs = fs;
+// wha-08: requireConfig() now validates the stored credential looks like a
+// real API key (wm_sk_…) — every fixture that goes through requireConfig()
+// needs a realistic-looking key; loadConfig() itself is format-agnostic
+// (it's a dumb JSON read — the validation lives in requireConfig()).
+const REAL_KEY = 'wm_sk_' + 'a'.repeat(64);
 afterEach(() => {
     jest.restoreAllMocks();
     delete process.env.MARKETPLACE_API_URL;
@@ -67,8 +72,8 @@ describe('saveConfig()', () => {
     });
 });
 describe('requireConfig()', () => {
-    it('returns config when it exists', () => {
-        const config = { apiKey: 'key', apiUrl: 'http://test' };
+    it('returns config when it exists and looks like a real API key', () => {
+        const config = { apiKey: REAL_KEY, apiUrl: 'http://test' };
         mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
         expect((0, config_1.requireConfig)()).toEqual(config);
     });
@@ -81,6 +86,33 @@ describe('requireConfig()', () => {
         exitSpy.mockRestore();
         errSpy.mockRestore();
     });
+    // wha-08: the interactive CLI used to store a bare wallet public key as
+    // "apiKey" and send it as X-Wallet-Pubkey (the retired header). An
+    // existing user with that old config gets a clear message to sign in
+    // properly instead of the client silently sending a spoofable header.
+    it('exits with clear guidance when the stored credential looks like a wallet address, not an API key', () => {
+        const config = { apiKey: 'AKnL4NNf3DGWZJS6cPknBuEGnVsV4A4m5tgebLHaRSZ9', apiUrl: 'http://test' };
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        (0, config_1.requireConfig)();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const messages = errSpy.mock.calls.map(c => c.join(' ')).join('\n');
+        expect(messages).toContain('wen-market auth login');
+        exitSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+});
+describe('clearConfig()', () => {
+    it('removes the config file', () => {
+        mockedFs.unlinkSync.mockReturnValue(undefined);
+        (0, config_1.clearConfig)();
+        expect(mockedFs.unlinkSync).toHaveBeenCalledWith(expect.stringContaining('config.json'));
+    });
+    it('does not throw when the config file does not already exist', () => {
+        mockedFs.unlinkSync.mockImplementation(() => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); });
+        expect(() => (0, config_1.clearConfig)()).not.toThrow();
+    });
 });
 describe('getApiUrl()', () => {
     it('prefers env var over config', () => {
@@ -92,8 +124,8 @@ describe('getApiUrl()', () => {
         mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
         expect((0, config_1.getApiUrl)()).toBe('http://config-url');
     });
-    it('falls back to default when no config or env', () => {
+    it('falls back to the production marketplace when no config or env (a published CLI must work out of the box)', () => {
         mockedFs.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
-        expect((0, config_1.getApiUrl)()).toBe('http://localhost:3002/api/v1');
+        expect((0, config_1.getApiUrl)()).toBe('https://api.wenrwa.com/api/v1');
     });
 });

package/dist/__tests__/openBrowser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/openBrowser.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — wha-08: `wen-market auth login` tries to open the approval URL in a
+ * browser as best-effort convenience. The code + URL are always printed
+ * regardless (works over SSH), so any failure here must be swallowed, never
+ * surfaced. spawnFn is injectable so this never touches a real process.
+ */
+const openBrowser_1 = require("../utils/openBrowser");
+function fakeChild() {
+    return { unref: jest.fn(), on: jest.fn() };
+}
+describe('openBrowser', () => {
+    it('uses "open" on darwin', () => {
+        const child = fakeChild();
+        const spawnFn = jest.fn().mockReturnValue(child);
+        (0, openBrowser_1.openBrowser)('https://x/settings/cli-login?code=HIVE-7K3Q', { platform: 'darwin', spawnFn });
+        expect(spawnFn).toHaveBeenCalledWith('open', ['https://x/settings/cli-login?code=HIVE-7K3Q'], expect.any(Object));
+    });
+    it('uses "xdg-open" on linux', () => {
+        const child = fakeChild();
+        const spawnFn = jest.fn().mockReturnValue(child);
+        (0, openBrowser_1.openBrowser)('https://x', { platform: 'linux', spawnFn });
+        expect(spawnFn).toHaveBeenCalledWith('xdg-open', ['https://x'], expect.any(Object));
+    });
+    it('uses a shell "start" command on win32', () => {
+        const child = fakeChild();
+        const spawnFn = jest.fn().mockReturnValue(child);
+        (0, openBrowser_1.openBrowser)('https://x', { platform: 'win32', spawnFn });
+        expect(spawnFn).toHaveBeenCalledWith('cmd', expect.arrayContaining(['/c', 'start']), expect.any(Object));
+    });
+    it('never throws when spawning throws synchronously', () => {
+        const spawnFn = jest.fn().mockImplementation(() => { throw new Error('ENOENT'); });
+        expect(() => (0, openBrowser_1.openBrowser)('https://x', { platform: 'linux', spawnFn })).not.toThrow();
+    });
+    it('never throws when the child process reports an error', () => {
+        const child = { unref: jest.fn(), on: jest.fn((event, cb) => { if (event === 'error')
+                cb(new Error('spawn failed')); }) };
+        const spawnFn = jest.fn().mockReturnValue(child);
+        expect(() => (0, openBrowser_1.openBrowser)('https://x', { platform: 'linux', spawnFn })).not.toThrow();
+    });
+});

package/dist/__tests__/prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/prompt.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — wha-08: the "Already signed in as X. Sign in again? (y/N)" prompt.
+ * Streams are injected (no real stdin/stdout) so this is testable without a
+ * TTY, using a PassThrough pipe like other stream-based CLI tests.
+ */
+const stream_1 = require("stream");
+const prompt_1 = require("../utils/prompt");
+function makeStreams() {
+    const input = new stream_1.PassThrough();
+    const output = new stream_1.PassThrough();
+    output.on('data', () => { }); // drain — readline writes the prompt text here
+    return { input, output };
+}
+describe('confirm', () => {
+    it('defaults to the given default value on an empty answer (Enter)', async () => {
+        const { input, output } = makeStreams();
+        const promise = (0, prompt_1.confirm)('Sign in again? (y/N) ', false, { input, output });
+        input.write('\n');
+        expect(await promise).toBe(false);
+    });
+    it('returns true for "y"', async () => {
+        const { input, output } = makeStreams();
+        const promise = (0, prompt_1.confirm)('Sign in again? (y/N) ', false, { input, output });
+        input.write('y\n');
+        expect(await promise).toBe(true);
+    });
+    it('returns true for "yes", case-insensitively', async () => {
+        const { input, output } = makeStreams();
+        const promise = (0, prompt_1.confirm)('Sign in again? (y/N) ', false, { input, output });
+        input.write('YES\n');
+        expect(await promise).toBe(true);
+    });
+    it('returns false for "n" even when the default is true', async () => {
+        const { input, output } = makeStreams();
+        const promise = (0, prompt_1.confirm)('Continue? (Y/n) ', true, { input, output });
+        input.write('n\n');
+        expect(await promise).toBe(false);
+    });
+});
+describe('isInteractive', () => {
+    it('is true only when both stdin and stdout are a TTY', () => {
+        expect((0, prompt_1.isInteractive)({ isTTY: true }, { isTTY: true })).toBe(true);
+        expect((0, prompt_1.isInteractive)({ isTTY: false }, { isTTY: true })).toBe(false);
+        expect((0, prompt_1.isInteractive)({ isTTY: true }, { isTTY: false })).toBe(false);
+        expect((0, prompt_1.isInteractive)({}, {})).toBe(false);
+    });
+});

package/dist/auth/identity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * wha-08 — the one authenticated call `wen-market auth login` (device flow,
+ * to print "Signed in as <name>") and `auth login --api-key` (CI, to verify
+ * the key before saving it) both need. Sends the key as X-API-Key — never
+ * X-Wallet-Pubkey, the retired header this whole PRD exists to remove.
+ *
+ * GET /agents/me works for every account, agent or not: an account with no
+ * registered agent still comes back `{ success: true, agent: null }` (see
+ * MarketplaceController#getMyAgent), so a plain 200 already tells us the key
+ * is valid even when there's no name to show.
+ */
+import { FetchImpl } from '../bridge/apiClient';
+export interface ResolveIdentityResult {
+    ok: boolean;
+    name?: string;
+    message?: string;
+}
+export declare function resolveIdentity(opts: {
+    apiUrl: string;
+    apiKey: string;
+    fetchImpl?: FetchImpl;
+}): Promise<ResolveIdentityResult>;

package/dist/auth/identity.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIdentity = resolveIdentity;
+async function resolveIdentity(opts) {
+    const f = opts.fetchImpl ?? fetch;
+    try {
+        const res = await f(`${opts.apiUrl}/agents/me`, {
+            method: 'GET',
+            headers: { 'X-API-Key': opts.apiKey },
+        });
+        const json = await res.json().catch(() => ({}));
+        if (!res.ok || json?.success === false) {
+            return { ok: false, message: json?.error?.message || `HTTP ${res.status}` };
+        }
+        return { ok: true, name: json?.agent?.name || undefined };
+    }
+    catch (err) {
+        return { ok: false, message: err?.message || 'Could not reach the server' };
+    }
+}

package/dist/auth/login.d.ts

@@ -0,0 +1,80 @@
+/**
+ * wha-08 — `wen-market auth login`: CLI browser login. Device-code pairing
+ * (purpose=cli_login on the shared lws-14 mechanism), same GitHub-CLI /
+ * Apple-TV pattern as bridge pairing (bridge/pairing.ts) — a code is minted,
+ * printed with the approval URL, and polled until a human decides in the
+ * browser.
+ *
+ * Deliberately NOT shared with bridge/pairing.ts: `wen-market pair` (bridge
+ * pairing) must keep working byte-for-byte unchanged, and cli_login has an
+ * outcome bridge pairing's loop never handles — the approval screen lets the
+ * human DENY a CLI login, and this CLI needs to say so plainly rather than
+ * silently waiting out the clock (which is what runPairingPoll would do,
+ * since 'denied' falls through its pending/approved/expired switch).
+ */
+import { PairingPollResponse } from '../bridge/apiClient';
+export interface LoginPollDeps {
+    poll: () => Promise<PairingPollResponse>;
+    sleep: (ms: number) => Promise<void>;
+    intervalMs: number;
+    deadlineMs: number;
+    now: () => number;
+    isCancelled: () => boolean;
+}
+export type LoginPollOutcome = {
+    outcome: 'approved';
+    apiKey: string;
+} | {
+    outcome: 'denied';
+} | {
+    outcome: 'expired';
+} | {
+    outcome: 'timeout';
+} | {
+    outcome: 'cancelled';
+};
+export declare const DEFAULT_LOGIN_POLL_INTERVAL_MS = 2000;
+export declare const DEFAULT_LOGIN_POLL_DEADLINE_MS: number;
+export declare function runLoginPoll(deps: LoginPollDeps): Promise<LoginPollOutcome>;
+export interface LoginCoreDeps {
+    requestPairingCode: (opts: {
+        apiUrl: string;
+        deviceLabel: string;
+        purpose: 'cli_login';
+    }) => Promise<{
+        code: string;
+        pollToken: string;
+        expiresAt: string;
+    }>;
+    pollPairingCode: (opts: {
+        apiUrl: string;
+        pollToken: string;
+    }) => Promise<PairingPollResponse>;
+    hostname: () => string;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    isCancelled: () => boolean;
+    intervalMs?: number;
+    deadlineMs?: number;
+    /** Fired the instant the code is minted, before polling starts, so the
+     *  command shell can print it large (+ the approval URL) right away. */
+    onCodeReady?: (info: {
+        code: string;
+        expiresAt: string;
+    }) => void;
+}
+export interface LoginCoreOutcome {
+    code: string;
+    expiresAt: string;
+    result: LoginPollOutcome;
+}
+/**
+ * Pure core: request → poll, network and clock both injected. Deliberately
+ * does NOT write anything to disk — the command shell decides what to save
+ * (and resolves a display name) once it has the 'approved' outcome, so this
+ * stays a single-responsibility "run the device flow" function, mirroring
+ * pairCore's "pure core, thin command shell" split.
+ */
+export declare function loginCore(opts: {
+    apiUrl: string;
+}, deps: LoginCoreDeps): Promise<LoginCoreOutcome>;

package/dist/auth/login.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LOGIN_POLL_DEADLINE_MS = exports.DEFAULT_LOGIN_POLL_INTERVAL_MS = void 0;
+exports.runLoginPoll = runLoginPoll;
+exports.loginCore = loginCore;
+// 2s cadence, ~10min overall deadline — matches the backend's pairing-code
+// TTL (pairing.service.ts TTL_MS) so a locally timed-out poll and a
+// server-expired code mean the same thing to the user.
+exports.DEFAULT_LOGIN_POLL_INTERVAL_MS = 2000;
+exports.DEFAULT_LOGIN_POLL_DEADLINE_MS = 10 * 60_000;
+async function runLoginPoll(deps) {
+    const start = deps.now();
+    for (;;) {
+        if (deps.isCancelled())
+            return { outcome: 'cancelled' };
+        if (deps.now() - start >= deps.deadlineMs)
+            return { outcome: 'timeout' };
+        const result = await deps.poll();
+        if (deps.isCancelled())
+            return { outcome: 'cancelled' };
+        if (result.status === 'approved') {
+            const apiKey = result.apiKey;
+            // Defensive: an approved cli_login poll always carries the raw key
+            // (pairing.service.ts poll()) — anything else means something is
+            // badly wrong server-side, and "expired, try again" is a safer thing
+            // to tell the user than silently reporting success with no key.
+            if (!apiKey)
+                return { outcome: 'expired' };
+            return { outcome: 'approved', apiKey };
+        }
+        if (result.status === 'denied')
+            return { outcome: 'denied' };
+        if (result.status === 'expired')
+            return { outcome: 'expired' };
+        await deps.sleep(deps.intervalMs);
+    }
+}
+/**
+ * Pure core: request → poll, network and clock both injected. Deliberately
+ * does NOT write anything to disk — the command shell decides what to save
+ * (and resolves a display name) once it has the 'approved' outcome, so this
+ * stays a single-responsibility "run the device flow" function, mirroring
+ * pairCore's "pure core, thin command shell" split.
+ */
+async function loginCore(opts, deps) {
+    const { code, pollToken, expiresAt } = await deps.requestPairingCode({
+        apiUrl: opts.apiUrl,
+        deviceLabel: deps.hostname(),
+        purpose: 'cli_login',
+    });
+    deps.onCodeReady?.({ code, expiresAt });
+    const result = await runLoginPoll({
+        poll: () => deps.pollPairingCode({ apiUrl: opts.apiUrl, pollToken }),
+        sleep: deps.sleep,
+        intervalMs: deps.intervalMs ?? exports.DEFAULT_LOGIN_POLL_INTERVAL_MS,
+        deadlineMs: deps.deadlineMs ?? exports.DEFAULT_LOGIN_POLL_DEADLINE_MS,
+        now: deps.now,
+        isCancelled: deps.isCancelled,
+    });
+    return { code, expiresAt, result };
+}

package/dist/bridge/apiClient.d.ts

@@ -30,19 +30,44 @@ export interface PairingCodeResponse {
     pollToken: string;
     expiresAt: string;
 }
+/**
+ * wha-08: `purpose` is optional and omitted by every bridge caller (pair.ts
+ * never passes it), so the request body stays byte-for-byte
+ * `{ deviceLabel }` for the bridge — JSON.stringify drops an undefined-
+ * valued key. Only `auth/login.ts` (cli_login) passes it explicitly.
+ */
 export declare function requestPairingCode(opts: {
     apiUrl: string;
     deviceLabel: string;
+    purpose?: 'bridge' | 'cli_login';
     fetchImpl?: FetchImpl;
 }): Promise<PairingCodeResponse>;
+/**
+ * wha-08: widened (additively) to cover the cli_login purpose — a 'denied'
+ * status (the human declined in the browser — bridge pairing's poll loop
+ * never reaches this branch, see auth/login.ts's header comment) and an
+ * 'approved' response that carries a fresh API key instead of a connect
+ * token + device id. `purpose` is optional/untyped-through on the bridge
+ * variant since the real server has always sent it, but the bridge's own
+ * tests stub responses without it — this stays backward compatible.
+ */
 export type PairingPollResponse = {
     success: true;
     status: 'pending';
 } | {
     success: true;
     status: 'approved';
+    purpose?: 'bridge';
     connectToken: string;
     deviceId: string;
+} | {
+    success: true;
+    status: 'approved';
+    purpose: 'cli_login';
+    apiKey: string;
+} | {
+    success: true;
+    status: 'denied';
 } | {
     success: true;
     status: 'expired';

package/dist/bridge/apiClient.js

@@ -69,8 +69,14 @@ async function pairingRequest(apiUrl, path, body, fetchImpl) {
     }
     return json;
 }
+/**
+ * wha-08: `purpose` is optional and omitted by every bridge caller (pair.ts
+ * never passes it), so the request body stays byte-for-byte
+ * `{ deviceLabel }` for the bridge — JSON.stringify drops an undefined-
+ * valued key. Only `auth/login.ts` (cli_login) passes it explicitly.
+ */
 function requestPairingCode(opts) {
-    return pairingRequest(opts.apiUrl, '/pairing/codes', { deviceLabel: opts.deviceLabel }, opts.fetchImpl);
+    return pairingRequest(opts.apiUrl, '/pairing/codes', { deviceLabel: opts.deviceLabel, purpose: opts.purpose }, opts.fetchImpl);
 }
 function pollPairingCode(opts) {
     return pairingRequest(opts.apiUrl, '/pairing/poll', { pollToken: opts.pollToken }, opts.fetchImpl);

package/dist/bridge/bundleInstaller.d.ts

@@ -17,6 +17,15 @@ export interface BundleInstallerDeps {
     mkdirp: (dir: string) => void;
     /** Write (overwrite) a file. */
     writeFile: (filePath: string, content: string) => void;
+    /**
+     * The three deps a crew SWAP needs. All optional together: absent (any older
+     * caller, or a half-wired dep set) → nothing is ever pruned and this module
+     * behaves exactly as it did before. Pruning deletes files inside a real
+     * checkout, so "not wired" must mean "do nothing", never "guess".
+     */
+    listDir?: (dir: string) => string[];
+    readFile?: (filePath: string) => string;
+    remove?: (filePath: string) => void;
 }
 export type SkipReason = 'unsafe' | 'unmanaged';
 export interface InstallBundleResult {
@@ -29,6 +38,11 @@ export interface InstallBundleResult {
         path: string;
         reason: SkipReason;
     }>;
+    /**
+     * Crew members removed because this bundle replaced them (relative paths).
+     * Reported so an install is auditable rather than silently destructive.
+     */
+    pruned: string[];
 }
 /**
  * A workspaceId is the sole dir segment under reposBaseDir — it must be a plain

package/dist/bridge/bundleInstaller.js

@@ -65,6 +65,15 @@ exports.installBundle = installBundle;
  *     the crew files.
  */
 const path = __importStar(require("path"));
+/**
+ * The marker every forged crew member carries. Its presence is what
+ * distinguishes a file this installer put there from one the pilot wrote by
+ * hand in the same directory — and the pilot's own subagent must survive a
+ * crew swap. If Forge ever stops emitting it, the failure direction is a
+ * stale file left behind, never a deleted one.
+ */
+const CREW_FILE_MARKER = '## Prompt Defense Baseline';
+const AGENTS_DIR_REL = '.claude/agents';
 /**
  * A workspaceId is the sole dir segment under reposBaseDir — it must be a plain
  * id, never a path fragment. Reject anything that could climb out of / redirect
@@ -87,11 +96,12 @@ function isManaged(normalizedRel) {
 function installBundle(bundle, deps) {
     const written = [];
     const skipped = [];
+    const pruned = [];
     // fcct-27: the id is a path segment ONLY when we join it ourselves. An
     // explicit workspaceRoot never puts it on the path, so there is nothing for
     // it to climb out of — but the guard stays for the joining case.
     if (!deps.workspaceRoot && !isSafeWorkspaceId(bundle.workspaceId)) {
-        return { workspaceRoot: null, written, skipped };
+        return { workspaceRoot: null, written, skipped, pruned };
     }
     const workspaceRoot = deps.workspaceRoot
         ? path.posix.resolve(deps.workspaceRoot)
@@ -128,5 +138,49 @@ function installBundle(bundle, deps) {
         deps.writeFile(target, content);
         written.push(normalized);
     }
-    return { workspaceRoot, written, skipped };
+    /*
+      A crew SWAP must replace its members, not pile a new crew on top of the old
+      one. Before this, installBundle only ever wrote: a live container was found
+      holding eight `.claude/agents/*.md` for a five-member crew (and another
+      checkout ten), so subagents from a crew the pilot had detached stayed
+      callable indefinitely.
+  
+      Every condition below exists to make the failure direction "left a stale
+      file" rather than "deleted something of yours":
+        - only inside `.claude/agents`, so CLAUDE.md and the rest of `.claude/`
+          are untouchable here;
+        - only when this bundle installs at least one agent, so a CLAUDE.md-only
+          or skills-only bundle can never empty the crew;
+        - only files carrying CREW_FILE_MARKER, so a hand-written subagent living
+          in the same directory survives;
+        - only when the caller wired listDir/readFile/remove;
+        - and any error reading the directory abandons pruning entirely — an
+          install that wrote its files must not fail because cleanup could not.
+    */
+    const installedAgents = new Set(written.filter((rel) => rel.startsWith(`${AGENTS_DIR_REL}/`)));
+    if (installedAgents.size > 0 && deps.listDir && deps.readFile && deps.remove) {
+        const agentsDir = path.posix.resolve(workspaceRoot, AGENTS_DIR_REL);
+        try {
+            for (const name of deps.listDir(agentsDir)) {
+                if (!name.endsWith('.md'))
+                    continue;
+                const rel = `${AGENTS_DIR_REL}/${name}`;
+                if (installedAgents.has(rel))
+                    continue;
+                const full = path.posix.resolve(agentsDir, name);
+                // Containment, same discipline as the write path above: a listing that
+                // somehow yields a climbing name must not delete outside the directory.
+                if (!full.startsWith(agentsDir + '/'))
+                    continue;
+                if (!deps.readFile(full).includes(CREW_FILE_MARKER))
+                    continue;
+                deps.remove(full);
+                pruned.push(rel);
+            }
+        }
+        catch {
+            // Cleanup is best-effort by design; the bundle is already installed.
+        }
+    }
+    return { workspaceRoot, written, skipped, pruned };
 }

package/dist/bridge/contextWriter.d.ts

@@ -1,5 +1,7 @@
 export declare const CONTEXT_START_MARKER = "<!-- HIVEOP:CONTEXT:START -->";
 export declare const CONTEXT_END_MARKER = "<!-- HIVEOP:CONTEXT:END -->";
+export declare const POINTERS_START_MARKER = "<!-- HIVEOP:POINTERS:START -->";
+export declare const POINTERS_END_MARKER = "<!-- HIVEOP:POINTERS:END -->";
 export interface ContextWriterDeps {
     /** Root holding every workspace's checkout, e.g. `/data/repos`. */
     reposBaseDir: string;
@@ -27,6 +29,27 @@ export interface ContextWriteResult {
  */
 export declare function writeContext(input: {
     workspaceId: string;
-    content: string;
+    /** Absent only for a pointers-only refresh (wmr-07). */
+    content?: string;
     workGraphAvailable?: boolean;
+    /**
+     * wmr-01 — whether to carry the workspace-memory guidance. Decided by the
+     * caller on the same signal as workGraphAvailable (WENRWA_CONNECT_TOKEN),
+     * because it names the same MCP tool registration. Absent/false is
+     * byte-identical to pre-wmr-01 output.
+     */
+    memoryAvailable?: boolean;
+    /**
+     * wmr-03 — this workspace's composed memory brief, or null when the fetch
+     * failed or there is nothing yet. Never blocks the write (PRD D2): a null
+     * brief renders the standing instruction alone.
+     */
+    memoryBrief?: string | null;
+    /**
+     * wmr-07 — refresh ONLY the standing pointers, keeping whatever file
+     * content the region already holds. Used by the bridge when a session
+     * opens, which is the trigger that does not depend on the pilot having
+     * selected files or on a browser being connected at all.
+     */
+    pointersOnly?: boolean;
 }, deps: ContextWriterDeps): ContextWriteResult;

package/dist/bridge/contextWriter.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_END_MARKER = exports.CONTEXT_START_MARKER = void 0;
+exports.POINTERS_END_MARKER = exports.POINTERS_START_MARKER = exports.CONTEXT_END_MARKER = exports.CONTEXT_START_MARKER = void 0;
 exports.writeContext = writeContext;
 /**
  * pucc-int-01 (ADR-0032 / ADR-0028) — container context writer.
@@ -68,8 +68,40 @@ exports.writeContext = writeContext;
 const path = __importStar(require("path"));
 const bundleInstaller_1 = require("./bundleInstaller");
 const workGraphPointer_1 = require("./workGraphPointer");
+const memoryPointer_1 = require("./memoryPointer");
 exports.CONTEXT_START_MARKER = '<!-- HIVEOP:CONTEXT:START -->';
 exports.CONTEXT_END_MARKER = '<!-- HIVEOP:CONTEXT:END -->';
+/*
+  wmr-07 — an inner fence around the standing pointers (work graph, workspace
+  memory), INSIDE the managed region.
+
+  The bridge refreshes those pointers when a session opens, because arena only
+  pushes a context-manifest when the pilot has files selected — so waiting for a
+  push meant the pointers never arrived at all for most workspaces. But the
+  region also holds that pushed file content, and a refresh that rewrote the
+  whole region would eat it. This fence is what lets the two be updated
+  independently: pointers replaced in place, file content left exactly as it is.
+
+  A region written before this fence existed has no markers; it is then treated
+  as file content and the pointer block is inserted above it, which is the
+  correct reading of what it contained.
+*/
+exports.POINTERS_START_MARKER = '<!-- HIVEOP:POINTERS:START -->';
+exports.POINTERS_END_MARKER = '<!-- HIVEOP:POINTERS:END -->';
+/** Split a region body into its pointer block and everything else. */
+function splitRegion(body) {
+    const start = body.indexOf(exports.POINTERS_START_MARKER);
+    const end = body.indexOf(exports.POINTERS_END_MARKER);
+    if (start === -1 || end === -1 || end < start)
+        return { pointers: '', rest: body.trim() };
+    const rest = (body.slice(0, start) + body.slice(end + exports.POINTERS_END_MARKER.length)).trim();
+    return { pointers: body.slice(start, end + exports.POINTERS_END_MARKER.length), rest };
+}
+function pointerBlock(sections) {
+    if (sections.length === 0)
+        return '';
+    return `${exports.POINTERS_START_MARKER}\n${sections.join('\n\n')}\n${exports.POINTERS_END_MARKER}`;
+}
 /** Build the fenced region block for a non-empty body. */
 function regionBlock(content) {
     // Normalize only the region's own trailing newlines so the END marker sits on
@@ -100,10 +132,34 @@ function writeContext(input, deps) {
     // appears — pointing at unregistered MCP tools is worse than silence). When
     // present, the pointer alone is reason enough to keep the region — it does
     // NOT get removed just because there is no pushed file content this turn.
-    const hasFileContent = input.content.trim().length > 0;
-    const content = input.workGraphAvailable
-        ? (hasFileContent ? `${workGraphPointer_1.WORK_GRAPH_POINTER}\n\n${input.content}` : workGraphPointer_1.WORK_GRAPH_POINTER)
-        : input.content;
+    //
+    // wmr-01 adds the memory pointer beside it under the same rule. Both are
+    // assembled as a list of present sections so the joining logic states the
+    // shape once — two independent flags would otherwise need four branches to
+    // get the blank lines right, and the empty-content case is the one that
+    // decides whether the region survives at all.
+    const existingRegion = (() => {
+        if (!existing)
+            return '';
+        const s0 = existing.indexOf(exports.CONTEXT_START_MARKER);
+        const e0 = existing.indexOf(exports.CONTEXT_END_MARKER);
+        if (s0 === -1 || e0 === -1 || e0 < s0)
+            return '';
+        return existing.slice(s0 + exports.CONTEXT_START_MARKER.length, e0).trim();
+    })();
+    const pointers = [];
+    if (input.workGraphAvailable)
+        pointers.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    if (input.memoryAvailable)
+        pointers.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    // wmr-07: a pointers-only refresh keeps the region's existing file content
+    // rather than replacing it with the (absent) `content` argument.
+    const fileContent = input.pointersOnly
+        ? splitRegion(existingRegion).rest
+        : (input.content ?? '').trim();
+    const block = pointerBlock(pointers);
+    const parts = [block, fileContent].filter((part) => part.length > 0);
+    const content = parts.join('\n\n');
     const isEmpty = content.trim().length === 0;
     // Locate any existing managed region.
     const startIdx = existing ? existing.indexOf(exports.CONTEXT_START_MARKER) : -1;