@jskit-ai/assistant-core 0.2.18 → 0.2.19

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.18",
-    "@jskit-ai/http-runtime": "0.2.8",
-    "@jskit-ai/kernel": "0.2.8",
+    "@jskit-ai/assistant-core": "0.2.19",
+    "@jskit-ai/http-runtime": "0.2.9",
+    "@jskit-ai/kernel": "0.2.9",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.9",
-    "@jskit-ai/connectors-catalog": "0.2.9"
+    "@jskit-ai/connectors-core": "0.2.10",
+    "@jskit-ai/connectors-catalog": "0.2.10"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.18",
+  "version": "0.2.19",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -51,8 +51,8 @@
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
     "@jskit-ai/agent": "0.1.1",
-    "@jskit-ai/resource-core": "0.1.199",
-    "@jskit-ai/resource-crud-core": "0.1.199",
+    "@jskit-ai/resource-core": "0.1.200",
+    "@jskit-ai/resource-crud-core": "0.1.200",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.152",
@@ -61,8 +61,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.2.8",
-    "@jskit-ai/kernel": "0.2.8",
+    "@jskit-ai/http-runtime": "0.2.9",
+    "@jskit-ai/kernel": "0.2.9",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/server/conversation/codexNotificationObserver.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerTurnKey, CODEX_APP_SERVER_AGENT_RUN_ID, CODEX_AGENT_PROVIDER, CODEX_APP_SERVER_RUN_STATE } from "./codexTurnState.js";
 import { codexAppServerProviderConnectionGeneration } from "./codexModelCatalog.js";
 import {
   codexAppServerAssistantItemText,
@@ -239,6 +239,8 @@ export function createCodexNotificationObserver({
         threadId: normalizedThreadId,
         turnId: codexAppServerNotificationTurnId(notification)
       };
+      // Anything Codex reports about a turn means it has started that turn.
+      journal.unstartedTurns.delete(codexAppServerTurnKey(normalizedThreadId, notificationContext.turnId));
       if (method === "thread/tokenUsage/updated") {
         notificationQueue.run(notificationContext, async () => {
           const store = await createStore(normalizedSessionId);

package/src/server/conversation/codexPromptDispatch.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerMessageRequiresNewTurn, codexAppServerMessageDeferred } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerErrorMessage, codexAppServerSteerFailure, codexAppServerMessageRequiresNewTurn, codexAppServerMessageDeferred, codexAppServerTurnKey } from "./codexTurnState.js";
 import { codexAppServerRequestIsInvalid } from "./codexProviderThreads.js";
 import { codexLocalImageInput, codexAppServerDeliveredTurn, sendCodexAppServerPrompt } from "./codexProviderTurns.js";
 import { normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
@@ -74,6 +74,10 @@ export function createCodexPromptDispatch({
     if (!deliveredTurnId) {
       throw new Error("Codex app-server accepted the prompt without returning a turn id.");
     }
+    // Codex answers turn/start before it starts the turn; its notifications about the turn say when it has.
+    if (!codexAppServerTurnStatusIsComplete(deliveredTurnStatus)) {
+      journal.unstartedTurns.add(codexAppServerTurnKey(threadId, deliveredTurnId));
+    }
     delivery.pendingUserMessage(promptSessionId, clientUserMessageId)?.onNativeReceipt();
     await recovery.markTurnActive(sessionId, {
       requireTrackedTurn: true,

package/src/server/conversation/codexRunJournal.js

@@ -88,6 +88,8 @@ export function createCodexRunJournal({
   isClosing
 }) {
   const codexAppServerCompletedTurns = new Set();
+  // Turns Codex accepted with turn/start but has not yet reported: until it does, its thread still reads idle.
+  const codexAppServerUnstartedTurns = new Set();
   const codexAppServerProcessedTurns = new Set();
   const codexAppServerActiveTimers = new Map();
   const codexAppServerFinalizingTimers = new Map();
@@ -637,6 +639,7 @@ export function createCodexRunJournal({
 
   return Object.freeze({
     completedTurns: codexAppServerCompletedTurns,
+    unstartedTurns: codexAppServerUnstartedTurns,
     processedTurns: codexAppServerProcessedTurns,
     activeTimers: codexAppServerActiveTimers,
     finalizingTimers: codexAppServerFinalizingTimers,

package/src/server/conversation/codexThreadStatus.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnCanAdoptSuccessor, codexAppServerErrorMessage } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerTurnCanReceiveProviderCompletion, codexAppServerTurnCanAdoptSuccessor, codexAppServerErrorMessage, codexAppServerTurnKey } from "./codexTurnState.js";
 import { isRecord, normalizeText } from "@jskit-ai/kernel/shared/support/normalize";
 import { codexAppServerStatusFromValue } from "./codexEvents.js";
 import { codexAppServerThreadRawValue, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexThreadSnapshot.js";
@@ -200,6 +200,27 @@ export function createCodexThreadStatus({ journal, settlement, recovery, output,
         turnId
       };
     }
+    // Codex has accepted the tracked turn but not started it. Until it does, its thread reads idle and lists the
+    // turn as interrupted, so only Codex's own report about the turn settles it.
+    if (
+      trackedProviderTurn?.state === "active" &&
+      !codexAppServerTurnStatusIsActive(status) &&
+      journal.unstartedTurns.has(codexAppServerTurnKey(trackedProviderTurn.threadId, trackedProviderTurn.turnId))
+    ) {
+      debugLog("appServerThread.reconcile.awaitingProviderStart", {
+        sessionId: normalizedSessionId,
+        source: normalizeText(source),
+        status,
+        threadId: trackedProviderTurn.threadId,
+        turnId: trackedProviderTurn.turnId
+      });
+      return {
+        ok: true,
+        reason: "provider_turn_not_started",
+        status: trackedProviderTurn.status || "inProgress",
+        turnId: trackedProviderTurn.turnId
+      };
+    }
     if (
       trackedProviderTurn &&
       turnId &&

package/src/server/conversation/codexTurnRecovery.js

@@ -1,4 +1,4 @@
-import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerPendingUserMessageOwnership, codexAppServerTurnCanAdoptSuccessor } from "./codexTurnState.js";
+import { codexAppServerTurnStatusIsActive, codexAppServerTurnStatusIsComplete, codexAppServerTurnStatusIsSuccessfulComplete, codexAppServerTurnStatusIsProviderFailure, codexAppServerThreadStatus, codexAppServerReadThreadStatus, codexAppServerAgentRun, codexAppServerPendingUserMessageOwnership, codexAppServerTurnCanAdoptSuccessor, codexAppServerTurnKey } from "./codexTurnState.js";
 import { codexAppServerProviderTurnForOperation, codexAppServerThreadTurnId, codexAppServerThreadError } from "./codexThreadSnapshot.js";
 import { createCodexTurnActivity } from "./codexTurnActivity.js";
 import { createCodexTurnEndings } from "./codexTurnEndings.js";
@@ -270,6 +270,17 @@ export function createCodexTurnRecovery({
     if (!codexAppServerTurnStatusIsComplete(status)) {
       return currentSession;
     }
+    if (journal.unstartedTurns.has(codexAppServerTurnKey(currentTurn.threadId, currentTurn.turnId))) {
+      // Codex has accepted this turn but not started it, and its thread reads idle until it does.
+      debugLog("appServerTurn.reconcile.awaitingProviderStart", {
+        sessionId,
+        status,
+        threadId: currentTurn.threadId,
+        turnId: currentTurn.turnId
+      });
+      scheduleCodexAppServerActiveRecovery(sessionId);
+      return currentSession;
+    }
     const completedTurnId = providerTurnId || currentTurn.turnId;
     debugLog("appServerTurn.reconcile.complete", {
       sessionId,

package/test/codexTurn.test.js

@@ -1910,6 +1910,51 @@ test("original dispatch steering preserves deferred versus new-turn recovery and
   }
 });
 
+// Codex answers turn/start before it starts the turn. Until its turn/started notification, codex-cli 0.163.0 reads
+// the thread as idle and lists the new turn as interrupted, so neither read means the turn ended. On 2026-11-06 the
+// starting watchdog's status read landed in that gap: the turn was marked finished 0.46 s after delivery, and Codex's
+// answer 33 s later was dropped behind "Codex finished, but Vibe64 could not recover its final response".
+for (const read of ["starting watchdog", "status check"]) {
+  test(`a delivered turn Codex has not started stays active through a ${read} and keeps its answer`, async t => {
+    const notices = [];
+    const f = await receiptFixture({
+      finalizingGraceMs: 30,
+      outcomeNotice(_runtime, _sessionId, _threadId, _turnId, outcome) { notices.push(outcome); }
+    });
+    t.after(() => f.owner.clearSessionRecoveryTimers(f.sessionId));
+    const context = dispatchContext(f);
+    let codexStatus = "idle";
+    f.run = { ...f.run, state: "starting", providerTurnId: "", providerStatus: "", outerTurnId: context.messageId };
+    f.provider.sendTurn = async () => ({ id: f.turnId, status: "inProgress" });
+    f.provider.readThreadStatus = async () => ({ raw: { status: { type: codexStatus } } });
+    f.history = [turn(f.turnId, "interrupted")];
+    f.observe();
+    assert.equal((await f.owner.startTurn(f.sessionId, {}, context)).providerFailure, "");
+    assert.equal(f.run.state, "active");
+    if (read === "starting watchdog") {
+      await f.owner.recoverActiveTurn(f.sessionId, { provider: f.provider, retryOnError: false });
+    } else {
+      await f.owner.reconcileThreadStatus(f.sessionId, f.provider, f.threadId, {
+        observeLatestTurn: true, source: "wellbeing"
+      });
+    }
+    await f.drain();
+    assert.equal(f.run.state, "active", "An idle read before turn/started does not end the turn");
+    assert.equal(f.run.providerTurnId, f.turnId);
+    codexStatus = "active";
+    f.history = [turn(f.turnId, "inProgress")];
+    f.emit({ method: "turn/started", params: { threadId: f.threadId, turn: { id: f.turnId, status: "inProgress" } } });
+    await f.drain();
+    codexStatus = "idle";
+    f.history = [turn(f.turnId, "completed", "The complete reply.")];
+    f.emit({ method: "turn/completed", params: { threadId: f.threadId, turn: { id: f.turnId, status: "completed" } } });
+    await f.drain();
+    assert.equal(f.run.state, "completed");
+    assert.deepEqual((await f.replies()).map(row => row.assistant.text), ["The complete reply."]);
+    assert.deepEqual(notices, []);
+  });
+}
+
 function controlContext(f, overrides = {}) {
   return {
     runtime: f.runtime,