@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/plugins/defaults/memory/__tests__/memory-retrospective-job.test.ts

@@ -2,6 +2,7 @@ import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { AgentLoopExitReason } from "../../../../hooks/types.js";
 import { getWorkspaceDir } from "../paths.js";
 
 // ---------------------------------------------------------------------------
@@ -48,7 +49,14 @@ let priorRetroId: string | null = null;
 let priorRetroOwnerId = "src-conv-1";
 let priorRetroMessages: Array<{ role: string; content: string }> = [];
 
-let mockWakeResult: { invoked: boolean; reason?: string } = { invoked: true };
+// `exitReason` mirrors what the real wake reports for a completed run: the
+// model answered without asking for another tool. The finalizer reads it to
+// tell a finished review from one something else cut short.
+let mockWakeResult: {
+  invoked: boolean;
+  reason?: string;
+  exitReason?: AgentLoopExitReason;
+} = { invoked: true, exitReason: "no_tool_calls" };
 let mockWakeThrows: Error | null = null;
 let wakeCalls: Array<{
   conversationId: string;
@@ -481,7 +489,7 @@ describe("memoryRetrospectiveJob", () => {
     priorRetroId = null;
     priorRetroOwnerId = "src-conv-1";
     priorRetroMessages = [];
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     mockWakeThrows = null;
     wakeCalls = [];
     deletedConversationIds = [];
@@ -822,7 +830,7 @@ describe("memoryRetrospectiveJob", () => {
   // -------------------------------------------------------------------------
 
   test("invoked wake with NO persisted run output: no_usable_output, cursor and log untouched, window retryable", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     // The fork persisted nothing (e.g. a swallowed provider rejection or a
     // zero-output max-tokens stop).
     messagesByConversationId["fork-conv-1"] = [];
@@ -843,14 +851,19 @@ describe("memoryRetrospectiveJob", () => {
         value: 1,
         detail: {
           outcome: "no_usable_output",
-          reason: "run persisted no memory-writing tool call",
+          // The failure reason names what was missing, so an operator reading
+          // the job row can tell a lost write from an unfinished review.
+          reason: "run committed neither a memory write nor a concluding reply",
         },
       },
     ]);
   });
 
-  test("invoked wake whose run persisted only analysis text (no tool calls): no_usable_output, prior retrospective preserved", async () => {
-    mockWakeResult = { invoked: true };
+  test("a run whose reply reads as a conclusion but that the provider cut short: no_usable_output, prior retrospective preserved", async () => {
+    // Same persisted text as a finished review, but the loop ended on the
+    // output-token ceiling rather than on the model's own stop, so the reply
+    // is a fragment of a review, not a verdict on the window.
+    mockWakeResult = { invoked: true, exitReason: "max_tokens_reached" };
     priorRetroId = "prior-retro-1";
     messagesByConversationId["fork-conv-1"] = [
       {
@@ -866,14 +879,38 @@ describe("memoryRetrospectiveJob", () => {
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
 
     expect(outcome.kind).toBe("no_usable_output");
+    if (outcome.kind === "no_usable_output") {
+      expect(outcome.reason).toBe(
+        "run replied without saving anything, but ended on max_tokens_reached rather than a completed review",
+      );
+    }
     expect(stateUpserts).toHaveLength(0);
     // Only this run's own fork is deleted; the prior retrospective (the
     // dedup baseline for the retry) is preserved.
     expect(deletedConversationIds).toEqual(["fork-conv-1"]);
   });
 
-  test("run-message load failure classifies as no_usable_output (fail-closed), not success", async () => {
+  test("a run the loop never reported a terminal exit for cannot advance on a reply alone", async () => {
+    // A checkpoint handoff runs no terminal exit event, so the run resumes
+    // elsewhere and this fork holds an unfinished review.
     mockWakeResult = { invoked: true };
+    messagesByConversationId["fork-conv-1"] = [
+      {
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Nothing to save." }]),
+        createdAt: Date.parse("2026-05-11T10:20:00Z"),
+        metadata: null,
+      },
+    ];
+
+    const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+    expect(outcome.kind).toBe("no_usable_output");
+    expect(stateUpserts).toHaveLength(0);
+  });
+
+  test("run-message load failure classifies as no_usable_output (fail-closed), not success", async () => {
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     // Fork-kind conversation with no stamps and no leading instruction row:
     // `loadRetrospectiveRunMessages` returns null (indeterminate).
     conversationOverrides["fork-conv-1"] = {
@@ -896,7 +933,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("checkpoint-persisted saves on a fork-kind tail count as usable output (rebase-after-live cannot fake no-output)", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     conversationOverrides["fork-conv-1"] = {
       source: "memory-retrospective-fork",
       forkParentMessageId: null,
@@ -945,7 +982,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("scaffold_managed_skill counts as durable work even with zero remembers", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
@@ -982,7 +1019,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("a remember whose execution FAILED (is_error tool_result) is not durable evidence and its facts stay out of the log", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
@@ -1023,41 +1060,91 @@ describe("memoryRetrospectiveJob", () => {
     expect(lastRunAtBumps).toHaveLength(1);
   });
 
-  test("explicit no-findings reply advances the cursor without fabricating a memory write", async () => {
-    mockWakeResult = { invoked: true };
+  // A finished review that found nothing advances on the SHAPE of the run,
+  // never on the wording of the reply. Each phrasing below is a correct
+  // conclusion the model reached on its own; the window it reviewed is
+  // consumed, and the health counter records which kind of success it was.
+  test.each([
+    "Nothing new to save.",
+    "Nothing new to save beyond those two facts.",
+    "Nothing else new to save.",
+    "Done.",
+    "I reviewed the window. Nothing new to save. Here is my reasoning about why each item was already covered by prior passes.",
+  ])(
+    "a completed review that saved nothing advances the cursor: %s",
+    async (reply) => {
+      mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
+      messagesByConversationId["fork-conv-1"] = [
+        {
+          role: "assistant",
+          content: JSON.stringify([{ type: "text", text: reply }]),
+          createdAt: Date.parse("2026-05-11T10:20:00Z"),
+          metadata: null,
+        },
+      ];
+
+      const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
+
+      expect(outcome.kind).toBe("invoked");
+      if (outcome.kind === "invoked") {
+        expect(outcome.noFindings).toBe(true);
+      }
+      expect(stateUpserts).toHaveLength(1);
+      expect(stateUpserts[0]!.lastProcessedMessageId).toBe("m3");
+      expect(stateUpserts[0]!.rememberedLog).toEqual([]);
+      expect(
+        watchdogEvents.filter(
+          (e) => e.checkName === "memory_retrospective_run",
+        ),
+      ).toEqual([
+        {
+          checkName: "memory_retrospective_run",
+          value: 1,
+          detail: { outcome: "invoked", noFindings: true },
+        },
+      ]);
+    },
+  );
+
+  test("narration followed by an empty final response has not concluded and does not advance", async () => {
+    // The reply that proves an empty-handed review must be the run's final
+    // word: text that went live mid-run followed by an empty last response
+    // is an unfinished review, not a conclusion.
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
         content: JSON.stringify([
-          { type: "text", text: "Nothing new to save." },
+          { type: "text", text: "Let me look through the window carefully." },
         ]),
         createdAt: Date.parse("2026-05-11T10:20:00Z"),
         metadata: null,
       },
+      {
+        role: "assistant",
+        content: JSON.stringify([]),
+        createdAt: Date.parse("2026-05-11T10:20:05Z"),
+        metadata: null,
+      },
     ];
 
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
 
-    // A reviewed-and-no-findings pass is a legitimate success: the mandated
-    // exact reply is the positive persisted artifact, the cursor advances,
-    // and the remembered log gains nothing.
-    expect(outcome.kind).toBe("invoked");
-    expect(stateUpserts).toHaveLength(1);
-    expect(stateUpserts[0]!.lastProcessedMessageId).toBe("m3");
-    expect(stateUpserts[0]!.rememberedLog).toEqual([]);
+    expect(outcome.kind).toBe("no_usable_output");
+    if (outcome.kind === "no_usable_output") {
+      expect(outcome.reason).toBe(
+        "run committed neither a memory write nor a concluding reply",
+      );
+    }
+    expect(stateUpserts).toHaveLength(0);
   });
 
-  test("analysis prose that merely mentions the no-findings phrase does not advance", async () => {
-    mockWakeResult = { invoked: true };
+  test("a run whose only text is whitespace has committed nothing and does not advance", async () => {
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
-        content: JSON.stringify([
-          {
-            type: "text",
-            text: "I reviewed the window. Nothing new to save. Here is my reasoning about why each item was already covered by prior passes.",
-          },
-        ]),
+        content: JSON.stringify([{ type: "text", text: "   \n  " }]),
         createdAt: Date.parse("2026-05-11T10:20:00Z"),
         metadata: null,
       },
@@ -1069,8 +1156,8 @@ describe("memoryRetrospectiveJob", () => {
     expect(stateUpserts).toHaveLength(0);
   });
 
-  test("no-findings reply cannot advance a run that attempted a save and failed", async () => {
-    mockWakeResult = { invoked: true };
+  test("a spoken conclusion cannot advance a run that attempted a save and failed", async () => {
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
@@ -1112,13 +1199,18 @@ describe("memoryRetrospectiveJob", () => {
 
     // The run demonstrably had findings (it attempted a save); the failed
     // write must stay retryable rather than being papered over by a
-    // no-findings claim.
+    // no-findings claim, and the job row must say a write was lost.
     expect(outcome.kind).toBe("no_usable_output");
+    if (outcome.kind === "no_usable_output") {
+      expect(outcome.reason).toBe(
+        "run attempted 1 memory write(s), none of which persisted a successful result",
+      );
+    }
     expect(stateUpserts).toHaveLength(0);
   });
 
   test("a remember tool_use with NO persisted tool_result is not durable evidence", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [
       {
         role: "assistant",
@@ -1142,7 +1234,7 @@ describe("memoryRetrospectiveJob", () => {
   });
 
   test("retry after a no_usable_output run advances only once durable output exists", async () => {
-    mockWakeResult = { invoked: true };
+    mockWakeResult = { invoked: true, exitReason: "no_tool_calls" };
     messagesByConversationId["fork-conv-1"] = [];
 
     const first = await memoryRetrospectiveJob(makeJob(), stubConfig);
@@ -1735,6 +1827,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls[0]!.opts.toolContextPin).toEqual({
       hasNoClient: false,
       transportInterface: "web",
+      clientOs: "web",
       requestOrigin: "memory_retrospective",
     });
   });
@@ -1771,7 +1864,11 @@ describe("memoryRetrospectiveJob", () => {
         id: "m2",
         createdAt: Date.parse("2026-05-11T10:05:00Z"),
         role: "user",
-        metadata: JSON.stringify({ userMessageInterface: "macos" }),
+        metadata: JSON.stringify({
+          userMessageInterface: "macos",
+          client: { os: "macos" },
+          clientOsFromRequest: true,
+        }),
       },
       {
         id: "m3",
@@ -1792,6 +1889,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls[0]!.opts.toolContextPin).toEqual({
       hasNoClient: false,
       transportInterface: "macos",
+      clientOs: "macos",
       requestOrigin: "memory_retrospective",
     });
   });
@@ -1815,6 +1913,7 @@ describe("memoryRetrospectiveJob", () => {
     expect(wakeCalls[0]!.opts.toolContextPin).toEqual({
       hasNoClient: false,
       transportInterface: "macos",
+      clientOs: "macos",
       requestOrigin: "memory_retrospective",
     });
   });

package/src/plugins/defaults/memory/__tests__/memory-retrospective-prompt.test.ts

@@ -3,7 +3,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-import { MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT } from "../memory-retrospective-constants.js";
 import {
   buildForkInstruction,
   type ForkInstructionArgs,
@@ -11,6 +10,14 @@ import {
 } from "../memory-retrospective-prompt.js";
 import { getWorkspaceDir } from "../paths.js";
 
+/**
+ * The mandate sentence as the prompt module builds it. Spelled out here
+ * rather than imported so a reworded prompt fails these expectations instead
+ * of silently agreeing with itself.
+ */
+const NO_FINDINGS_MANDATE =
+  "If nothing new is worth saving, say so briefly and stop.";
+
 function makeArgs(
   overrides: Partial<ForkInstructionArgs> = {},
 ): ForkInstructionArgs {
@@ -48,7 +55,7 @@ Two dedup sources to skip:
 1. Anything semantically captured in <already_remembered> above (from prior retrospective passes).
 2. Anything you already called \`remember\` on inline within your review window — those appear as \`tool_use\` blocks with \`name: "remember"\` in your history.
 
-For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. When several facts are worth saving, pass them all as an array to a single \`remember\` call rather than calling it once per fact. If nothing new is worth saving, reply with exactly "Nothing new to save." and stop.
+For everything else in your review window, use the \`remember\` tool on facts, plans, decisions, preferences, names, dates, felt moments, corrections, commitments, or anything else concrete and worth carrying forward. When several facts are worth saving, pass them all as an array to a single \`remember\` call rather than calling it once per fact. If nothing new is worth saving, say so briefly and stop.
 `);
   });
 
@@ -119,11 +126,7 @@ For everything else in your review window, use the \`remember\` tool on facts, p
   test("proc-to-skills inactive: no authoring section, instruction ends at the remember guidance", () => {
     const out = buildForkInstruction(makeArgs());
     expect(out).not.toContain("PROCEDURE");
-    expect(
-      out.endsWith(
-        'If nothing new is worth saving, reply with exactly "Nothing new to save." and stop.\n',
-      ),
-    ).toBe(true);
+    expect(out.endsWith(`${NO_FINDINGS_MANDATE}\n`)).toBe(true);
   });
 
   test("bundled template carries each placeholder exactly once", () => {
@@ -176,17 +179,13 @@ describe("promptOverridePath", () => {
     writeFileSync(overridePath, "Just remember the good parts.\n");
     expect(
       buildForkInstruction(makeArgs({ promptOverridePath: overridePath })),
-    ).toBe(
-      "Just remember the good parts.\n\n\n" +
-        `If nothing new is worth saving, reply with exactly "${MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT}" and stop.`,
-    );
+    ).toBe(`Just remember the good parts.\n\n\n${NO_FINDINGS_MANDATE}`);
   });
 
-  test("an override that drops the no-findings mandate still carries the finalizer's exact-reply contract", () => {
-    // The finalizer advances a no-findings window only on a persisted reply
-    // that trims to exactly MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT. An
-    // override author who never read that code would otherwise stall every
-    // no-findings window forever, so the mandate must survive any override.
+  test("an override that tells a no-findings pass to stay silent still carries the reply mandate", () => {
+    // A pass that saves nothing advances only on a committed reply, so an
+    // override telling it to do nothing would stall every no-findings window
+    // forever. The mandate must survive any override.
     const overridePath = join(dir, "mandate-free.md");
     writeFileSync(
       overridePath,
@@ -195,13 +194,7 @@ describe("promptOverridePath", () => {
     const out = buildForkInstruction(
       makeArgs({ promptOverridePath: overridePath }),
     );
-    expect(out).toContain(
-      `reply with exactly "${MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT}"`,
-    );
-    // The mandate references the same constant the finalizer compares
-    // against, so the two cannot drift; guard the constant's exact value here
-    // to make an accidental rewording loud.
-    expect(MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT).toBe("Nothing new to save.");
+    expect(out.endsWith(NO_FINDINGS_MANDATE)).toBe(true);
   });
 
   test("missing override file falls back to the bundled rendering", () => {
@@ -227,12 +220,9 @@ describe("promptOverridePath", () => {
   });
 });
 
-// The finalizer's explicit-no-findings gate matches persisted assistant text
-// against MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT by strict equality, and the
-// bundled instruction is what teaches the model to emit it. This guard fails
-// if either side drifts.
-test("bundled template mandates the exact no-findings sentinel the finalizer matches", () => {
-  expect(RETROSPECTIVE_INSTRUCTION_TEMPLATE).toContain(
-    `reply with exactly "${MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT}" and stop.`,
-  );
+// A pass that saves nothing advances its window only if it replies at all,
+// and the bundled instruction is what asks for that reply. The wording is
+// free; a template that stopped asking for a reply is not.
+test("bundled template asks a no-findings pass to answer rather than stay silent", () => {
+  expect(RETROSPECTIVE_INSTRUCTION_TEMPLATE).toContain(NO_FINDINGS_MANDATE);
 });

package/src/plugins/defaults/memory/__tests__/memory-retrospective-provider-path.test.ts

@@ -17,9 +17,9 @@
  *   - `invoked: true` alone must therefore NOT advance
  *     `memory_retrospective_state`: the handler re-reads the fork's persisted
  *     rows (`collectRetrospectiveRunEvidence` → `loadRetrospectiveRunMessages`
- *     → `getMessages`) and only advances when a durable memory-writing
- *     `tool_use` (`remember` / `scaffold_managed_skill`) was persisted by THIS
- *     run.
+ *     → `getMessages`) and only advances when THIS run persisted a durable
+ *     memory-writing `tool_use` (`remember` / `scaffold_managed_skill`) or
+ *     replied and stopped on its own (a completed no-findings review).
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -481,16 +481,20 @@ describe("memoryRetrospectiveJob through the real wake + real agent loop", () =>
     expect(lastRunAtBumps).toHaveLength(0);
   });
 
-  test("clean empty reply through the real loop does not advance", async () => {
-    // Scenario C: the model answers with analysis text and no tool calls.
-    // The wake persists the text tail (visible output), but with zero
-    // durable memory-writing tool calls the gate must refuse to advance.
+  test("a text-only conclusion through the real loop advances as a no-findings pass", async () => {
+    // Scenario C: the model answers in its own words and stops without any
+    // tool call. The real loop exits on `no_tool_calls`, so the committed
+    // reply is a finished empty-handed review and the window is consumed.
     providerImpl = async () => textOnlyResponse("Nothing worth saving.");
 
     const outcome = await memoryRetrospectiveJob(makeJob(), stubConfig);
 
-    expect(outcome.kind).toBe("no_usable_output");
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind === "invoked") {
+      expect(outcome.noFindings).toBe(true);
+    }
     expect(providerCalls.length).toBeGreaterThanOrEqual(1);
-    expect(stateUpserts).toHaveLength(0);
+    expect(stateUpserts).toHaveLength(1);
+    expect(stateUpserts[0]!.rememberedLog).toEqual([]);
   });
 });

package/src/plugins/defaults/memory/__tests__/memory-retrospective-wake-chain.test.ts

@@ -24,7 +24,9 @@
  * 2. The failed window stays retryable: a later run over the same window
  *    succeeds and advances state.
  * 3. A usable-output control advances state (cursor, remembered log) and
- *    GCs the superseded prior retrospective.
+ *    GCs the superseded prior retrospective, and a pass that reviewed its
+ *    window and had nothing to save advances it too, in whatever words the
+ *    model chose.
  * 4. A run whose checkpoint went live before a later rejection stays
  *    `invoked: true` (its side effects landed and are honored).
  */
@@ -409,9 +411,8 @@ describe("memory retrospective wake state chain (real AgentLoop)", () => {
     expect(listRetroForksOf(fixture.sourceId)).toEqual([fixture.priorRetroId]);
 
     // (2) The window stays retryable: the same slice succeeds on retry.
-    // The finalizer's usable-output gate accepts free text only when it is
-    // exactly the mandated no-findings sentinel; a verified remember write
-    // is the other accepted evidence. Use the sentinel for the control.
+    // The finalizer accepts a text-only reply as a completed empty-handed
+    // review; a verified remember write is the other accepted evidence.
     providerScript = [{ response: textResponse("Nothing new to save.") }];
     providerCallCount = 0;
     const retry = await runForkBasedRetrospective(
@@ -472,6 +473,31 @@ describe("memory retrospective wake state chain (real AgentLoop)", () => {
     ).toBe(fixture.newMessageId);
   });
 
+  test("a paraphrased empty-handed conclusion consumes the window", async () => {
+    const fixture = await stageChainFixture();
+
+    // The instruction asks a pass with nothing to save to say so; it does not
+    // dictate the sentence. The real loop ends this run on `no_tool_calls`,
+    // which is what proves the model reached its own conclusion.
+    providerScript = [
+      { response: textResponse("Nothing further to save, all covered above.") },
+    ];
+
+    const outcome = await runForkBasedRetrospective(
+      fixture.sourceId,
+      chainConfig,
+    );
+
+    expect(outcome.kind).toBe("invoked");
+    if (outcome.kind === "invoked") {
+      expect(outcome.noFindings).toBe(true);
+    }
+    const state = getRetrospectiveState(fixture.sourceId);
+    expect(state?.lastProcessedMessageId).toBe(fixture.newMessageId);
+    // A pass that saved nothing adds nothing to the dedup baseline.
+    expect(state?.rememberedLog).toEqual([PRIOR_FACT]);
+  });
+
   test("usable-output control: cursor advances, remembered log grows, prior retrospective is GC'd", async () => {
     const fixture = await stageChainFixture();
 
@@ -488,6 +514,7 @@ describe("memory retrospective wake state chain (real AgentLoop)", () => {
     expect(outcome.kind).toBe("invoked");
     if (outcome.kind === "invoked") {
       expect(outcome.cutoffMessageId).toBe(fixture.newMessageId);
+      expect(outcome.noFindings).toBe(false);
     }
 
     // (3) Real finalization against real rows: cursor advanced, this run's

package/src/plugins/defaults/memory/memory-retrospective-constants.ts

@@ -78,14 +78,3 @@ export const MEMORY_RETROSPECTIVE_ORIGIN = "memory_retrospective";
  * set from turn 1, and matched by the permission checker's origin-scoped grant.
  */
 export const SKILL_MANAGEMENT_SKILL_ID = "skill-management";
-
-/**
- * The exact reply the fork instruction mandates when a reviewed window
- * contains nothing worth saving. The finalizer treats a persisted assistant
- * text block that trims to exactly this phrase (with no memory-writing tool
- * attempts in the run) as the positive artifact of a legitimate no-findings
- * review, advancing the cursor without fabricating a memory write. Compared
- * by strict whole-block equality so analysis prose that merely mentions the
- * phrase does not qualify.
- */
-export const MEMORY_RETROSPECTIVE_NO_FINDINGS_TEXT = "Nothing new to save.";

package/src/plugins/defaults/memory/memory-retrospective-fork-boundary.ts

@@ -76,21 +76,27 @@ function isRetrospectiveInstructionRow(metadata: string | null): boolean {
  * Load the messages a retrospective run produced itself, given the
  * retrospective conversation's `source` kind:
  *
- *   - **Fork-kind** rows carry the copied source prefix (the source's visible
- *     tail), so only the post-fork tail (messages strictly after the fork
- *     boundary) counts — scanning the whole row would attribute the source
- *     conversation's own turns to the retrospective. When no row carries a
- *     `forkSourceMessageId` stamp, the fork is run-authored end-to-end only
- *     if its first row is the run's own instruction message (the empty-prefix
- *     tail-only fork); a stampless fork WITHOUT a leading instruction row is
- *     indeterminate — attributing it would mine copied source tool calls as
- *     run output — and degrades to "produced none".
+ *   - **Fork-kind, referential**: the fork copies no prefix. Inherited
+ *     history is read through lineage and keeps the source `conversationId`.
+ *     When no copied-row stamp is present, a mixed-ownership list is that
+ *     shape: rows owned by this conversation are the run, including when
+ *     that set is empty. No separate conversation-row lookup is required.
+ *   - **Fork-kind, cloning**: rows carry the copied source prefix (the
+ *     source's visible tail), so only the post-fork tail (messages strictly
+ *     after the fork boundary) counts. Scanning the whole list would
+ *     attribute the source conversation's own turns to the retrospective.
+ *     When no row carries a `forkSourceMessageId` stamp, the fork is
+ *     run-authored end-to-end only if its first row is the run's own
+ *     instruction message (the empty-prefix tail-only fork). A stampless
+ *     list where every row is owned by this conversation is the
+ *     indeterminate cloning shape: attributing it would mine copied source
+ *     tool calls as run output, so the helper degrades to "produced none".
  *   - **Legacy-kind** rows start empty, so every message is the run's own.
  *
  * Returns `null` when the run's output cannot be determined (message load
- * failure, or the indeterminate stampless shape above) — callers degrade
- * (empty dedup baseline / "no output"). Best-effort: failures are logged,
- * never thrown.
+ * failure, or the indeterminate stampless cloning shape above). Callers
+ * degrade (empty dedup baseline / "no output"). Best-effort: failures are
+ * logged, never thrown.
  */
 export async function loadRetrospectiveRunMessages(
   conversationId: string,
@@ -114,10 +120,18 @@ export async function loadRetrospectiveRunMessages(
         return messages;
       }
       if (isRetrospectiveInstructionRow(messages[0]?.metadata ?? null)) {
-        // Empty copied prefix — the run's instruction opens the conversation,
+        // Empty copied prefix. The run's instruction opens the conversation,
         // so every message is the run's own output.
         return messages;
       }
+      // Referential forks copy nothing. Lineage rows keep the source
+      // conversationId, so a mixed-ownership list is a reference fork and
+      // the owned rows are the run. A stampless list where every row is
+      // owned by this conversation is the indeterminate cloning shape.
+      const owned = messages.filter((m) => m.conversationId === conversationId);
+      if (owned.length < messages.length) {
+        return owned;
+      }
       log.warn(
         { retrospectiveConversationId: conversationId },
         "memory-retrospective: fork-kind retrospective has no forkSourceMessageId stamps and no leading instruction row; treating run as having produced none",