@jskit-ai/assistant-core 0.1.212 → 0.1.214

package/test/conversationAgentRun.test.js

@@ -324,3 +324,184 @@ test("native output origin joins only its exact outer authored request and prese
     assert.equal(unowned.metadata.runtime.origin, undefined);
   }
 });
+
+
+test("native completed text uses the exact authored row without changing saved or public stream grouping", async () => {
+  for (const origin of ["user", "application"]) {
+    const f = await fixture();
+    let current = true;
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const streams = createConversationStreams();
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => current, transcript, streams });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    const authoredRequest = { messageId: "outer-request", text: "Exact authored request", origin };
+    const row = await store.writeConversationUserMessage(scope, { messageId: authoredRequest.messageId, authoredRequest, nativeIdentity });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+      providerTurnId: nativeIdentity.turnId, outerTurnId: authoredRequest.messageId } });
+    const before = await transcript.readConversationLog(scope);
+    const live = await store.updateConversationStream(scope, { nativeIdentity, turnId: "native-thread:native-turn",
+      messageId: "native-item", outputId: "native-item", role: "commentary", delta: "Partial" });
+    assert.equal(live.messages[0].origin, origin);
+    assert.equal(Object.hasOwn(live.messages[0], "turnId"), false);
+    assert.equal(JSON.stringify(live).includes("nativeIdentity"), false);
+    const completed = store.completeConversationStreamMessage(scope, "native-item", { text: "Exact completed sentence" });
+    assert.equal(completed.completedMessages[0].turnId, row.turnId);
+    assert.equal(completed.completedMessages[0].origin, origin);
+    assert.equal(completed.completedMessages[0].text, "Exact completed sentence");
+    assert.equal(completed.completedMessages[0].status, "complete");
+    assert.deepEqual(await transcript.readConversationLog(scope), before, "Completion adds no canonical commentary row");
+    assert.equal(streams.read(scope).completedMessages, undefined);
+    assert.equal(store.completeConversationStreamMessage(scope, "native-item", { text: "Repeated" }).completedMessages, undefined);
+    current = false;
+    assert.throws(() => store.completeConversationStreamMessage(scope, "native-item", { text: "Retired" }), /retired provider/);
+  }
+});
+
+test("pending native custody gains only its same authored row and never a successor's identity", async () => {
+  for (const sameRequest of [true, false]) {
+    const f = await fixture();
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => true, transcript, streams: createConversationStreams() });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    await f.storage.write(scope, async transaction => {
+      const metadata = await transaction.readMetadata(); metadata.runtime.request.origin = "user";
+      await transaction.writeMetadata(metadata);
+    });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+      providerTurnId: nativeIdentity.turnId, outerTurnId: "authored-request" } });
+    const input = { nativeIdentity, turnId: "native-thread:native-turn", messageId: "early-item", role: "commentary" };
+    await store.updateConversationStream(scope, { ...input, delta: "Early" });
+    const messageId = sameRequest ? "authored-request" : "successor";
+    const row = await store.writeConversationUserMessage(scope, { messageId,
+      authoredRequest: { messageId, text: "Admitted request", origin: "user" }, nativeIdentity });
+    await store.writeAgentRunEvent(scope, runId, { patch: { outerTurnId: messageId } });
+    await store.updateConversationStream(scope, { ...input, delta: " complete" });
+    const completed = store.completeConversationStreamMessage(scope, input.messageId, { text: "Completed early item" });
+    assert.equal(completed.completedMessages?.[0]?.turnId, sameRequest ? row.turnId : undefined);
+    assert.equal((await transcript.readConversationLog(scope)).flatMap(turn => turn.commentary || []).length, 0);
+  }
+});
+
+test("captured native predecessor commentary cannot be reassigned by same-turn steering", async () => {
+  const f = await fixture();
+  const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+  const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+    isCurrent: () => true, transcript, streams: createConversationStreams() });
+  const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+  const authored = async messageId => store.writeConversationUserMessage(scope, { messageId,
+    authoredRequest: { messageId, text: messageId, origin: "user" }, nativeIdentity });
+  const first = await authored("predecessor");
+  await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+    providerTurnId: nativeIdentity.turnId, outerTurnId: "predecessor" } });
+  const input = { nativeIdentity, turnId: "native-thread:native-turn", messageId: "old-item", role: "commentary" };
+  await store.updateConversationStream(scope, { ...input, delta: "Original intent" });
+  const successor = await authored("successor");
+  await store.writeAgentRunEvent(scope, runId, { patch: { outerTurnId: "successor" } });
+  await store.updateConversationStream(scope, { ...input, delta: " late words" });
+  assert.equal(store.completeConversationStreamMessage(scope, input.messageId, { text: "Original completed intent" })
+    .completedMessages[0].turnId, first.turnId);
+  await store.updateConversationStream(scope, { ...input, messageId: "new-item", delta: "Successor intent" });
+  assert.equal(store.completeConversationStreamMessage(scope, "new-item", { text: "Successor completed intent" })
+    .completedMessages[0].turnId, successor.turnId);
+  const unproven = await store.updateConversationStream(scope, { ...input, messageId: "foreign-item",
+    nativeIdentity: { ...nativeIdentity, threadId: "foreign-thread" }, delta: "Foreign" });
+  assert.equal(unproven.messages[0].origin, undefined);
+  assert.equal(store.completeConversationStreamMessage(scope, "foreign-item", { text: "Foreign" }).completedMessages, undefined);
+});
+
+
+test("a single pending native delta resolves only its captured same request at exact completion", async () => {
+  for (const selected of ["same", "successor", "foreign", "changed-origin"]) {
+    const f = await fixture();
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => true, transcript, streams: createConversationStreams() });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    await f.storage.write(scope, async transaction => {
+      const metadata = await transaction.readMetadata(); metadata.runtime.request.origin = "user";
+      await transaction.writeMetadata(metadata);
+    });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+      providerTurnId: nativeIdentity.turnId, outerTurnId: "authored-request" } });
+    await store.updateConversationStream(scope, { nativeIdentity, turnId: "native-thread:native-turn",
+      messageId: "single-delta", role: "commentary", delta: "Early partial words" });
+    const messageId = selected === "successor" ? "successor" : "authored-request";
+    const row = await store.writeConversationUserMessage(scope, { messageId, nativeIdentity,
+      authoredRequest: { messageId, text: "Admitted exact request", origin: selected === "changed-origin" ? "application" : "user" } });
+    await store.writeAgentRunEvent(scope, runId, { patch: { outerTurnId: messageId } });
+    const before = await transcript.readConversationLog(scope);
+    const completed = await store.completeConversationStreamMessage(scope, "single-delta", {
+      nativeIdentity: selected === "foreign" ? { ...nativeIdentity, threadId: "foreign-thread" } : nativeIdentity,
+      text: "Exact completed intent", role: "commentary" });
+    assert.equal(completed.completedMessages?.[0]?.turnId, selected === "same" ? row.turnId : undefined);
+    if (selected === "same") {
+      assert.equal(completed.completedMessages[0].text, "Exact completed intent");
+      assert.equal(completed.completedMessages[0].origin, "user");
+    }
+    assert.deepEqual(await transcript.readConversationLog(scope), before);
+    assert.equal((await store.completeConversationStreamMessage(scope, "single-delta", {
+      nativeIdentity, text: "Repeat", role: "commentary" })).completedMessages, undefined);
+  }
+});
+
+
+test("native envelope stream markers come only from exact current pending or authored metadata", async () => {
+  for (const selected of ["pending", "authored", "foreign", "ordinary"]) {
+    const f = await fixture();
+    const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+    const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+      isCurrent: () => true, transcript, streams: createConversationStreams() });
+    const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+    await f.storage.write(scope, async tx => {
+      const metadata = await tx.readMetadata();
+      metadata.runtime.request.origin = "application";
+      metadata.runtime.request.text = "Original internal prompt";
+      if (selected !== "ordinary") metadata.runtime.request.completedEnvelope = true;
+      await tx.writeMetadata(metadata);
+    });
+    if (selected === "authored") await store.writeConversationUserMessage(scope, {
+      messageId: "authored-request", nativeIdentity, authoredRequest: { messageId: "authored-request", origin: "application", text: "Original internal prompt" }
+    });
+    await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+      providerTurnId: nativeIdentity.turnId, outerTurnId: "authored-request" } });
+    const stream = await store.updateConversationStream(scope, { nativeIdentity: selected === "foreign"
+      ? { ...nativeIdentity, turnId: "foreign-turn" } : nativeIdentity,
+      turnId: "native-thread:native-turn", messageId: "native-partial", text: "Partial internal JSON",
+      completedEnvelope: true, data: { completedEnvelope: true } });
+    assert.equal(stream.messages[0].completedEnvelope, ["pending", "authored"].includes(selected) ? true : undefined);
+    assert.equal(Object.hasOwn(stream.messages[0], "turnId"), false);
+    assert.equal(JSON.stringify(stream).includes("authored-request"), false);
+    if (selected === "authored") {
+      const completed = await store.completeConversationStreamMessage(scope, "native-partial", { nativeIdentity, text: "Exact internal final" });
+      assert.equal(completed.completedMessages[0].completedEnvelope, true);
+      assert.equal(completed.completedMessages[0].text, "Exact internal final");
+    }
+  }
+});
+
+test("marked native pending stream completion cannot borrow a successor's authored receipt", async () => {
+  const f = await fixture();
+  const transcript = createConversationTranscript({ storage: f.storage, applicationTurns: true });
+  const store = createCodexConversationStore({ storage: f.storage, scope, segmentId: "segment-one",
+    isCurrent: () => true, transcript, streams: createConversationStreams() });
+  const nativeIdentity = { threadId: "native-thread", turnId: "native-turn" };
+  await f.storage.write(scope, async tx => {
+    const metadata = await tx.readMetadata();
+    metadata.runtime.request.origin = "application";
+    metadata.runtime.request.completedEnvelope = true;
+    await tx.writeMetadata(metadata);
+  });
+  await store.writeAgentRunEvent(scope, runId, { patch: { state: "active", providerThreadId: nativeIdentity.threadId,
+    providerTurnId: nativeIdentity.turnId, outerTurnId: "authored-request" } });
+  const live = await store.updateConversationStream(scope, { nativeIdentity, turnId: "native-thread:native-turn",
+    messageId: "captured-item", text: "Partial original" });
+  assert.equal(live.messages[0].completedEnvelope, true);
+  await store.writeConversationUserMessage(scope, { messageId: "successor", nativeIdentity,
+    authoredRequest: { messageId: "successor", text: "New ordinary instruction", origin: "user" } });
+  await store.writeAgentRunEvent(scope, runId, { patch: { outerTurnId: "successor" } });
+  const completed = await store.completeConversationStreamMessage(scope, "captured-item", { nativeIdentity, text: "Late old final" });
+  assert.equal(completed.completedMessages, undefined);
+  assert.equal((await transcript.readConversationLog(scope))[0].user.messageId, "successor");
+});

package/test/conversationRuntime.test.js

@@ -408,3 +408,98 @@ test("Codex never interrupts a late active turn for instructions and restores it
   assert.equal(goal.status, "active");
   assert.equal(f.requests.some(request => ["host.recordInterruption", "turn/interrupt", "thread/unsubscribe", "thread/resume", "thread/inject_items"].includes(request.method)), false);
 });
+
+
+test("Codex excludes deferred instruction composition without replenishing spent native-control time", async t => {
+  for (const mode of ["idle", "became active", "native timed out", "native refused", "binding closed", "budget exhausted before composition"]) {
+    await t.test(mode, async t => {
+      let now = 0;
+      const deadlines = [];
+      t.mock.method(performance, "now", () => now);
+      t.mock.method(AbortSignal, "timeout", duration => {
+        const controller = new AbortController();
+        deadlines.push({ duration, due: now + duration, controller });
+        return controller.signal;
+      });
+      const advance = duration => {
+        now += duration;
+        for (const deadline of deadlines) {
+          if (deadline.due <= now && !deadline.controller.signal.aborted) {
+            deadline.controller.abort(new DOMException("The operation was aborted due to timeout", "TimeoutError"));
+          }
+        }
+      };
+      let refresh = false, instructionReads = 0;
+      const f = codexHost({ readInstructions: () => {
+        instructionReads += 1;
+        if (!refresh) return "Installed project instructions";
+        advance(15_000);
+        if (mode === "became active") f.state.status = "active";
+        if (mode === "binding closed") f.runtime.close();
+        return "Fresh composed project instructions";
+      } });
+      await f.runtime.withThreadContext("native-history", {}, () => {});
+      const installed = f.runtime.threadEnvironments.get("native-history");
+      f.requests.length = 0;
+      const request = f.client.request;
+      let statusReads = 0;
+      f.client.request = async (method, input, options) => {
+        if (method === "thread/read") {
+          statusReads += 1;
+          if (statusReads === 1) {
+            if (mode === "budget exhausted before composition") now += 10_000;
+            else advance(2_500);
+          }
+          if (statusReads === 2 && mode === "native timed out") {
+            advance(7_501);
+            options.signal.throwIfAborted();
+          }
+          if (statusReads === 2 && mode === "native refused") throw new Error("Native read refused");
+        }
+        options.signal.throwIfAborted();
+        return request(method, input, options);
+      };
+      refresh = true;
+      let operations = 0;
+      const operation = f.runtime.withThreadContext("native-history", {}, params => {
+        operations += 1;
+        assert.equal(params.developerInstructions, mode === "became active"
+          ? installed.params.developerInstructions : "Fresh composed project instructions");
+      });
+      if (mode === "budget exhausted before composition") {
+        await assert.rejects(operation, { name: "TimeoutError" });
+        assert.equal(instructionReads, 1, "An exhausted native budget cannot begin deferred composition");
+        assert.equal(operations, 0);
+        assert.equal(statusReads, 1);
+      } else if (["native timed out", "native refused"].includes(mode)) {
+        await assert.rejects(operation, error => {
+          assert.match(error.message, /could not be verified/);
+          assert.equal(error.cause.name, mode === "native timed out" ? "TimeoutError" : "Error");
+          return true;
+        });
+        assert.equal(operations, 0);
+        assert.equal(f.runtime.bindingCount, 0);
+      } else if (mode === "binding closed") {
+        await assert.rejects(operation, error => {
+          assert.match(error.message, /could not be verified/);
+          assert.match(error.cause.message, /closed during recovery/);
+          return true;
+        });
+        assert.equal(operations, 0);
+        assert.equal(statusReads, 1, "Retired instructions cannot issue a later native request");
+      } else {
+        await operation;
+        assert.equal(operations, 1);
+        if (mode === "became active") {
+          assert.equal(f.runtime.threadEnvironments.get("native-history"), installed);
+          assert.equal(f.requests.some(r => ["thread/goal/get", "turn/interrupt", "thread/unsubscribe", "thread/resume", "thread/inject_items"].includes(r.method)), false);
+        } else {
+          assert.equal(f.requests.filter(r => r.method === "thread/inject_items").length, 1);
+        }
+      }
+      assert.deepEqual(deadlines.map(deadline => deadline.duration), mode === "budget exhausted before composition"
+        ? [10_000, 10_000] : [10_000, 10_000, 7_500],
+        "Only host composition is excluded; the 2.5 seconds already spent are not replenished");
+    });
+  }
+});

package/test/conversationRuntimeStateUpgrade.test.js

@@ -142,3 +142,92 @@ test("current journals distinguish an unsent reservation from a frozen attempted
         request: { ...frozen.metadata.runtime.request, ...patch } } } }), { code: "conversation_runtime_upgrade_unavailable" });
   }
 });
+
+function codexRetirementRecord() {
+  const value = record("codex", { version: 3, lastEngine: "codex",
+    continuity: "Retained discussion", continuityAttachments: [{ attachmentId: "earlier" }],
+    binding: { ...bindings.codex, accountIdentity: "retained-account", toolSchemaIdentity: "a".repeat(64),
+      run: { turnId: "retained-native-turn", status: "running" }, goal: { status: "active", objective: "Retained native goal" } },
+    predecessors: [segment("claude", { segmentId: "earlier-segment" })] });
+  value.metadata.application.effects = [{ toolCallId: "already-invoked", status: "unknown" }];
+  return { ...value, retirement: { operationId: "retire-old-manifest", successorSegmentId: "inert-successor",
+    expectedSegmentId: value.metadata.runtime.segmentId, expectedThreadId: value.metadata.runtime.binding.threadId,
+    expectedToolSchemaIdentity: value.metadata.runtime.binding.toolSchemaIdentity,
+    workdir: value.metadata.runtime.binding.workdir, configRoot: value.metadata.runtime.binding.configRoot } };
+}
+
+test("explicit Codex retirement only transforms metadata and preserves the exact predecessor and history", () => {
+  const value = codexRetirementRecord();
+  const before = structuredClone(value);
+  const { retirement, ...withoutRetirement } = value;
+  const unchanged = upgradeConversationRuntimeState(withoutRetirement);
+  assert.equal(unchanged.changed, false, "Known metadata alone must not activate retirement");
+  assert.equal(unchanged.metadata, value.metadata);
+  assert.deepEqual(unchanged.warnings, []);
+
+  const result = upgradeConversationRuntimeState(value);
+  const old = before.metadata.runtime;
+  const current = result.metadata.runtime;
+  assert.equal(result.changed, true);
+  assert.deepEqual(result.warnings, []);
+  assert.deepEqual(result.metadata.application, before.metadata.application);
+  assert.deepEqual(current.predecessors[0], old.predecessors[0]);
+  assert.deepEqual(current.predecessors[1], { segmentId: old.segmentId, engine: old.engine,
+    configuration: old.configuration, binding: old.binding, seen: old.seen,
+    continuity: old.continuity, continuityAttachments: old.continuityAttachments, request: undefined,
+    successorId: retirement.successorSegmentId, replacement: { operationId: retirement.operationId,
+      expectedSegmentId: old.segmentId, engine: "codex", configuration: old.configuration,
+      retireNative: true, operation: "select" } });
+  assert.deepEqual(current.binding, { threadId: "", workdir: old.binding.workdir,
+    configRoot: old.binding.configRoot, executionId: "" });
+  assert.equal(current.segmentId, retirement.successorSegmentId);
+  assert.equal(current.engine, "codex");
+  assert.equal(current.version, 3);
+  assert.deepEqual(current.configuration, old.configuration);
+  assert.deepEqual(current.seen, {});
+  assert.equal(current.lastEngine, "");
+  assert.equal(current.continuity, undefined);
+  assert.deepEqual(current.continuityAttachments, []);
+  assert.equal(Object.hasOwn(current, "request"), false);
+  assert.equal(Object.hasOwn(current, "replacement"), false);
+  assert.equal(Object.hasOwn(current.predecessors[1], "preparedAt"), false);
+  assert.deepEqual(value, before, "Native activity and effect facts are retained, not certified or mutated");
+  assert.deepEqual(upgradeConversationRuntimeState(structuredClone(before)), result,
+    "Verified before metadata and stable IDs yield the same pure result");
+  const repeated = { ...before, metadata: result.metadata };
+  const repeatedBefore = structuredClone(repeated);
+  assert.throws(() => upgradeConversationRuntimeState(repeated), { code: "conversation_runtime_upgrade_unavailable" });
+  assert.deepEqual(repeated, repeatedBefore, "A converted tuple is not silently retired a second time");
+});
+
+test("explicit Codex retirement refuses malformed IDs, changed identity and unresolved metadata without mutation", () => {
+  const cases = [
+    ["numeric operation ID", value => { value.retirement.operationId = 1; }],
+    ["numeric successor ID", value => { value.retirement.successorSegmentId = 1; }],
+    ["unknown input field", value => { value.retirement.idle = true; }],
+    ["changed segment", value => { value.retirement.expectedSegmentId = "other-segment"; }],
+    ["changed native thread", value => { value.retirement.expectedThreadId = "other-thread"; }],
+    ["changed tool schema", value => { value.retirement.expectedToolSchemaIdentity = "b".repeat(64); }],
+    ["changed workdir", value => { value.retirement.workdir = "/other-workspace"; }],
+    ["changed config root", value => { value.retirement.configRoot = "/other-account"; }],
+    ["relative path", value => { value.retirement.workdir = "workspace"; }],
+    ["current successor", value => { value.retirement.successorSegmentId = value.metadata.runtime.segmentId; }],
+    ["retained successor", value => { value.retirement.successorSegmentId = "earlier-segment"; }],
+    ["reserved successor", value => { value.metadata.runtime.predecessors[0].successorId = value.retirement.successorSegmentId; }],
+    ["used operation", value => { value.metadata.runtime.predecessors[0].replacement = { operationId: value.retirement.operationId }; }],
+    ["missing runtime", value => { delete value.metadata.runtime; }],
+    ["old runtime version", value => { value.metadata.runtime.version = 2; }],
+    ["other engine", value => { value.metadata.runtime.engine = "claude"; value.metadata.runtime.binding = bindings.claude; }],
+    ["pending delivery", value => { value.metadata.runtime.request = { ...request, attempted: false }; }],
+    ["pending replacement", value => { value.metadata.runtime.replacement = { ...segment("codex"), segmentId: "pending",
+      request: { operationId: "pending-selection", expectedSegmentId: value.metadata.runtime.segmentId, operation: "select" } }; }],
+    ["unfinished Undo", value => { value.metadata.runtime.replacement = { ...segment("codex"), reason: "rewind" }; }]
+  ];
+  for (const [reason, mutate] of cases) {
+    const value = codexRetirementRecord();
+    mutate(value);
+    const before = structuredClone(value);
+    assert.throws(() => upgradeConversationRuntimeState(value), { code: "conversation_runtime_upgrade_unavailable" }, reason);
+    assert.deepEqual(value, before, reason);
+  }
+});

package/test/conversationStreaming.test.js

@@ -153,3 +153,88 @@ test("output identity survives stream revisions and saved projection without cha
   assert.equal(final[0].assistant.messageId, "native-saved");
   assert.equal(final[0].assistant.outputId, snapshot.messages[0].outputId);
 });
+
+
+test("native completed carriers retain exact final text once without exposing private custody in live reads", () => {
+  const streams = createConversationStreams();
+  const input = { nativeIdentity: { threadId: "thread", turnId: "native-turn" }, turnId: "thread:native-turn",
+    messageId: "native-item", outputId: "exact-output", role: "commentary", origin: "user",
+    authorship: { messageId: "authored-message", turnId: "000001", origin: "user" } };
+  streams.update("chat", { ...input, delta: "Partial words" });
+  const live = streams.read("chat");
+  assert.equal(Object.hasOwn(live.messages[0], "turnId"), false);
+  assert.equal(JSON.stringify(live).includes("authored-message"), false);
+  assert.equal(JSON.stringify(live).includes("nativeIdentity"), false);
+  const final = "Corrected completed sentence.\nExact ending.";
+  const completed = streams.complete("chat", input.messageId, { text: final });
+  assert.deepEqual(completed.messages, []);
+  assert.deepEqual(completed.completedMessages.map(message => ({ turnId: message.turnId, outputId: message.outputId,
+    messageId: message.messageId, origin: message.origin, role: message.role, text: message.text, status: message.status })),
+  [{ turnId: "000001", outputId: "exact-output", messageId: "native-item", origin: "user", role: "commentary",
+    text: final, status: "complete" }]);
+  completed.completedMessages[0].text = "Changed return value";
+  assert.equal(streams.read("chat").completedMessages, undefined);
+  assert.equal(streams.complete("chat", input.messageId, { text: final }).completedMessages, undefined);
+  assert.equal(streams.update("chat", { ...input, delta: "late" }), null);
+  assert.deepEqual(streams.read("chat").messages, []);
+  assert.deepEqual(input.authorship, { messageId: "authored-message", turnId: "000001", origin: "user" });
+  streams.update("chat", { ...input, messageId: "phase-less-item", role: "assistant", text: "Initially unclassified" });
+  assert.equal(streams.complete("chat", "phase-less-item", { text: "Completed progress", role: "commentary" })
+    .completedMessages[0].role, "commentary", "The completed native classification owns the role, not an initial phase-less delta");
+});
+
+test("unproven native origin and duplicate cleanup cannot produce completed authored carriers", () => {
+  const streams = createConversationStreams();
+  const input = { nativeIdentity: { threadId: "thread", turnId: "turn" }, turnId: "thread:turn",
+    messageId: "unproven", role: "commentary", origin: "application" };
+  streams.update("chat", { ...input, text: "Unproven sentence" });
+  assert.equal(streams.complete("chat", input.messageId, { text: "Unproven sentence" }).completedMessages, undefined);
+  streams.update("chat", { ...input, messageId: "duplicate", text: "Same sentence",
+    authorship: { turnId: "000001", messageId: "request", origin: "application" } });
+  assert.equal(streams.complete("chat", "duplicate").completedMessages, undefined,
+    "Fingerprint cleanup is not a completed-text publication");
+  assert.equal(streams.complete("chat", "duplicate", { text: "Same sentence" }).completedMessages, undefined);
+  assert.equal(streams.complete("other", "missing", { text: "No item" }).completedMessages, undefined);
+  streams.update("chat", { ...input, messageId: "initially-unproven", text: "Earlier unowned output" });
+  streams.update("chat", { ...input, messageId: "initially-unproven", text: "Later words",
+    authorship: { turnId: "000002", messageId: "successor-request", origin: "application" } });
+  assert.equal(streams.complete("chat", "initially-unproven", { text: "Late completed output" }).completedMessages, undefined,
+    "A later current request cannot adopt an item that had no captured authored custody");
+});
+
+
+test("completed-envelope stream scalar changes participate in dedup and require captured application authorship", () => {
+  const streams = createConversationStreams();
+  const input = { turnId: "native:turn", nativeIdentity: { threadId: "native", turnId: "turn" },
+    messageId: "item", origin: "application", text: "Exact partial",
+    authorship: { messageId: "request", origin: "application" } };
+  const first = streams.update("chat", input);
+  assert.equal(first.messages[0].completedEnvelope, undefined);
+  const marked = streams.update("chat", { ...input, authorship: { ...input.authorship, completedEnvelope: true } });
+  assert.equal(marked.messages[0].completedEnvelope, true);
+  assert.ok(marked.revision > first.revision, "Equal text does not hide an actual trusted scalar change");
+  assert.equal(streams.update("chat", { ...input, authorship: { ...input.authorship, completedEnvelope: true } }), null);
+  streams.update("chat", { ...input, messageId: "unowned", authorship: undefined,
+    completedEnvelope: true, data: { completedEnvelope: true } });
+  assert.equal(streams.read("chat").messages.find(message => message.messageId === "unowned").completedEnvelope, undefined);
+  streams.update("chat", { ...input, messageId: "ordinary", origin: "user",
+    authorship: { messageId: "user-request", turnId: "000002", origin: "user", completedEnvelope: true } });
+  assert.equal(streams.read("chat").messages.find(message => message.messageId === "ordinary").completedEnvelope, undefined);
+});
+
+test("completed-envelope completion keeps its captured scalar while resolving only the same authored pending receipt", () => {
+  const streams = createConversationStreams();
+  const input = { turnId: "native:turn", nativeIdentity: { threadId: "native", turnId: "turn" }, messageId: "item",
+    origin: "application", text: "Partial", authorship: { messageId: "request", origin: "application", completedEnvelope: true } };
+  streams.update("chat", input);
+  const completed = streams.complete("chat", "item", { text: "Exact final", role: "assistant",
+    authorship: { messageId: "request", turnId: "000001", origin: "application" } });
+  assert.equal(completed.completedMessages[0].completedEnvelope, true);
+  assert.equal(completed.completedMessages[0].turnId, "000001");
+  assert.equal(completed.completedMessages[0].text, "Exact final");
+  assert.equal(streams.complete("chat", "item", { text: "Repeat" }).completedMessages, undefined);
+  streams.update("chat", { ...input, messageId: "old-pending" });
+  assert.equal(streams.complete("chat", "old-pending", { text: "Wrong association", authorship: {
+    messageId: "successor", turnId: "000002", origin: "application", completedEnvelope: true
+  } }).completedMessages, undefined);
+});