@wenrwa/marketplace-cli 0.5.23 → 0.5.24

package/dist/__tests__/bridge-context-writer.test.js

@@ -192,3 +192,90 @@ describe('writeContext — path safety (writes nothing outside the workspace)',
         expect(files.size).toBe(0);
     });
 });
+/**
+ * wmr-01 — the memory pointer rides the same managed region as the work-graph
+ * pointer, gated the same way (the caller decides; absence is byte-identical
+ * to before). The no-op proof below is the load-bearing one: every agent on
+ * every attach gets this file, so a regression here is a regression for the
+ * whole fleet.
+ */
+describe('writeContext — workspace memory pointer (wmr-01)', () => {
+    const { MEMORY_POINTER } = require('../bridge/memoryPointer');
+    it('writes the memory pointer into the region when the caller says it is available', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '', memoryAvailable: true }, deps);
+        expect(files.get(CLAUDE)).toContain(MEMORY_POINTER);
+    });
+    it('NO-OP PROOF: without the flag the output is byte-identical to before', () => {
+        const withFlag = makeFs();
+        const withoutFlag = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'pushed content' }, withoutFlag.deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'pushed content', memoryAvailable: false }, withFlag.deps);
+        expect(withFlag.files.get(CLAUDE)).toBe(withoutFlag.files.get(CLAUDE));
+        expect(withoutFlag.files.get(CLAUDE)).not.toContain('Workspace memory');
+    });
+    it('coexists with the work-graph pointer and the arena\'s pushed content', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({
+            workspaceId: 'ws-7',
+            content: 'pushed content',
+            workGraphAvailable: true,
+            memoryAvailable: true,
+        }, deps);
+        const written = files.get(CLAUDE);
+        expect(written).toContain(workGraphPointer_1.WORK_GRAPH_POINTER);
+        expect(written).toContain(MEMORY_POINTER);
+        expect(written).toContain('pushed content');
+        // All of it inside the managed fence — nothing leaks into the user's own file.
+        const body = written.slice(written.indexOf(contextWriter_1.CONTEXT_START_MARKER), written.indexOf(contextWriter_1.CONTEXT_END_MARKER));
+        expect(body).toContain(MEMORY_POINTER);
+    });
+    it('keeps the region alive on the pointer alone, with no pushed content', () => {
+        // Same rule wgcp-01 established: a pointer is reason enough to keep the
+        // region — it must not vanish just because the arena pushed nothing.
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '', memoryAvailable: true }, deps);
+        expect(files.get(CLAUDE)).toContain(contextWriter_1.CONTEXT_START_MARKER);
+    });
+    it('is idempotent — re-writing the same inputs does not duplicate the pointer', () => {
+        const { files, deps } = makeFs();
+        const input = { workspaceId: 'ws-7', content: 'x', memoryAvailable: true };
+        (0, contextWriter_1.writeContext)(input, deps);
+        (0, contextWriter_1.writeContext)(input, deps);
+        const written = files.get(CLAUDE);
+        expect(written.split('## Workspace memory')).toHaveLength(2);
+    });
+});
+/**
+ * wmr-03 — the brief reaching the hosted context file. The failing-fetch case
+ * is the load-bearing one: PRD decision D2 is that memory can never stop a
+ * terminal from opening.
+ */
+describe('writeContext — the memory brief (wmr-03)', () => {
+    const { MEMORY_POINTER } = require('../bridge/memoryPointer');
+    const BRIEF = 'WORKSPACE MEMORY BRIEF (1 entries, 0 flagged)\n- deploy: prod deploys from master';
+    it('writes the brief into the managed region', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '', memoryAvailable: true, memoryBrief: BRIEF }, deps);
+        expect(files.get(CLAUDE)).toContain(BRIEF);
+    });
+    it('a failed fetch (null brief) still writes the instruction', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '', memoryAvailable: true, memoryBrief: null }, deps);
+        const written = files.get(CLAUDE);
+        expect(written).toContain(MEMORY_POINTER);
+        expect(written).toContain(contextWriter_1.CONTEXT_START_MARKER);
+    });
+    it('NO-OP PROOF: a null brief is byte-identical to the wmr-01 output', () => {
+        const withBrief = makeFs();
+        const without = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'x', memoryAvailable: true }, without.deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'x', memoryAvailable: true, memoryBrief: null }, withBrief.deps);
+        expect(withBrief.files.get(CLAUDE)).toBe(without.files.get(CLAUDE));
+    });
+    it('a brief without the gate is never written — the gate still governs', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'x', memoryAvailable: false, memoryBrief: BRIEF }, deps);
+        expect(files.get(CLAUDE)).not.toContain(BRIEF);
+    });
+});

package/dist/__tests__/bridge-local-context-writer.test.js

@@ -150,3 +150,43 @@ describe('writeLocalContext — work graph pointer (wgcp-01)', () => {
         expect(fs.readFileSync(contextPath, 'utf-8')).toBe('## files\n- a.ts');
     });
 });
+/**
+ * wmr-04 — two-lane parity. A local agent gets the same memory section a
+ * hosted one does, in the lane's own bridge-owned file. The standing mandate
+ * is that a feature ships for both lanes or is scoped out in writing; memory
+ * was never scoped out.
+ */
+describe('writeLocalContext — workspace memory (wmr-04)', () => {
+    const { MEMORY_POINTER } = require('../bridge/memoryPointer');
+    const BRIEF = 'WORKSPACE MEMORY BRIEF (1 entries, 0 flagged)\n- deploy: prod deploys from master';
+    it('writes the instruction when memory is available', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04-'));
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: root, content: '', memoryAvailable: true }, realDeps());
+        const written = fs.readFileSync(path.join(root, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8');
+        expect(written).toContain(MEMORY_POINTER);
+    });
+    it('writes the brief alongside it', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04-'));
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: root, content: '', memoryAvailable: true, memoryBrief: BRIEF }, realDeps());
+        expect(fs.readFileSync(path.join(root, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8')).toContain(BRIEF);
+    });
+    it('NO-OP PROOF: without the flag the file is byte-identical to before', () => {
+        const a = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04a-'));
+        const b = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04b-'));
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: a, content: 'pushed' }, realDeps());
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: b, content: 'pushed', memoryAvailable: false, memoryBrief: BRIEF }, realDeps());
+        expect(fs.readFileSync(path.join(b, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8')).toBe(fs.readFileSync(path.join(a, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8'));
+    });
+    it('a failed fetch still writes the instruction', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04-'));
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: root, content: '', memoryAvailable: true, memoryBrief: null }, realDeps());
+        expect(fs.readFileSync(path.join(root, localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH), 'utf-8')).toContain(MEMORY_POINTER);
+    });
+    it('never touches the user\'s own CLAUDE.md', () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wmr04-'));
+        const usersOwn = path.join(root, 'CLAUDE.md');
+        fs.writeFileSync(usersOwn, 'the user wrote this');
+        (0, localContextWriter_1.writeLocalContext)({ projectRoot: root, content: '', memoryAvailable: true, memoryBrief: BRIEF }, realDeps());
+        expect(fs.readFileSync(usersOwn, 'utf-8')).toBe('the user wrote this');
+    });
+});

package/dist/__tests__/bridge-memory-brief.test.d.ts

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

package/dist/__tests__/bridge-memory-brief.test.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — wmr-02: bridge/memoryBrief.ts. The brief fetcher never breaks a
+ * terminal: every failure mode (non-200, network error, malformed body,
+ * missing token, timeout) must resolve null, never throw — and every test
+ * here asserts against a stubbed transport what request was ACTUALLY
+ * SENT (url, method, Authorization header), not just that a canned
+ * fixture comes back.
+ */
+const memoryBrief_1 = require("../bridge/memoryBrief");
+const ORIGINAL_ENV = { ...process.env };
+function fakeFetch(handler) {
+    return async (url, init) => {
+        const { ok, status, body } = handler(url, init);
+        return { ok, status, json: async () => body };
+    };
+}
+describe('fetchMemoryBrief', () => {
+    beforeEach(() => {
+        process.env.WENRWA_CONNECT_TOKEN = 'wm_ct_' + 'a'.repeat(32);
+        delete process.env.MARKETPLACE_API_URL;
+    });
+    afterEach(() => {
+        process.env = { ...ORIGINAL_ENV };
+    });
+    it('returns the brief text on a 200 and sends an authenticated GET at the right URL', async () => {
+        let seenUrl = '';
+        let seenInit = {};
+        const fetchImpl = async (url, init) => {
+            seenUrl = url;
+            seenInit = init;
+            return { ok: true, status: 200, json: async () => ({ success: true, brief: 'workspace uses pnpm, not npm' }) };
+        };
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-123', { fetchImpl });
+        expect(brief).toBe('workspace uses pnpm, not npm');
+        expect(seenUrl).toBe('https://api.wenrwa.com/api/v1/workspaces/ws-123/memory/brief');
+        expect(seenInit.method).toBe('GET');
+        expect(seenInit.headers.Authorization).toBe(`Bearer ${process.env.WENRWA_CONNECT_TOKEN}`);
+    });
+    it('honours MARKETPLACE_API_URL when set', async () => {
+        process.env.MARKETPLACE_API_URL = 'https://api.test.internal/api/v1';
+        let seenUrl = '';
+        const fetchImpl = async (url) => {
+            seenUrl = url;
+            return { ok: true, status: 200, json: async () => ({ success: true, brief: 'hello' }) };
+        };
+        await (0, memoryBrief_1.fetchMemoryBrief)('ws-456', { fetchImpl });
+        expect(seenUrl).toBe('https://api.test.internal/api/v1/workspaces/ws-456/memory/brief');
+    });
+    it('returns null — never throws — on a non-200 response', async () => {
+        const fetchImpl = fakeFetch(() => ({ ok: false, status: 500, body: { success: false } }));
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+    });
+    it('returns null — never throws — when the transport throws a network error', async () => {
+        const fetchImpl = async () => {
+            throw new Error('ECONNREFUSED');
+        };
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+    });
+    it('returns null — never throws — on malformed JSON (json() rejects)', async () => {
+        const fetchImpl = async () => ({
+            ok: true,
+            status: 200,
+            json: async () => {
+                throw new SyntaxError('Unexpected token in JSON');
+            },
+        });
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+    });
+    it('returns null — never throws — on a well-formed but wrongly-shaped body', async () => {
+        const fetchImpl = fakeFetch(() => ({ ok: true, status: 200, body: { success: true } })); // no `brief`
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+    });
+    it('returns null and never calls the transport when the Connect Token is missing', async () => {
+        delete process.env.WENRWA_CONNECT_TOKEN;
+        const fetchImpl = jest.fn();
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+        expect(fetchImpl).not.toHaveBeenCalled();
+    });
+    it('returns null and never calls the transport when the Connect Token is empty', async () => {
+        process.env.WENRWA_CONNECT_TOKEN = '';
+        const fetchImpl = jest.fn();
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl });
+        expect(brief).toBeNull();
+        expect(fetchImpl).not.toHaveBeenCalled();
+    });
+    it('aborts and returns null when the backend hangs past the bounded timeout', async () => {
+        let aborted = false;
+        const fetchImpl = (_url, init) => new Promise((_resolve, reject) => {
+            init?.signal?.addEventListener('abort', () => {
+                aborted = true;
+                const err = new Error('The operation was aborted');
+                err.name = 'AbortError';
+                reject(err);
+            });
+        });
+        const brief = await (0, memoryBrief_1.fetchMemoryBrief)('ws-1', { fetchImpl, timeoutMs: 15 });
+        expect(aborted).toBe(true);
+        expect(brief).toBeNull();
+    }, 2000);
+});

package/dist/__tests__/bridge-memory-pointer.test.d.ts

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

package/dist/__tests__/bridge-memory-pointer.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * wmr-01 — telling the agent that workspace memory exists.
+ *
+ * Workspace Memory shipped complete and held ZERO entries for a month: agents
+ * could not write (a Connect Token allowlist omission, fixed in cb5e725) and
+ * nothing ever told them the store existed. With writes working, the remaining
+ * half is guidance — an agent that is never told `memory_write` exists will
+ * never call it, exactly as no agent knew about the work graph before
+ * wgcp-01 put a pointer in this same managed region.
+ *
+ * This is the tracer bullet: STATIC text only, no fetch, cutting the whole
+ * path from the constant to the bytes in the context file.
+ *
+ * Asserts on the IMPORTED runtime value, never this file's own source text —
+ * the doc comment above MEMORY_POINTER echoes similar phrasing, so a
+ * source-matching guard could pass against the comment instead of the
+ * constant (the trap bridge-work-graph-pointer.test.ts already records).
+ */
+const memoryPointer_1 = require("../bridge/memoryPointer");
+describe('MEMORY_POINTER text (wmr-01)', () => {
+    it('names the real tool, so the agent has something to actually call', () => {
+        // If memory_write is ever renamed, this fails here rather than leaving an
+        // agent pointed at a tool that does not exist — the wgcp-01 rule that
+        // pointing at unregistered tools is worse than silence.
+        expect(memoryPointer_1.MEMORY_POINTER).toContain('memory_write');
+    });
+    it('is headed like the other managed-region sections', () => {
+        expect(memoryPointer_1.MEMORY_POINTER.split('\n')[0]).toBe('## Workspace memory');
+    });
+    it('says what is worth keeping — a correction, a decision, a non-obvious fact', () => {
+        expect(memoryPointer_1.MEMORY_POINTER).toMatch(/correct/i);
+        expect(memoryPointer_1.MEMORY_POINTER).toMatch(/decision/i);
+    });
+    it('says what is NOT worth keeping, so the store does not fill with trivia', () => {
+        // Without a stated floor the cheapest thing for a model to record is
+        // whatever it just read, which is precisely what the code already says.
+        expect(memoryPointer_1.MEMORY_POINTER).toMatch(/already/i);
+    });
+    it('does not promise the agent that memory is complete or authoritative', () => {
+        // Entries carry verdicts and can be stale; the brief renders its own
+        // flags. Guidance must not override that framing.
+        expect(memoryPointer_1.MEMORY_POINTER).not.toMatch(/do not re-verify/i);
+        expect(memoryPointer_1.MEMORY_POINTER).not.toMatch(/authoritative/i);
+    });
+    it('is a compact block — this rides in every agent\'s context', () => {
+        expect(Buffer.byteLength(memoryPointer_1.MEMORY_POINTER, 'utf8')).toBeLessThanOrEqual(600);
+    });
+});
+/**
+ * wmr-03 — the workspace's actual memory, rendered beside the instruction.
+ *
+ * The brief arrives pre-formatted and pre-capped by the backend's
+ * brief.service.ts (2048 bytes; tiered pinned → STILL_VALID/ASSERTED →
+ * DRIFTED → UNVERIFIED, each with its own flag text). This composer's whole
+ * job is to place it and to decide when there is nothing to place — it must
+ * never re-rank, re-wrap, re-cap or otherwise reinterpret it, because a second
+ * opinion about ranking here would silently diverge from what the Memory panel
+ * shows the human for the same workspace.
+ */
+describe('memorySection — placing the brief (wmr-03)', () => {
+    const { memorySection, MEMORY_POINTER } = require('../bridge/memoryPointer');
+    it('with no brief, is exactly the standing instruction', () => {
+        expect(memorySection(null)).toBe(MEMORY_POINTER);
+    });
+    it('treats an empty or whitespace-only brief as no brief', () => {
+        // An empty heading reads as "this workspace knows nothing", which is a
+        // different claim from "memory has not been written yet".
+        expect(memorySection('')).toBe(MEMORY_POINTER);
+        expect(memorySection('   \n  ')).toBe(MEMORY_POINTER);
+    });
+    it('carries the brief verbatim, after the instruction', () => {
+        const brief = 'WORKSPACE MEMORY BRIEF (2 entries, 0 flagged)\n- api-shape: GET /foo returns {id}';
+        const out = memorySection(brief);
+        expect(out).toContain(MEMORY_POINTER);
+        expect(out).toContain(brief);
+        expect(out.indexOf(MEMORY_POINTER)).toBeLessThan(out.indexOf(brief));
+    });
+    it('preserves drift flags exactly — an agent acting on a stale fact is the failure this guards', () => {
+        const brief = '- old-route: /v1/foo is the endpoint\n⚠ re-verify before relying: refs changed since abc123';
+        expect(memorySection(brief)).toContain('⚠ re-verify before relying:');
+    });
+    it('passes a brief already at the backend cap through unmodified', () => {
+        const brief = 'x'.repeat(2048);
+        expect(memorySection(brief)).toContain(brief);
+    });
+    it('does not re-cap or truncate — the backend owns that budget', () => {
+        const brief = 'y'.repeat(4096);
+        expect(memorySection(brief)).toContain(brief);
+    });
+});

package/dist/bridge/contextWriter.d.ts

@@ -29,4 +29,17 @@ export declare function writeContext(input: {
     workspaceId: string;
     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;
 }, deps: ContextWriterDeps): ContextWriteResult;

package/dist/bridge/contextWriter.js

@@ -68,6 +68,7 @@ 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 -->';
 /** Build the fenced region block for a non-empty body. */
@@ -100,10 +101,21 @@ 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.
+    //
+    // 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 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;
+    const sections = [];
+    if (input.workGraphAvailable)
+        sections.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    if (input.memoryAvailable)
+        sections.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    if (hasFileContent)
+        sections.push(input.content);
+    const content = sections.length > 0 ? sections.join('\n\n') : input.content;
     const isEmpty = content.trim().length === 0;
     // Locate any existing managed region.
     const startIdx = existing ? existing.indexOf(exports.CONTEXT_START_MARKER) : -1;

package/dist/bridge/localContextWriter.d.ts

@@ -28,4 +28,11 @@ export declare function writeLocalContext(input: {
     projectRoot: string;
     content: string;
     workGraphAvailable?: 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. */
+    memoryAvailable?: boolean;
+    /** wmr-04 — this workspace's composed brief, or null when the fetch failed
+     *  or there is nothing yet. Never blocks the write (PRD D2). */
+    memoryBrief?: string | null;
 }, deps: LocalContextWriterDeps): LocalContextWriteResult;

package/dist/bridge/localContextWriter.js

@@ -55,6 +55,7 @@ exports.writeLocalContext = writeLocalContext;
  */
 const path = __importStar(require("path"));
 const workGraphPointer_1 = require("./workGraphPointer");
+const memoryPointer_1 = require("./memoryPointer");
 exports.LOCAL_CONTEXT_DIR = '.hiveop';
 exports.LOCAL_CONTEXT_FILENAME = 'context.md';
 exports.LOCAL_CONTEXT_RELATIVE_PATH = `${exports.LOCAL_CONTEXT_DIR}/${exports.LOCAL_CONTEXT_FILENAME}`;
@@ -72,10 +73,21 @@ function writeLocalContext(input, deps) {
     // to pre-wgcp-01 behavior (never pointing at unregistered MCP tools); when
     // present, the pointer alone is reason enough to write the file, even with
     // no pushed manifest this turn.
+    //
+    // wmr-04 adds the memory section under the same rule, assembled as a list of
+    // present sections so the joining and empty-content logic is stated once —
+    // the same shape contextWriter.ts uses, because the two lanes diverging on
+    // this would be a two-lane bug nobody would notice until a local pilot
+    // reported missing memory.
     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;
+    const sections = [];
+    if (input.workGraphAvailable)
+        sections.push(workGraphPointer_1.WORK_GRAPH_POINTER);
+    if (input.memoryAvailable)
+        sections.push((0, memoryPointer_1.memorySection)(input.memoryBrief));
+    if (hasFileContent)
+        sections.push(input.content);
+    const content = sections.length > 0 ? sections.join('\n\n') : input.content;
     const isEmpty = content.trim().length === 0;
     if (isEmpty) {
         if (!existed)

package/dist/bridge/memoryBrief.d.ts

@@ -0,0 +1,41 @@
+/**
+ * wmr-02 — bridge-side fetcher for the workspace memory brief
+ * (`GET /workspaces/:id/memory/brief`, PRD decision D2 —
+ * docs/prd/workspace-memory-read-path.md). Mirrors storageQuotaFetch.ts's
+ * shape: injectable fetchImpl (defaults to the global fetch every Node
+ * >=18 the CLI already requires ships), ANY failure resolves null, never
+ * throws. This is deliberately a separate slice from anything that
+ * consumes the brief — proving the failure behaviour before depending on
+ * it is the whole point (see the PRD).
+ *
+ * Its entire contract: never throws, never hangs. On a non-200, network
+ * error, malformed/missing body, a missing/empty Connect Token, or a
+ * timeout, it resolves null so the caller writes the context region
+ * exactly as it would have anyway — memory can never become a single
+ * point of failure for opening a terminal.
+ */
+export type FetchLike = (url: string, init?: {
+    method?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+}>;
+export interface FetchMemoryBriefOpts {
+    /** Injectable transport — tests stub this so nothing hits the network,
+     *  same discipline as apiClient.ts / storageQuotaFetch.ts. Defaults to
+     *  the global fetch. */
+    fetchImpl?: FetchLike;
+    /** Overrides the default bounded timeout, in ms. Tests use this to keep
+     *  the timeout case fast without waiting out the real default. */
+    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.
+ */
+export declare function fetchMemoryBrief(workspaceId: string, opts?: FetchMemoryBriefOpts): Promise<string | null>;

package/dist/bridge/memoryBrief.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * wmr-02 — bridge-side fetcher for the workspace memory brief
+ * (`GET /workspaces/:id/memory/brief`, PRD decision D2 —
+ * docs/prd/workspace-memory-read-path.md). Mirrors storageQuotaFetch.ts's
+ * shape: injectable fetchImpl (defaults to the global fetch every Node
+ * >=18 the CLI already requires ships), ANY failure resolves null, never
+ * throws. This is deliberately a separate slice from anything that
+ * consumes the brief — proving the failure behaviour before depending on
+ * it is the whole point (see the PRD).
+ *
+ * Its entire contract: never throws, never hangs. On a non-200, network
+ * error, malformed/missing body, a missing/empty Connect Token, or a
+ * timeout, it resolves null so the caller writes the context region
+ * exactly as it would have anyway — memory can never become a single
+ * point of failure for opening a terminal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ */
+async function fetchMemoryBrief(workspaceId, opts = {}) {
+    const token = process.env.WENRWA_CONNECT_TOKEN;
+    if (!token)
+        return null; // missing/empty token — never even attempt the call
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl)
+        return null;
+    const apiUrl = process.env.MARKETPLACE_API_URL || DEFAULT_API_URL;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const url = `${apiUrl}/workspaces/${encodeURIComponent(workspaceId)}/memory/brief`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetchImpl(url, {
+            method: 'GET',
+            headers: { Authorization: `Bearer ${token}` },
+            signal: controller.signal,
+        });
+        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;
+    }
+    catch {
+        // network error, abort/timeout, or json() throwing on malformed JSON —
+        // all collapse to the same UNKNOWN outcome, never thrown to the caller.
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/bridge/memoryPointer.d.ts

@@ -0,0 +1,49 @@
+/**
+ * wmr-01 — the guidance that tells an agent workspace memory exists at all.
+ *
+ * Workspace Memory (ADR-0044) shipped complete — store, verdicts, curation UI,
+ * MCP tools — and held ZERO entries in production for a month. Two reasons, and
+ * only one of them was a bug: agents were structurally forbidden from writing
+ * (a Connect Token allowlist omission, fixed in cb5e725), and nothing ever told
+ * them the store existed. Fixing the first without the second just swaps a 403
+ * for an agent that never calls the tool.
+ *
+ * Delivered through the SAME managed-region mechanism as the work-graph pointer
+ * (wgcp-01, workGraphPointer.ts) — contextWriter.ts for the hosted lane,
+ * localContextWriter.ts for local. No new delivery channel, and no image
+ * rebuild: `--append-system-prompt` does not exist in this codebase, and the
+ * hosted lane launches `claude` from a script baked into the image, so argv is
+ * not reachable from here.
+ *
+ * Gated by the CALLER on `WENRWA_CONNECT_TOKEN`, exactly as the work-graph
+ * pointer is: absent means the MCP tools this text names are not registered in
+ * this process, and pointing an agent at a tool it does not have is worse than
+ * silence.
+ *
+ * WHAT THIS TEXT HAS TO EARN. It rides in every agent's context on every
+ * attach, so it states a floor as well as a prompt: without one, the cheapest
+ * thing for a model to record is whatever it just read, which is exactly what
+ * the code already says and what nobody needs repeated. It also never tells an
+ * agent that memory is settled truth — entries carry verdicts, the brief
+ * renders its own `⚠ re-verify before relying:` flags, and the predecessor
+ * this epic replaced (lib/agent-memory.ts) failed precisely by prompting
+ * "confirmed facts — do not re-verify".
+ */
+export declare const MEMORY_POINTER: string;
+/**
+ * wmr-03 — the memory section as it appears in the managed region: the
+ * standing instruction, followed by this workspace's brief when there is one.
+ *
+ * THE BRIEF IS CARRIED VERBATIM. It arrives already composed and already
+ * capped by the backend (brief.service.ts: 2048 bytes, tiered pinned →
+ * STILL_VALID/ASSERTED → DRIFTED → UNVERIFIED, each rendered with its own flag
+ * text). Re-ranking, re-wrapping or re-capping it here would give the agent a
+ * different view of the same workspace than the Memory panel gives the human,
+ * and the two would drift apart with no test able to see it. The one judgement
+ * this function makes is whether there is anything to show at all.
+ *
+ * `null` — the fetch failed, or the workspace has no memory yet — renders the
+ * instruction alone rather than an empty heading. An empty heading reads as
+ * "this workspace knows nothing", which is a different and wrong claim.
+ */
+export declare function memorySection(brief: string | null | undefined): string;

package/dist/bridge/memoryPointer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_POINTER = void 0;
+exports.memorySection = memorySection;
+/**
+ * wmr-01 — the guidance that tells an agent workspace memory exists at all.
+ *
+ * Workspace Memory (ADR-0044) shipped complete — store, verdicts, curation UI,
+ * MCP tools — and held ZERO entries in production for a month. Two reasons, and
+ * only one of them was a bug: agents were structurally forbidden from writing
+ * (a Connect Token allowlist omission, fixed in cb5e725), and nothing ever told
+ * them the store existed. Fixing the first without the second just swaps a 403
+ * for an agent that never calls the tool.
+ *
+ * Delivered through the SAME managed-region mechanism as the work-graph pointer
+ * (wgcp-01, workGraphPointer.ts) — contextWriter.ts for the hosted lane,
+ * localContextWriter.ts for local. No new delivery channel, and no image
+ * rebuild: `--append-system-prompt` does not exist in this codebase, and the
+ * hosted lane launches `claude` from a script baked into the image, so argv is
+ * not reachable from here.
+ *
+ * Gated by the CALLER on `WENRWA_CONNECT_TOKEN`, exactly as the work-graph
+ * pointer is: absent means the MCP tools this text names are not registered in
+ * this process, and pointing an agent at a tool it does not have is worse than
+ * silence.
+ *
+ * WHAT THIS TEXT HAS TO EARN. It rides in every agent's context on every
+ * attach, so it states a floor as well as a prompt: without one, the cheapest
+ * thing for a model to record is whatever it just read, which is exactly what
+ * the code already says and what nobody needs repeated. It also never tells an
+ * agent that memory is settled truth — entries carry verdicts, the brief
+ * renders its own `⚠ re-verify before relying:` flags, and the predecessor
+ * this epic replaced (lib/agent-memory.ts) failed precisely by prompting
+ * "confirmed facts — do not re-verify".
+ */
+exports.MEMORY_POINTER = [
+    '## Workspace memory',
+    'This workspace has a shared memory other agents read: `memory_write` to record something, `memory_recall` to search it.',
+    'Worth recording: a correction you were given, a decision and the reason behind it, a non-obvious fact and the file you learned it from.',
+    'Not worth recording: anything the code already states, or anything you merely read this session.',
+].join('\n');
+/**
+ * wmr-03 — the memory section as it appears in the managed region: the
+ * standing instruction, followed by this workspace's brief when there is one.
+ *
+ * THE BRIEF IS CARRIED VERBATIM. It arrives already composed and already
+ * capped by the backend (brief.service.ts: 2048 bytes, tiered pinned →
+ * STILL_VALID/ASSERTED → DRIFTED → UNVERIFIED, each rendered with its own flag
+ * text). Re-ranking, re-wrapping or re-capping it here would give the agent a
+ * different view of the same workspace than the Memory panel gives the human,
+ * and the two would drift apart with no test able to see it. The one judgement
+ * this function makes is whether there is anything to show at all.
+ *
+ * `null` — the fetch failed, or the workspace has no memory yet — renders the
+ * instruction alone rather than an empty heading. An empty heading reads as
+ * "this workspace knows nothing", which is a different and wrong claim.
+ */
+function memorySection(brief) {
+    if (!brief || brief.trim().length === 0)
+        return exports.MEMORY_POINTER;
+    return `${exports.MEMORY_POINTER}\n\n${brief.trim()}`;
+}

package/dist/bridge/relayClient.d.ts

@@ -227,7 +227,17 @@ export interface RelayClientOpts {
     }) => {
         action: string;
         claudeMdPath: string | null;
-    } | void;
+    } | void
+    /**
+     * wmr-03 — may be async: the hosted implementation fetches this
+     * workspace's memory brief before writing the region. The frame handler
+     * below resolves it rather than becoming async itself, so no other frame
+     * type's ordering changes.
+     */
+     | Promise<{
+        action: string;
+        claudeMdPath: string | null;
+    } | void>;
     /**
      * cve-06 (ADR-0047 / ADR-0032): read ONE file out of the container's
      * workspace checkout — the hosted-lane counterpart of the local bridge's

package/dist/bridge/relayClient.js

@@ -1274,12 +1274,26 @@ function startRelayClient(opts) {
                             send(socket, { t: 'error', message: 'context-manifest unsupported (no workspace checkouts)' });
                             break;
                         }
-                        const result = opts.writeContext({ workspaceId: frame.workspaceId, content: frame.content ?? '' });
-                        send(socket, {
-                            t: 'context-written',
-                            workspaceId: frame.workspaceId,
-                            ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
-                            ...(result && typeof result === 'object' ? { action: result.action } : {}),
+                        // wmr-03: the implementation may be async (it fetches the memory
+                        // brief). Resolved here so the outer message handler stays sync —
+                        // making IT async would change ordering for every frame type. A
+                        // rejection can only come from a bug in the writer, never from the
+                        // brief fetch (which resolves null on any failure, PRD D2), so it
+                        // is answered rather than thrown into an unhandled rejection.
+                        Promise.resolve(opts.writeContext({ workspaceId: frame.workspaceId, content: frame.content ?? '' }))
+                            .then((result) => {
+                            send(socket, {
+                                t: 'context-written',
+                                workspaceId: frame.workspaceId,
+                                ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+                                ...(result && typeof result === 'object' ? { action: result.action } : {}),
+                            });
+                        })
+                            .catch((err) => {
+                            send(socket, {
+                                t: 'error',
+                                message: `context-manifest failed: ${err instanceof Error ? err.message : String(err)}`,
+                            });
                         });
                         break;
                     }

package/dist/bridge/server.d.ts

@@ -197,10 +197,13 @@ export interface BridgeServerOpts {
      * this is a FILE write, not PTY input (ADR-0028), mirroring the hosted
      * lane's contextWriter.ts/relayClient.ts contract.
      */
+    /** wmr-04 — may be async: the implementation fetches this workspace's memory
+     *  brief before writing. The frame handler resolves it rather than becoming
+     *  async itself, so no other frame type's ordering changes. */
     writeLocalContext?: (params: {
         workspaceId: string;
         content: string;
-    }) => LocalContextWriteResult | null;
+    }) => LocalContextWriteResult | null | Promise<LocalContextWriteResult | null>;
     /**
      * fcct-24 — path to the local HiveOp activity JSONL file the activity
      * hooks (registered via a directly-spawned agent's `--settings`, see

package/dist/bridge/server.js

@@ -874,16 +874,27 @@ function startBridgeServer(opts) {
                             send(ws, { t: 'error', message: 'context-manifest unsupported (no local writer wired)' });
                             break;
                         }
-                        const result = opts.writeLocalContext({ workspaceId: frame.workspaceId, content: frame.content });
-                        if (!result) {
-                            send(ws, { t: 'error', message: 'unknown local workspace' });
-                            break;
-                        }
-                        send(ws, {
-                            t: 'context-written',
-                            workspaceId: frame.workspaceId,
-                            ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
-                            action: result.action,
+                        // wmr-04: mirrors the hosted lane — resolved here so the outer
+                        // handler stays sync. A rejection can only be a bug in the writer;
+                        // the brief fetch resolves null on any failure (PRD D2).
+                        Promise.resolve(opts.writeLocalContext({ workspaceId: frame.workspaceId, content: frame.content }))
+                            .then((result) => {
+                            if (!result) {
+                                send(ws, { t: 'error', message: 'unknown local workspace' });
+                                return;
+                            }
+                            send(ws, {
+                                t: 'context-written',
+                                workspaceId: frame.workspaceId,
+                                ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+                                action: result.action,
+                            });
+                        })
+                            .catch((err) => {
+                            send(ws, {
+                                t: 'error',
+                                message: `context-manifest failed: ${err instanceof Error ? err.message : String(err)}`,
+                            });
                         });
                         break;
                     }

package/dist/commands/bridge.js

@@ -73,6 +73,7 @@ const repoCheckout_1 = require("../bridge/repoCheckout");
 const bundleInstaller_1 = require("../bridge/bundleInstaller");
 const agentLaunch_1 = require("../bridge/agentLaunch");
 const contextWriter_1 = require("../bridge/contextWriter");
+const memoryBrief_1 = require("../bridge/memoryBrief");
 const containerFileRelay_1 = require("../bridge/containerFileRelay");
 const claudeTranscriptReader_1 = require("../bridge/claudeTranscriptReader");
 const config_2 = require("../utils/config");
@@ -714,7 +715,14 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // into a fenced managed region of /data/repos/<workspaceId>/CLAUDE.md so
             // Claude Code reads it natively next turn. A FILE, never PTY input;
             // path-safe + idempotent; empty content removes the region.
-            writeContext: ({ workspaceId, content }) => {
+            writeContext: async ({ workspaceId, content }) => {
+                // wmr-03 — the workspace's memory brief, fetched at manifest time so
+                // the agent has it in context from its next turn. Never blocks the
+                // write: fetchMemoryBrief resolves null on any failure (PRD D2), and
+                // carries its own bounded timeout so a hanging backend cannot stall a
+                // terminal opening.
+                const memoryAvailable = Boolean(process.env.WENRWA_CONNECT_TOKEN);
+                const memoryBrief = memoryAvailable ? await (0, memoryBrief_1.fetchMemoryBrief)(workspaceId) : null;
                 const result = (0, contextWriter_1.writeContext)({
                     workspaceId,
                     content,
@@ -724,6 +732,10 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                     // means the MCP tools this pointer names are not registered here —
                     // pointing at tools that do not exist is worse than silence.
                     workGraphAvailable: Boolean(process.env.WENRWA_CONNECT_TOKEN),
+                    // wmr-01 — same gate, same reason: the token is what proves the
+                    // MCP tools named by the memory pointer are registered here.
+                    memoryAvailable,
+                    memoryBrief,
                 }, {
                     reposBaseDir,
                     exists: (p) => fs.existsSync(p),
@@ -1019,10 +1031,15 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         // lws-08 (PRD D9) — a context-manifest frame writes ONLY
         // `.hiveop/context.md` under the resolved local workspace's project
         // root; unknown workspaceId → null (server.ts errors the frame).
-        writeLocalContext: ({ workspaceId, content }) => {
+        writeLocalContext: async ({ workspaceId, content }) => {
             const entry = (0, folderRegistry_1.findEntryByWorkspaceId)((0, folderRegistry_1.loadFolderRegistry)(), workspaceId);
             if (!entry)
                 return null;
+            // wmr-04 — same gate as the work-graph pointer on this lane: whether
+            // THIS bridge run actually registered the MCP server. Fetch failures
+            // resolve null and leave the standing instruction in place (PRD D2).
+            const memoryAvailable = mcp.action !== 'claude-not-found';
+            const memoryBrief = memoryAvailable ? await (0, memoryBrief_1.fetchMemoryBrief)(workspaceId) : null;
             return (0, localContextWriter_1.writeLocalContext)({
                 projectRoot: entry.path,
                 content,
@@ -1034,6 +1051,8 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                 // for "are the tools this pointer names actually registered" —
                 // pointing at tools that do not exist is worse than silence.
                 workGraphAvailable: mcp.action !== 'claude-not-found',
+                memoryAvailable,
+                memoryBrief,
             }, realLocalContextWriterDeps());
         },
         // lws-06 — best-effort `claude` binary check before spawning an

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.5.23",
-  "description": "CLI tool for the Wenrwa Agent Marketplace \u2014 monitor bounties, agents, workspaces, and treasury from your terminal",
+  "version": "0.5.24",
+  "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",
   "homepage": "https://marketplace.wenrwa.com",