@jskit-ai/assistant-core 0.1.205 → 0.1.207

package/test/conversationConfiguration.test.js

@@ -172,3 +172,30 @@ test("file-backed pending replacement keeps its admitted configuration across a
   assert.deepEqual((await resumed.read()).configuration, { systemPrompt: "Replacement instructions.", integrationId: "assistant" });
   assert.equal((await resumed.replace(input)).duplicate, true);
 });
+
+
+test("file-backed OpenCode selections keep compatible bindings and reserve a fresh provider binding without inference", async t => {
+  const f = await fixture(t, { file: true });
+  const first = f.runtime();
+  const conversation = await first.open({ id: "open-code", engine: "opencode",
+    configuration: { systemPrompt: "Keep the discussion.", integrationId: "included" } });
+  const initial = await conversation.read();
+  const old = await f.storage.read("open-code", tx => tx.readMetadata());
+  await conversation.select({ operationId: "effort-only", expectedSegmentId: initial.segmentId,
+    engine: "opencode", configuration: { ...initial.configuration, effort: "low" } });
+  assert.deepEqual((await f.storage.read("open-code", tx => tx.readMetadata())).runtime.binding, old.runtime.binding);
+  const selection = { operationId: "connect-flash", expectedSegmentId: initial.segmentId,
+    engine: "opencode", configuration: { ...initial.configuration, integrationId: "flash", effort: "low" } };
+  const selected = await conversation.select(selection);
+  assert.notEqual(selected.segmentId, initial.segmentId);
+  const saved = await f.storage.read("open-code", tx => tx.readMetadata());
+  assert.notEqual(saved.runtime.binding.directory, old.runtime.binding.directory);
+  assert.equal(saved.runtime.binding.sessionId, "");
+  assert.deepEqual(saved.runtime.predecessors.at(-1).binding, old.runtime.binding);
+  await first.close();
+  const reopened = await f.runtime().open({ id: "open-code" });
+  assert.equal((await reopened.select(selection)).duplicate, true);
+  assert.deepEqual(await f.storage.read("open-code", tx => tx.readMetadata()), saved);
+  await assert.rejects(reopened.select({ ...selection, configuration: { ...selection.configuration, integrationId: "different" } }),
+    { code: "conversation_replacement_conflict" });
+});

package/test/conversationReplacement.test.js

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
 import { createAiConnectionResolver } from "../../connectors-catalog/src/server/ai.js";
 
@@ -27,7 +30,7 @@ async function fixture(t, options = {}) {
   }) };
   function runtime() {
     const value = createConversationRuntime({ storage: failingStorage, connections,
-      authorize: () => state.allowed, limits: options.limits,
+      authorize: () => state.allowed, limits: options.limits, host: options.host,
       fetch: async (_url, init) => {
         const body = JSON.parse(init.body); requests.push(body);
         if (options.fetch) return options.fetch(body, init);
@@ -170,3 +173,75 @@ test("host scope belongs to a conversation and cannot be changed through another
   assert.equal((await one.wait()).conversationLog.length, 1);
   assert.equal((await two.wait()).conversationLog.length, 1);
 });
+
+
+test("interrupted OpenCode integration selection retries the original fresh binding transaction without inference", async t => {
+  const directory = await mkdtemp(join(tmpdir(), "opencode-selection-replacement-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const f = await fixture(t, { host: { workdir: directory, execution: {
+    start() { assert.fail("Selection must not start a native process or submit a prompt."); },
+    stop() { assert.fail("An inert binding has no process to stop."); }
+  } } });
+  const initial = await f.conversation.read();
+  await f.conversation.select({ operationId: "enter-open-code", expectedSegmentId: initial.segmentId,
+    engine: "opencode", configuration });
+  const original = await f.conversation.read();
+  const operation = { operationId: "switch-integration", expectedSegmentId: original.segmentId,
+    engine: "opencode", configuration: { ...configuration, integrationId: "flash" } };
+  const metadata = await f.storage.read("one", tx => tx.readMetadata());
+  f.state.failCommit = true;
+  await assert.rejects(f.conversation.select(operation), /Storage offline during replacement commit/);
+  const pending = await f.storage.read("one", tx => tx.readMetadata());
+  assert.deepEqual(pending.runtime.replacement.request, { ...operation, operation: "select" });
+  assert.notEqual(pending.runtime.replacement.binding.directory, metadata.runtime.binding.directory);
+  assert.equal((await f.conversation.read()).status, "replacement-pending");
+  await assert.rejects(f.conversation.send({ messageId: "premature", text: "Too early" }),
+    { code: "conversation_replacement_pending" });
+  await f.first.close();
+  f.state.failCommit = false;
+  const reopened = await f.runtime().open({ id: "one" });
+  const result = await reopened.select(operation);
+  assert.equal(result.segmentId, pending.runtime.replacement.segmentId);
+  const saved = await f.storage.read("one", tx => tx.readMetadata());
+  assert.deepEqual(saved.runtime.binding, pending.runtime.replacement.binding);
+  assert.deepEqual(saved.runtime.predecessors.at(-1).binding, metadata.runtime.binding);
+  assert.equal(saved.runtime.replacement, undefined);
+  assert.equal((await reopened.select(operation)).duplicate, true);
+  assert.deepEqual(await f.storage.read("one", tx => tx.readMetadata()), saved);
+  assert.equal(f.requests.length, 0);
+});
+
+test("interrupted fresh native selection retains its consumer policy and successor on restart", async t => {
+  const directory = await mkdtemp(join(tmpdir(), "opencode-fresh-selection-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const f = await fixture(t, { host: { workdir: directory, execution: {
+    start() { assert.fail("Selection cannot start native work."); },
+    stop() { assert.fail("An inert binding has no process to stop."); }
+  } } });
+  await f.conversation.select({ operationId: "enter-open-code", expectedSegmentId: (await f.conversation.read()).segmentId,
+    engine: "opencode", configuration });
+  const original = await f.storage.read("one", tx => tx.readMetadata());
+  const operation = { operationId: "fresh-model", expectedSegmentId: original.runtime.segmentId,
+    engine: "opencode", configuration: { ...configuration, effort: "high" }, retireNative: true };
+  f.state.failCommit = true;
+  await assert.rejects(f.conversation.select(operation), /Storage offline during replacement commit/);
+  const pending = await f.storage.read("one", tx => tx.readMetadata());
+  assert.deepEqual(pending.runtime.replacement.request, { ...operation, operation: "select" });
+  assert.notEqual(pending.runtime.replacement.binding.directory, original.runtime.binding.directory);
+  assert.equal((await f.conversation.read()).status, "replacement-pending");
+  await assert.rejects(f.conversation.send({ messageId: "too-early", text: "Wait for the change" }),
+    { code: "conversation_replacement_pending" });
+  await f.first.close();
+  f.state.failCommit = false;
+  const reopened = await f.runtime().open({ id: "one" });
+  const result = await reopened.select(operation);
+  const saved = await f.storage.read("one", tx => tx.readMetadata());
+  assert.equal(result.segmentId, pending.runtime.replacement.segmentId);
+  assert.deepEqual(saved.runtime.binding, pending.runtime.replacement.binding);
+  assert.deepEqual(saved.runtime.predecessors.at(-1).binding, original.runtime.binding);
+  assert.deepEqual(saved.runtime.predecessors.at(-1).replacement, { ...operation, operation: "select" });
+  assert.equal(saved.runtime.replacement, undefined);
+  assert.equal((await reopened.select(operation)).duplicate, true);
+  assert.deepEqual(await f.storage.read("one", tx => tx.readMetadata()), saved);
+  assert.equal(f.requests.length, 0);
+});

package/test/conversationRuntime.test.js

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { createConversationHookBridge } from "../src/server/conversation/index.js";
 import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 import { createCodexConversationAdapter } from "../src/server/conversation/providers/codex.js";
@@ -74,13 +77,16 @@ test("Claude does not acknowledge failed native settings or launch past failed c
   assert.equal(f.launches.length, 2);
 });
 
-function codexHost() {
-  const state = { status: "idle", process: "process-1", prompt: "Calendar instructions", provider: "openai", fail: false };
+function codexHost({ readInstructions } = {}) {
+  const state = { status: "idle", process: "process-1", prompt: "Calendar instructions", provider: "openai", fail: false,
+    environment: { TOOL_ENDPOINT: "current" } };
   const requests = [];
   const client = { async request(method, input) {
     requests.push({ method, input });
     if (method === "thread/read") return { thread: { historyMode: "paginated", status: state.status, modelProvider: state.provider } };
     if (method === "thread/goal/get") return { goal: null };
+    if (method === "thread/turns/list") return { data: [{ id: "active-turn" }] };
+    if (method === "turn/interrupt") { state.status = "idle"; return {}; }
     if (method === "thread/inject_items") return {};
     if (method === "thread/loaded/list") return { data: state.status === "notLoaded" ? [] : ["native-history"] };
     if (method === "thread/unsubscribe") { state.status = "notLoaded"; return { status: "unsubscribed" }; }
@@ -93,11 +99,12 @@ function codexHost() {
   } };
   const runtime = createCodexConversationAdapter({ client: async () => client,
     runtime: () => ({ executionId: state.process }), runRequest: (run) => run(),
-    readInstructions: () => state.prompt,
-    prepareEnvironment: async () => ({ TOOL_ENDPOINT: "current" }),
+    readInstructions: readInstructions || (() => state.prompt),
+    prepareEnvironment: async () => ({ ...state.environment }),
     prepareHistory: async (params) => params,
     threadParameters: (params) => params,
     verifyEnvironment: async () => {},
+    recordInterruption: (threadId, turnId) => requests.push({ method: "host.recordInterruption", input: { threadId, turnId } }),
     prepareResume: async (id, params) => { requests.push({ method: "host.prepareResume", input: { id } }); return params; }
   });
   return { runtime, state, requests, client };
@@ -239,3 +246,165 @@ test("OpenCode retries invalid content and rejects an invalidated in-flight read
   release("Obsolete instructions");
   await assert.rejects(inFlight, /context changed while reading/);
 });
+
+test("Codex keeps active installed instructions through source changes, deletion and restoration", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "codex-instructions-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const file = path.join(root, "instructions.md");
+  const original = "Original project and application instructions";
+  await writeFile(file, original);
+  let reads = 0;
+  const f = codexHost({ readInstructions: () => { reads += 1; return readFile(file, "utf8"); } });
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  const installed = f.runtime.threadEnvironments.get("native-history");
+  const revision = installed.params.config.shell_environment_policy.set.JSKIT_CONVERSATION_INSTRUCTIONS;
+  const initialReads = reads;
+  f.requests.length = 0;
+  f.state.status = "active";
+  let operations = 0;
+  for (const content of ["A temporarily changed reference", null, original]) {
+    if (content === null) await rm(file);
+    else await writeFile(file, content);
+    await f.runtime.withThreadContext("native-history", {}, params => {
+      operations += 1;
+      assert.equal(params.developerInstructions, original);
+      assert.equal(params.config.shell_environment_policy.set.JSKIT_CONVERSATION_INSTRUCTIONS, revision);
+    });
+  }
+  assert.equal(operations, 3);
+  assert.equal(reads, initialReads, "A healthy active observation must not reread an unavailable prompt source");
+  assert.equal(f.runtime.threadEnvironments.get("native-history"), installed);
+  assert.equal(f.requests.some(request => ["turn/interrupt", "thread/unsubscribe", "thread/resume", "thread/inject_items"].includes(request.method)), false);
+  assert.equal(f.requests.filter(request => request.method === "thread/read").length, 3, "Native status and current controls are still checked");
+  await writeFile(file, "Latest restored application instructions");
+  f.state.status = "idle";
+  await f.runtime.withThreadContext("native-history", {}, params => {
+    assert.equal(params.developerInstructions, "Latest restored application instructions");
+  });
+  assert.equal(reads, initialReads + 1, "The safe admission rereads the source rather than using a queued stale value");
+  assert.equal(f.requests.find(request => request.method === "thread/resume").input.threadId, "native-history");
+  assert.equal(f.requests.filter(request => request.method === "thread/inject_items").length, 1);
+  assert.match(f.requests.find(request => request.method === "thread/inject_items").input.items[0].content[0].text, /Latest restored application instructions/);
+  assert.equal(f.runtime.threadEnvironments.get("native-history").client, f.client);
+});
+
+test("Codex defers explicit instruction changes while active but installs them at idle admission", async () => {
+  const f = codexHost();
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  f.requests.length = 0;
+  f.state.status = "active";
+  const changed = { systemPrompt: "Explicit new application instructions" };
+  await f.runtime.withThreadContext("native-history", changed, params => {
+    assert.equal(params.developerInstructions, "Calendar instructions");
+  });
+  assert.equal(f.requests.some(request => request.method === "turn/interrupt" || request.method === "thread/resume"), false);
+  f.state.status = "idle";
+  await f.runtime.withThreadContext("native-history", changed, params => {
+    assert.equal(params.developerInstructions, changed.systemPrompt);
+  });
+  assert.equal(f.requests.filter(request => request.method === "thread/inject_items").length, 1);
+});
+
+test("Codex still recovers real active control changes with current instructions and an exact interruption cause", async () => {
+  const f = codexHost();
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  f.requests.length = 0;
+  f.state.status = "active";
+  f.state.prompt = "Current instructions after a real control change";
+  f.state.environment.TOOL_ENDPOINT = "replacement";
+  await f.runtime.withThreadContext("native-history", {}, params => {
+    assert.equal(params.developerInstructions, f.state.prompt);
+    assert.equal(params.config.shell_environment_policy.set.TOOL_ENDPOINT, "replacement");
+  });
+  const interrupt = f.requests.findIndex(request => request.method === "turn/interrupt");
+  assert.deepEqual(f.requests[interrupt - 1], { method: "host.recordInterruption", input: { threadId: "native-history", turnId: "active-turn" } });
+  assert.deepEqual(f.requests[interrupt].input, { threadId: "native-history", turnId: "active-turn" });
+  assert.equal(f.requests.filter(request => request.method === "thread/resume").length, 1);
+  assert.equal(f.requests.filter(request => request.method === "thread/inject_items").length, 1);
+});
+
+test("Codex does not reinstall a closed binding after an idle instruction read settles", async () => {
+  const reading = Promise.withResolvers();
+  const instructions = Promise.withResolvers();
+  let pending = false;
+  const f = codexHost({ readInstructions: () => {
+    if (!pending) return "Initial instructions";
+    reading.resolve();
+    return instructions.promise;
+  } });
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  pending = true;
+  let operations = 0;
+  const refresh = f.runtime.withThreadContext("native-history", {}, () => { operations += 1; });
+  await reading.promise;
+  f.requests.length = 0;
+  f.runtime.close();
+  instructions.resolve("Late instructions after close");
+  await assert.rejects(refresh, /could not be verified/);
+  assert.equal(operations, 0);
+  assert.equal(f.runtime.bindingCount, 0);
+  assert.deepEqual(f.requests, [], "A retired instruction refresh cannot issue native recovery commands");
+});
+
+test("Codex defers an instruction-only refresh when native work starts during the prompt read", async () => {
+  const reading = Promise.withResolvers();
+  const instructions = Promise.withResolvers();
+  let pending = false;
+  const f = codexHost({ readInstructions: () => {
+    if (!pending) return "Installed instructions";
+    reading.resolve();
+    return instructions.promise;
+  } });
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  const installed = f.runtime.threadEnvironments.get("native-history");
+  f.requests.length = 0;
+  pending = true;
+  let operations = 0;
+  const refresh = f.runtime.withThreadContext("native-history", {}, params => {
+    operations += 1;
+    assert.equal(params.developerInstructions, installed.params.developerInstructions);
+    assert.deepEqual(params.config.shell_environment_policy, installed.params.config.shell_environment_policy);
+  });
+  await reading.promise;
+  f.state.status = "active";
+  instructions.resolve("Instructions composed after native work began");
+  await refresh;
+  assert.equal(operations, 1);
+  assert.equal(f.runtime.threadEnvironments.get("native-history"), installed);
+  assert.equal(f.requests.filter(request => request.method === "thread/read").length, 2);
+  assert.equal(f.requests.some(request => ["thread/goal/get", "turn/interrupt", "thread/unsubscribe", "thread/resume", "thread/inject_items"].includes(request.method)), false);
+});
+
+test("Codex never interrupts a late active turn for instructions and restores its paused goal", async () => {
+  const f = codexHost();
+  await f.runtime.withThreadContext("native-history", {}, () => {});
+  const installed = f.runtime.threadEnvironments.get("native-history");
+  f.requests.length = 0;
+  f.state.prompt = "New instructions for a later admission";
+  let goal = { status: "active", createdAt: 1, updatedAt: 1, objective: "Continue the same task" };
+  const originalRequest = f.client.request;
+  f.client.request = async (method, input) => {
+    if (method === "thread/goal/get") {
+      f.requests.push({ method, input });
+      return { goal: { ...goal } };
+    }
+    if (method === "thread/goal/set") {
+      f.requests.push({ method, input });
+      goal = { ...goal, status: input.status, updatedAt: goal.updatedAt + 1 };
+      if (input.status === "paused") f.state.status = "active";
+      return { goal: { ...goal } };
+    }
+    return originalRequest(method, input);
+  };
+  let operations = 0;
+  await f.runtime.withThreadContext("native-history", {}, params => {
+    operations += 1;
+    assert.equal(params.developerInstructions, installed.params.developerInstructions);
+    assert.deepEqual(params.config.shell_environment_policy, installed.params.config.shell_environment_policy);
+  });
+  assert.equal(operations, 1);
+  assert.equal(f.runtime.threadEnvironments.get("native-history"), installed);
+  assert.deepEqual(f.requests.filter(request => request.method === "thread/goal/set").map(request => request.input.status), ["paused", "active"]);
+  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);
+});

package/test/conversationSession.test.js

@@ -304,6 +304,145 @@ test("native creation authorizes its parent scope and uses only the configured o
   assert.equal(saves.length, 2);
 });
 
+test("native detached execution separates admitted context from host-approved original options", async t => {
+  const id = "detached-parent";
+  const input = { prompt: "Original detached request" };
+  const nativeOptions = { runtime: { stateRoot: "/authorized/state" }, session: { sessionId: id }, onEvent: undefined };
+  const submittedOptions = { privateProjection: true };
+  const result = { ok: true, text: "Completed", threadId: "native-thread", turnId: "native-turn" };
+  const calls = [];
+  let permitted = false, wrongIdentity = false, preparing = null, entered = null;
+  const runtime = createConversationRuntime({
+    authorize(request) {
+      calls.push("authorize");
+      assert.deepEqual(request, { context, conversationId: id, operation: "runDetachedConversation" });
+      return permitted;
+    },
+    storage: { read() { assert.fail("Detached execution does not hydrate Main."); },
+      write() { assert.fail("Detached execution does not write canonical conversation history."); } },
+    host: { async conversation(request) {
+      calls.push("host");
+      assert.deepEqual(request, { id, context, input, options: submittedOptions, operation: "runDetachedConversation" });
+      entered?.resolve();
+      await preparing?.promise;
+      return { sessionId: wrongIdentity ? "other-parent" : id, engine: "codex", context, input, options: nativeOptions,
+        native: { runOwner: { runDetachedConversation(parent, authored, options) {
+          calls.push("native");
+          assert.equal(parent, id);
+          assert.equal(authored, input);
+          assert.equal(options, nativeOptions);
+          assert.equal(Object.hasOwn(options, "onEvent"), true);
+          assert.equal(Object.hasOwn(options, "signal"), false);
+          return result;
+        } } } };
+    } }
+  });
+  t.after(() => runtime.close());
+  const request = { id, context, input, options: submittedOptions,
+    get native() { return assert.fail("The caller cannot inject a native owner."); },
+    get engine() { return assert.fail("The caller cannot select another engine."); },
+    get host() { return assert.fail("The caller cannot override the configured host."); }
+  };
+  await assert.rejects(runtime.runNativeDetachedConversation(request), { code: "conversation_forbidden" });
+  assert.deepEqual(calls, ["authorize"]);
+  permitted = true;
+  wrongIdentity = true;
+  await assert.rejects(runtime.runNativeDetachedConversation(request), /authorized host preparation/);
+  assert.deepEqual(calls, ["authorize", "authorize", "host"]);
+  wrongIdentity = false;
+  assert.equal(await runtime.runNativeDetachedConversation(request), result);
+  assert.deepEqual(calls.slice(3), ["authorize", "host", "native"]);
+  preparing = Promise.withResolvers();
+  entered = Promise.withResolvers();
+  const pending = runtime.runNativeDetachedConversation(request);
+  await entered.promise;
+  await runtime.close();
+  preparing.resolve();
+  await assert.rejects(pending, { code: "conversation_closed" });
+  assert.deepEqual(calls.slice(6), ["authorize", "host"]);
+  await assert.rejects(runtime.runNativeDetachedConversation(request), { code: "conversation_closed" });
+  assert.equal(calls.length, 8);
+});
+
+test("Claude detached joining preserves acquire-before-audit and awaited event-before-start", async t => {
+  for (const rejected of [false, true]) await t.test(rejected ? "event rejection" : "completed turn", async t => {
+    const calls = [];
+    const eventEntered = Promise.withResolvers();
+    const eventRelease = Promise.withResolvers();
+    const executionProfile = { model: "selected-helper", limits: { timeoutMs: 500 } };
+    const signal = new AbortController().signal;
+    const nativeContext = { ...context, assistantScope: { id: "helper-parent" }, signal,
+      async onEvent(event) {
+        calls.push("profile-event");
+        assert.deepEqual(event, { type: "execution-profile", executionProfile });
+        eventEntered.resolve();
+        await eventRelease.promise;
+      }
+    };
+    const input = { prompt: "Original prompt", executionProfile };
+    const entry = { id: "", profile: null };
+    const result = { ok: true, text: "Original answer", threadId: "native-id", turnId: "native-turn" };
+    const owner = {
+      async acquire(actor, id, options) {
+        assert.equal(actor, nativeContext);
+        if (!entry.id) {
+          assert.match(id, /^[a-f0-9-]{36}$/u);
+          assert.deepEqual(options, { create: true });
+          entry.id = id;
+          calls.push("acquire");
+        } else {
+          assert.equal(id, entry.id);
+          calls.push(options ? "start-check" : "wait-acquire");
+          if (options) assert.deepEqual(options, { operation: "start", input: { ...input, conversationId: entry.id } });
+        }
+        return entry;
+      },
+      async startTurn(current, request) {
+        assert.equal(current, entry);
+        assert.deepEqual(request, { ...input, conversationId: entry.id });
+        assert.equal(entry.profile, executionProfile);
+        calls.push("start");
+      },
+      async wait(current, request, options) {
+        assert.equal(current, entry);
+        assert.deepEqual(request, { ...input, conversationId: entry.id });
+        assert.equal(options.context, nativeContext);
+        assert.equal(options.context.signal, signal);
+        assert.equal(options.acquire, owner.acquire);
+        calls.push("wait");
+        return result;
+      }
+    };
+    const runtime = createConversationRuntime({ authorize: () => true, host: { conversation() {
+      return { sessionId: "helper-parent", engine: "claude", context: nativeContext, input, options: {}, native: {
+        owner,
+        get executionProfile() {
+          assert.deepEqual(calls, ["acquire"]);
+          calls.push("audit");
+          return executionProfile;
+        }
+      } };
+    } } });
+    t.after(() => runtime.close());
+    const pending = runtime.runNativeDetachedConversation({ id: "helper-parent", context, input });
+    void pending.catch(() => {});
+    await eventEntered.promise;
+    assert.deepEqual(calls, ["acquire", "audit", "profile-event"]);
+    assert.equal(entry.profile, executionProfile);
+    if (rejected) {
+      const failure = new Error("Original observer rejected");
+      eventRelease.reject(failure);
+      await assert.rejects(pending, error => error === failure);
+      assert.deepEqual(calls, ["acquire", "audit", "profile-event"]);
+      assert.ok(entry.id, "The original acquired entry is not silently deleted when its event rejects.");
+    } else {
+      eventRelease.resolve();
+      assert.deepEqual(await pending, { ...result, executionProfile });
+      assert.deepEqual(calls, ["acquire", "audit", "profile-event", "start-check", "start", "wait-acquire", "wait"]);
+    }
+  });
+});
+
 test("native readiness authorizes its configured owner and rejects closure during host preparation", async t => {
   const nativeContext = { ...context, key: "readiness-scope", workdir: "/unused-native-workdir" };
   let allowed = false, hostCalls = 0, acquisitions = 0, accounts = 0, saves = 0;

package/test/conversationTools.test.js

@@ -181,9 +181,23 @@ test("the runtime applies application tool policy to schemas and an unsolicited
   const result = await f.conversation.wait();
   assert.equal((f.observed.requests[0].tools || []).length, 0);
   assert.equal(f.observed.executions.length, 0);
-  assert.equal(f.observed.requests.length, 1);
-  assert.equal(result.conversationLog[0].metadata.runtime.status, "failed");
-  assert.match(result.error, /unavailable tool|No such tool/i);
+  assert.equal(f.observed.requests.length, 2);
+  assert.equal((f.observed.requests[1].tools || []).length, 0);
+  assert.equal(result.conversationLog[0].metadata.runtime.status, "complete");
+  assert.equal(result.error, "");
+  assert.equal(result.conversationLog[0].assistant.text, "The total is five.");
+  const refusal = { ok: false, error: { code: "assistant_tool_unknown", message: "Unknown tool." } };
+  const recorded = result.conversationLog[0].metadata.applicationTools[0];
+  assert.equal(result.conversationLog[0].metadata.applicationTools.length, 1);
+  assert.equal(recorded.id, call.id);
+  assert.equal(recorded.name, f.name);
+  assert.equal(recorded.arguments, call.arguments);
+  assert.equal(recorded.status, "complete");
+  assert.deepEqual(recorded.result, refusal);
+  const feedback = f.observed.requests[1].messages.filter(message => message.role === "tool");
+  assert.equal(feedback.length, 1);
+  assert.equal(feedback[0].tool_call_id, call.id);
+  assert.deepEqual(JSON.parse(feedback[0].content), { error: refusal.error });
 });
 
 test("incomplete model tool streams cannot execute application actions", async t => {