@the-open-engine/zeroshot 6.9.1 → 6.10.0

package/task-lib/provider-session-capture.js

@@ -0,0 +1,138 @@
+import { extractProviderSessionId } from './provider-helper-runtime.js';
+
+/**
+ * Capture a provider-owned session ID from one complete output line.
+ *
+ * The caller owns persistence so watcher variants can share parsing without
+ * importing each other's process lifecycle. Repeated IDs are idempotent; any
+ * differing ID makes the capture permanently ambiguous.
+ */
+export function captureProviderSessionLine({
+  providerName,
+  line,
+  currentSessionId = null,
+  observedSessionIds = new Set(currentSessionId ? [currentSessionId] : []),
+  sessionIdConflict = false,
+  onCapture = () => {},
+  onConflict = () => {},
+}) {
+  const sessionId = extractProviderSessionId(providerName, line);
+  if (!sessionId) {
+    return { currentSessionId, sessionIdConflict };
+  }
+
+  observedSessionIds.add(sessionId);
+  if (sessionIdConflict || observedSessionIds.size > 1) {
+    if (!sessionIdConflict) {
+      onConflict([...observedSessionIds]);
+    }
+    return { currentSessionId: null, sessionIdConflict: true };
+  }
+
+  if (sessionId === currentSessionId) {
+    return { currentSessionId, sessionIdConflict: false };
+  }
+  onCapture(sessionId);
+  return { currentSessionId: sessionId, sessionIdConflict: false };
+}
+
+function providerSessionCompletionError({
+  requestedSessionId,
+  currentSessionId,
+  sessionIdConflict,
+  persistenceError,
+}) {
+  if (persistenceError) {
+    return `Provider session identity could not be persisted: ${persistenceError.message}`;
+  }
+
+  const requested = requestedSessionId?.trim() || null;
+  if (!requested) {
+    return null;
+  }
+  if (sessionIdConflict) {
+    return 'Provider continuation emitted conflicting session identities';
+  }
+
+  const captured = currentSessionId?.trim() || null;
+  if (captured === requested) {
+    return null;
+  }
+  return captured
+    ? 'Provider continuation returned a different session identity'
+    : 'Provider continuation did not confirm the requested session identity';
+}
+
+export function createProviderSessionCapture({
+  providerName,
+  taskId,
+  updateTask,
+  log,
+  requestedSessionId = null,
+  initialSessionId = null,
+  initialSessionIdConflict = false,
+}) {
+  let currentSessionId = initialSessionId;
+  let sessionIdConflict = initialSessionIdConflict;
+  let persistenceError = null;
+  const observedSessionIds = new Set(initialSessionId ? [initialSessionId] : []);
+
+  function persist(update) {
+    try {
+      updateTask(taskId, update);
+    } catch (error) {
+      persistenceError ||= error;
+      throw error;
+    }
+  }
+
+  function captureLine(line) {
+    try {
+      ({ currentSessionId, sessionIdConflict } = captureProviderSessionLine({
+        providerName,
+        line,
+        currentSessionId,
+        observedSessionIds,
+        sessionIdConflict,
+        onCapture: (sessionId) => {
+          // Advance memory before persistence so a failed write can never leave
+          // this watcher believing the earlier identity is still trustworthy.
+          currentSessionId = sessionId;
+          persist({ sessionId });
+        },
+        onConflict: () => {
+          currentSessionId = null;
+          sessionIdConflict = true;
+          persist({
+            sessionId: null,
+            sessionIdConflict: true,
+            resumeIdentityVerified: false,
+          });
+        },
+      }));
+    } catch (error) {
+      log(`[${Date.now()}][SESSION] Failed to persist provider session: ${error.message}\n`);
+    }
+  }
+
+  function getCompletionError() {
+    return providerSessionCompletionError({
+      requestedSessionId,
+      currentSessionId,
+      sessionIdConflict,
+      persistenceError,
+    });
+  }
+
+  return {
+    captureLine,
+    getCompletionError,
+    getCompletionUpdate: (resolvedCode) => {
+      const error = getCompletionError();
+      return {
+        resumeIdentityVerified: resolvedCode === 0 && !error,
+        ...(error ? { sessionId: null, sessionIdConflict: true } : {}),
+      };
+    },
+  };
+}

package/task-lib/runner.js

@@ -155,7 +155,7 @@ function providerLevelSelection(options) {
   return { modelSpec };
 }
 
-function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
+export function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
   return {
     id,
     prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
@@ -163,7 +163,15 @@ function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, mode
     cwd,
     status: 'running',
     pid: null,
-    sessionId: options.resume || options.sessionId || null,
+    // Only watcher-observed provider output may populate sessionId. A requested
+    // resume ID is diagnostic input, not proof the resumed provider emitted or
+    // accepted that session identity.
+    sessionId: null,
+    sessionIdConflict: false,
+    requestedResumeSessionId: options.resume || null,
+    // Resumed tasks start fail-closed. Only the watcher terminal transaction
+    // may prove that the requested identity completed without conflict.
+    resumeIdentityVerified: !options.resume,
     logFile,
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),

package/task-lib/store.js

@@ -12,6 +12,7 @@ import { TASKS_DIR, LOGS_DIR } from './config.js';
 import { generateName } from './name-generator.js';
 
 const DB_FILE = join(TASKS_DIR, 'store.db');
+export const TASK_STORE_SCHEMA_VERSION = 4;
 
 /** @type {Database.Database | null} */
 let db = null;
@@ -41,6 +42,9 @@ function getDb() {
       status TEXT NOT NULL DEFAULT 'pending',
       pid INTEGER,
       session_id TEXT,
+      session_id_conflict INTEGER NOT NULL DEFAULT 0,
+      requested_resume_session_id TEXT,
+      resume_identity_verified INTEGER NOT NULL DEFAULT 0,
       log_file TEXT,
       created_at TEXT NOT NULL,
       updated_at TEXT NOT NULL,
@@ -77,8 +81,7 @@ function getDb() {
     CREATE INDEX IF NOT EXISTS idx_schedules_enabled ON schedules(enabled);
   `);
 
-  ensureTaskColumn(db, 'process_group_id', 'INTEGER');
-  ensureTaskColumn(db, 'termination_strategy', 'TEXT');
+  migrateTaskStore(db);
 
   return db;
 }
@@ -90,6 +93,40 @@ function ensureTaskColumn(database, name, definition) {
   }
 }
 
+export function migrateTaskStore(database) {
+  ensureTaskColumn(database, 'process_group_id', 'INTEGER');
+  ensureTaskColumn(database, 'termination_strategy', 'TEXT');
+  ensureTaskColumn(database, 'requested_resume_session_id', 'TEXT');
+  ensureTaskColumn(database, 'session_id_conflict', 'INTEGER NOT NULL DEFAULT 0');
+  ensureTaskColumn(database, 'resume_identity_verified', 'INTEGER NOT NULL DEFAULT 0');
+
+  const version = database.pragma('user_version', { simple: true });
+  if (version >= TASK_STORE_SCHEMA_VERSION) return;
+
+  database.transaction(() => {
+    if (version < 2) {
+      database
+        .prepare(
+          `UPDATE tasks
+           SET requested_resume_session_id = COALESCE(requested_resume_session_id, session_id),
+               session_id = NULL`
+        )
+        .run();
+    }
+    if (version < 3) {
+      database.prepare('UPDATE tasks SET session_id_conflict = 0').run();
+    }
+    if (version < 4) {
+      database.prepare('UPDATE tasks SET resume_identity_verified = 0').run();
+    }
+    database.pragma(`user_version = ${TASK_STORE_SCHEMA_VERSION}`);
+  })();
+}
+
+function nullable(value) {
+  return value || null;
+}
+
 export function ensureDirs() {
   if (!existsSync(TASKS_DIR)) mkdirSync(TASKS_DIR, { recursive: true });
   if (!existsSync(LOGS_DIR)) mkdirSync(LOGS_DIR, { recursive: true });
@@ -112,6 +149,9 @@ function rowToTask(row) {
     status: row.status,
     pid: row.pid,
     sessionId: row.session_id,
+    sessionIdConflict: Boolean(row.session_id_conflict),
+    requestedResumeSessionId: row.requested_resume_session_id,
+    resumeIdentityVerified: Boolean(row.resume_identity_verified),
     logFile: row.log_file,
     createdAt: row.created_at,
     updatedAt: row.updated_at,
@@ -149,11 +189,11 @@ export function saveTasks(tasks) {
   const database = getDb();
   const insert = database.prepare(`
     INSERT OR REPLACE INTO tasks (
-      id, prompt, full_prompt, cwd, status, pid, session_id, log_file,
+      id, prompt, full_prompt, cwd, status, pid, session_id, session_id_conflict, requested_resume_session_id, resume_identity_verified, log_file,
       created_at, updated_at, exit_code, error, provider, model,
       schedule_id, socket_path, attachable, process_group_id, termination_strategy
     ) VALUES (
-      @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @logFile,
+      @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
       @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
     )
@@ -172,6 +212,9 @@ export function saveTasks(tasks) {
         status: task.status || 'pending',
         pid: task.pid || null,
         sessionId: task.sessionId || null,
+        sessionIdConflict: task.sessionIdConflict ? 1 : 0,
+        requestedResumeSessionId: nullable(task.requestedResumeSessionId),
+        resumeIdentityVerified: task.resumeIdentityVerified ? 1 : 0,
         logFile: task.logFile || null,
         createdAt: task.createdAt || new Date().toISOString(),
         updatedAt: task.updatedAt || new Date().toISOString(),
@@ -240,6 +283,9 @@ export function updateTask(id, updates) {
       status = @status,
       pid = @pid,
       session_id = @sessionId,
+      session_id_conflict = @sessionIdConflict,
+      requested_resume_session_id = @requestedResumeSessionId,
+      resume_identity_verified = @resumeIdentityVerified,
       log_file = @logFile,
       updated_at = @updatedAt,
       exit_code = @exitCode,
@@ -262,6 +308,9 @@ export function updateTask(id, updates) {
       status: updated.status || 'pending',
       pid: updated.pid || null,
       sessionId: updated.sessionId || null,
+      sessionIdConflict: updated.sessionIdConflict ? 1 : 0,
+      requestedResumeSessionId: nullable(updated.requestedResumeSessionId),
+      resumeIdentityVerified: updated.resumeIdentityVerified ? 1 : 0,
       logFile: updated.logFile || null,
       updatedAt: updated.updatedAt,
       exitCode: updated.exitCode ?? null,
@@ -295,11 +344,11 @@ export function addTask(task) {
     .prepare(
       `
     INSERT INTO tasks (
-      id, prompt, full_prompt, cwd, status, pid, session_id, log_file,
+      id, prompt, full_prompt, cwd, status, pid, session_id, session_id_conflict, requested_resume_session_id, resume_identity_verified, log_file,
       created_at, updated_at, exit_code, error, provider, model,
       schedule_id, socket_path, attachable, process_group_id, termination_strategy
     ) VALUES (
-      @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @logFile,
+      @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
       @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy
     )
@@ -313,6 +362,9 @@ export function addTask(task) {
       status: fullTask.status || 'pending',
       pid: fullTask.pid || null,
       sessionId: fullTask.sessionId || null,
+      sessionIdConflict: fullTask.sessionIdConflict ? 1 : 0,
+      requestedResumeSessionId: nullable(fullTask.requestedResumeSessionId),
+      resumeIdentityVerified: fullTask.resumeIdentityVerified ? 1 : 0,
       logFile: fullTask.logFile || null,
       createdAt: fullTask.createdAt,
       updatedAt: fullTask.updatedAt,

package/task-lib/watcher.js

@@ -8,13 +8,14 @@
 import { spawn } from 'child_process';
 import { appendFileSync, unlinkSync } from 'fs';
 import { unlink } from 'fs/promises';
-import { updateTask } from './store.js';
+import { getTask, updateTask } from './store.js';
 import {
   detectProviderFatalError,
   detectProviderStreamingModeError,
   recoverProviderStructuredOutput,
   supportsProviderStructuredOutputRecovery,
 } from './provider-helper-runtime.js';
+import { createProviderSessionCapture } from './provider-session-capture.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -36,6 +37,17 @@ function log(msg) {
 
 const providerName = normalizeProviderName(config.provider || 'claude');
 const enableRecovery = supportsProviderStructuredOutputRecovery(providerName);
+const storedTask = getTask(taskId);
+const providerSessionCapture = createProviderSessionCapture({
+  providerName,
+  taskId,
+  updateTask,
+  log,
+  requestedSessionId: storedTask?.requestedResumeSessionId || null,
+  initialSessionId: storedTask?.sessionId || null,
+  initialSessionIdConflict: storedTask?.sessionIdConflict === true,
+});
+const maybeCaptureProviderSession = providerSessionCapture.captureLine;
 
 const env = { ...process.env, ...(commandSpec.env || {}) };
 const command = commandSpec.binary;
@@ -136,6 +148,7 @@ function maybeCaptureStructuredOutput(line) {
 function handleSilentJsonLines(lines, timestamp) {
   for (const line of lines) {
     if (!line.trim()) continue;
+    maybeCaptureProviderSession(line);
     maybeHandleFatalError(line, timestamp);
     if (captureStreamingError(line, timestamp)) {
       continue;
@@ -146,6 +159,7 @@ function handleSilentJsonLines(lines, timestamp) {
 
 function handleStreamingLines(lines, timestamp) {
   for (const line of lines) {
+    maybeCaptureProviderSession(line);
     maybeHandleFatalError(line, timestamp);
     if (captureStreamingError(line, timestamp)) {
       continue;
@@ -159,6 +173,7 @@ function flushStdoutBuffer(timestamp) {
     return;
   }
 
+  maybeCaptureProviderSession(stdoutBuffer);
   if (!enableRecovery) {
     if (!silentJsonMode) {
       log(`[${timestamp}]${stdoutBuffer}\n`);
@@ -282,18 +297,25 @@ child.on('close', async (code, signal) => {
     log(finalResultJson + '\n');
   }
 
-  writeCompletionFooter(code, signal);
+  const sessionIdentityError = providerSessionCapture.getCompletionError();
+  const resolvedCode =
+    fatalError || sessionIdentityError ? 1 : recovered?.payload ? 0 : code;
+  const status = resolvedCode === 0 ? 'completed' : 'failed';
+
+  writeCompletionFooter(resolvedCode, signal);
   await cleanupCommandSpec();
 
-  const resolvedCode = fatalError ? 1 : recovered?.payload ? 0 : code;
-  const status = resolvedCode === 0 ? 'completed' : 'failed';
   try {
     await updateTask(taskId, {
       status,
       pid: null,
       processGroupId: null,
       exitCode: resolvedCode,
-      error: fatalError || (resolvedCode !== 0 && signal ? `Killed by ${signal}` : null),
+      ...providerSessionCapture.getCompletionUpdate(resolvedCode),
+      error:
+        fatalError ||
+        sessionIdentityError ||
+        (resolvedCode !== 0 && signal ? `Killed by ${signal}` : null),
     });
   } catch (updateError) {
     log(`[${Date.now()}][ERROR] Failed to update task status: ${updateError.message}\n`);