@the-open-engine/zeroshot 6.23.0 → 6.25.0

package/task-lib/runner.js

@@ -1,16 +1,25 @@
 import { fork } from 'child_process';
-import { join, dirname } from 'path';
+import { join, dirname, resolve as resolvePath } from 'path';
 import { fileURLToPath } from 'url';
+import { mkdirSync } from 'fs';
 import { LOGS_DIR } from './config.js';
 import { addTask, generateId, ensureDirs } from './store.js';
+import {
+  isOmpSessionlessRun,
+  resolveOmpStorageRoot,
+  resolveOmpOwnerKind,
+} from './omp-storage-root.js';
+import { readOwnership, writeProvisionalOwnership } from './omp-session-ownership.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
 const {
   buildOmpPrompt,
   getProviderRegistryEntry,
+  normalizeProviderName,
   prepareSingleAgentProviderCommand,
 } = require('./provider-helper-runtime.js');
+const { getDefaultProviderId } = require('../lib/provider-names.js');
 const {
   ISOLATED_SETTINGS_FILE_ENV,
   ISOLATED_SETTINGS_FILE_MARKER,
@@ -23,6 +32,11 @@ const {
 } = require('../src/worktree-claude-config');
 const { TASK_SPAWN_OWNERSHIP_TOKEN_ENV } = require('../src/task-spawn-cleanup-ownership');
 const { sendWatcherPrompt } = require('../src/watcher-prompt-channel');
+const {
+  generateOmpPartitionId,
+  partitionPathFor,
+  createOmpSessionPartitionDirectory,
+} = require('../src/omp-session-partition');
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -32,6 +46,162 @@ export {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Cross-check the caller-supplied resume descriptor against the prior owner's *persisted* record
+ * and return the expectation the watcher will re-verify.
+ *
+ * The descriptor arrives over argv (from the agent's own `providerSession.ompSession` snapshot, or
+ * from `zeroshot task resume`), so it is never trusted on its own: the task row named by
+ * `priorOwnerTaskId` is the authority, and every field the descriptor asserts must match it
+ * exactly. A descriptor and a row that disagree are conflicting identities and fail closed here,
+ * before a task row is even created — the "conflicting IDs never reach a resume prompt" case.
+ */
+export function resolveOmpResumeExpectation({ descriptor, storageRoot, canonicalWorkspace }) {
+  const prior = readOwnership(descriptor.priorOwnerTaskId);
+  if (!prior) {
+    throw new Error(
+      `OMP resume: task ${descriptor.priorOwnerTaskId} has no valid OMP session ownership record.`
+    );
+  }
+  if (prior.state !== 'committed' || !prior.session || !prior.partitionIdentity) {
+    throw new Error(
+      `OMP resume: task ${descriptor.priorOwnerTaskId} ownership is '${prior.state}', not a committed resumable session.`
+    );
+  }
+  if (prior.storageRoot !== resolvePath(storageRoot)) {
+    throw new Error(
+      `OMP resume: storage root ${resolvePath(storageRoot)} does not match the recorded ${prior.storageRoot}.`
+    );
+  }
+  // Moved/deleted workspace and "existing-but-wrong recorded cwd": a session belongs to the
+  // workspace it was recorded against and may never be continued from a different one.
+  if (prior.canonicalWorkspace !== resolvePath(canonicalWorkspace)) {
+    throw new Error(
+      `OMP resume: workspace ${resolvePath(canonicalWorkspace)} does not match the recorded ${prior.canonicalWorkspace}.`
+    );
+  }
+
+  const mismatches = [];
+  const requireExact = (label, actual, expected) => {
+    if (actual !== expected) mismatches.push(`${label} (${actual} != ${expected})`);
+  };
+  requireExact('partitionId', descriptor.partitionId, prior.partitionId);
+  requireExact('sessionId', descriptor.expectedSessionId, prior.session.sessionId);
+  requireExact('sessionFileName', descriptor.sessionFileName, prior.session.fileName);
+  requireExact(
+    'sessionFileIdentity',
+    `${descriptor.expectedSessionFileIdentity?.device}:${descriptor.expectedSessionFileIdentity?.inode}`,
+    `${prior.session.fileIdentity.device}:${prior.session.fileIdentity.inode}`
+  );
+  // partitionIdentity is deliberately absent from the agent's `providerSession.ompSession`
+  // snapshot (issue #866 fixes that field list, and the snapshot never carries partition paths or
+  // storage-root state), so it is authoritative from the row only. `zeroshot task resume`, which
+  // reads the row directly, does assert it — check it whenever it is supplied.
+  if (descriptor.expectedPartitionIdentity !== undefined) {
+    requireExact(
+      'partitionIdentity',
+      `${descriptor.expectedPartitionIdentity?.device}:${descriptor.expectedPartitionIdentity?.inode}`,
+      `${prior.partitionIdentity.device}:${prior.partitionIdentity.inode}`
+    );
+  }
+  requireExact(
+    'artifactManifestDigest',
+    descriptor.expectedArtifactManifestDigest,
+    prior.session.artifactManifestDigest
+  );
+  requireExact(
+    'executionFingerprint',
+    descriptor.expectedExecutionFingerprint,
+    prior.session.executionFingerprint
+  );
+  requireExact(
+    'selectedProvider',
+    descriptor.expectedSelectedProvider,
+    prior.session.selectedProvider
+  );
+  requireExact('selectedModel', descriptor.expectedSelectedModel, prior.session.selectedModel);
+  if (mismatches.length > 0) {
+    throw new Error(
+      `OMP resume: descriptor conflicts with the persisted owner record: ${mismatches.join(', ')}.`
+    );
+  }
+
+  return {
+    priorOwnerTaskId: descriptor.priorOwnerTaskId,
+    partitionId: prior.partitionId,
+    partitionPath: prior.partitionPath,
+    canonicalWorkspace: prior.canonicalWorkspace,
+    sessionFileName: prior.session.fileName,
+    sessionFilePath: join(prior.partitionPath, prior.session.fileName),
+    expectedSessionId: prior.session.sessionId,
+    expectedPartitionIdentity: prior.partitionIdentity,
+    expectedSessionFileIdentity: prior.session.fileIdentity,
+    expectedArtifactManifestDigest: prior.session.artifactManifestDigest,
+    expectedExecutionFingerprint: prior.session.executionFingerprint,
+    expectedSelectedProvider: prior.session.selectedProvider,
+    expectedSelectedModel: prior.session.selectedModel,
+  };
+}
+
+/**
+ * Resolve this task's OMP session plan, or null for every other provider / structured-output
+ * recovery turn. Allocates (but does not yet create on disk) a fresh partition, or resolves the
+ * resume descriptor against the prior owner's persisted record. The partition directory itself is
+ * created only after the task row is durable (see spawnTask below — row-before-directory), and
+ * the structural/identity/fingerprint verification plus the owner transfer happen in the rpc-stdio
+ * watcher, not here.
+ */
+function resolveOmpSessionPlan({ id, cwd, options }) {
+  if (options.structuredOutputRecovery) return null;
+  const providerName = normalizeProviderName(options.provider || getDefaultProviderId());
+  if (providerName !== 'omp') return null;
+  // Docker stays fresh-only (issue #866). Returning null here means no partition is allocated, no
+  // ownership row is written, and the adapter falls back to `--no-session`.
+  if (isOmpSessionlessRun(options)) return null;
+
+  const storageRoot = resolveOmpStorageRoot(options);
+  mkdirSync(storageRoot, { recursive: true });
+  const ownerKind = resolveOmpOwnerKind(options);
+  const owner = { ...ownerKind, taskId: id };
+
+  if (options.ompResume) {
+    const expectation = resolveOmpResumeExpectation({
+      descriptor: options.ompResume,
+      storageRoot,
+      canonicalWorkspace: cwd,
+    });
+    return {
+      session: {
+        kind: 'resume',
+        partition: { path: expectation.partitionPath },
+        file: { path: expectation.sessionFilePath },
+      },
+      resumeExpectation: expectation,
+      provisionalOwnership: writeProvisionalOwnership({
+        partitionId: expectation.partitionId,
+        storageRoot,
+        canonicalWorkspace: cwd,
+        owner,
+      }),
+      createDirectory: () => {}, // must already exist; the watcher verifies before spawn
+    };
+  }
+
+  const partitionId = generateOmpPartitionId();
+  const partitionPath = partitionPathFor(storageRoot, partitionId);
+  return {
+    session: { kind: 'fresh', partition: { path: partitionPath } },
+    resumeExpectation: null,
+    provisionalOwnership: writeProvisionalOwnership({
+      partitionId,
+      storageRoot,
+      canonicalWorkspace: cwd,
+      owner,
+    }),
+    createDirectory: () => createOmpSessionPartitionDirectory(partitionPath),
+  };
+}
+
 export function spawnTask(prompt, options = {}) {
   ensureDirs();
 
@@ -41,10 +211,12 @@ export function spawnTask(prompt, options = {}) {
 
   const outputFormat = resolveOutputFormat(options);
   const jsonSchema = resolveJsonSchema(options, outputFormat);
+  const ompPlan = resolveOmpSessionPlan({ id, cwd, options });
   const prepared = prepareTaskProviderCommandFromResolved(prompt, options, {
     outputFormat,
     jsonSchema,
     cwd,
+    ompSession: ompPlan?.session,
   });
   const providerName = prepared.adapter.id;
   const modelSpec = prepared.options.modelSpec;
@@ -59,16 +231,23 @@ export function spawnTask(prompt, options = {}) {
     providerName,
     modelSpec,
     commandSpec,
+    ompSessionOwnership: ompPlan?.provisionalOwnership ?? null,
   });
 
+  // Row-before-directory: the SQL row is durable proof of an attempted allocation before the
+  // partition directory (or anything else OMP-owned) exists on disk. A crash between these two
+  // lines leaves a provisional row pointing at a path with nothing there yet — cleanup safely
+  // no-ops on a nonexistent path, and normal task-lifecycle recovery handles the row itself.
   addTask(task);
+  ompPlan?.createDirectory();
 
   const watcherConfig = buildWatcherConfig(
     outputFormat,
     jsonSchema,
     options,
     providerName,
-    commandSpec
+    commandSpec,
+    ompPlan
   );
   const watcherScript = resolveWatcherScript(
     {
@@ -137,6 +316,7 @@ function buildProviderOptions(options, runtime, modelSelection) {
     ...(structuredOutputRecovery ? {} : mcpConfigOption(options)),
     ...claudeSettingsFileOption(),
     ...(!structuredOutputRecovery && options.resume ? { resumeSessionId: options.resume } : {}),
+    ...(runtime.ompSession ? { ompSession: runtime.ompSession } : {}),
     ...(process.env.ZEROSHOT_OPENCODE_AGENT?.trim()
       ? { agentName: process.env.ZEROSHOT_OPENCODE_AGENT.trim() }
       : {}),
@@ -218,6 +398,7 @@ export function buildTaskRecord({
   providerName,
   modelSpec,
   commandSpec = {},
+  ompSessionOwnership = null,
 }) {
   return {
     id,
@@ -251,6 +432,7 @@ export function buildTaskRecord({
     terminationStrategy: null,
     cancelRequested: false,
     spawnOwnershipToken: process.env[TASK_SPAWN_OWNERSHIP_TOKEN_ENV] || null,
+    ompSessionOwnership,
     commandCleanup:
       commandSpec.cleanup?.length > 0
         ? {
@@ -267,8 +449,8 @@ function isRpcStdioLane(providerName) {
 
 // The returned object is JSON-serialized into the detached watcher's argv, so it must never carry
 // prompt or other task content: `ps` and /proc/<pid>/cmdline expose argv to every local user for
-// the whole lifetime of the watcher.
-function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec) {
+// the whole lifetime of the watcher. Partition paths, ids, and digests are not secret.
+function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec, ompPlan) {
   return {
     outputFormat,
     jsonSchema,
@@ -278,6 +460,15 @@ function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, com
     command: commandSpec.binary,
     env: commandSpec.env || {},
     commandSpec: buildWatcherCommandSpec(commandSpec, isRpcStdioLane(providerName)),
+    ...(ompPlan
+      ? {
+          ompSession: ompPlan.session,
+          ompResumeExpectation: ompPlan.resumeExpectation,
+          // The workspace the ownership row was canonicalized against; the watcher compares it to
+          // the session header's own recorded cwd after materialization.
+          ompCanonicalWorkspace: ompPlan.provisionalOwnership.canonicalWorkspace,
+        }
+      : {}),
   };
 }
 

package/task-lib/store.js

@@ -10,9 +10,13 @@ import { join } from 'path';
 import Database from 'better-sqlite3';
 import { TASKS_DIR, LOGS_DIR } from './config.js';
 import { generateName } from './name-generator.js';
+import {
+  parseOmpSessionOwnership,
+  serializeOmpSessionOwnership,
+} from './omp-session-ownership-schema.js';
 
 const DB_FILE = join(TASKS_DIR, 'store.db');
-export const TASK_STORE_SCHEMA_VERSION = 4;
+export const TASK_STORE_SCHEMA_VERSION = 5;
 
 /** @type {Database.Database | null} */
 let db = null;
@@ -59,7 +63,8 @@ function getDb() {
       termination_strategy TEXT,
       command_cleanup TEXT,
       cancel_requested INTEGER DEFAULT 0,
-      spawn_ownership_token TEXT
+      spawn_ownership_token TEXT,
+      omp_session_ownership TEXT
     );
 
     CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
@@ -110,6 +115,15 @@ function serializeCommandCleanup(value) {
   return value ? JSON.stringify(value) : null;
 }
 
+/**
+ * Internal accessor for modules that need direct prepared-statement access (SQL compare-and-swap
+ * transitions) beyond what the generic load/save/update helpers below offer. See
+ * task-lib/omp-session-ownership.js.
+ */
+export function getTaskStoreDatabase() {
+  return getDb();
+}
+
 export function migrateTaskStore(database) {
   ensureTaskColumn(database, 'process_group_id', 'INTEGER');
   ensureTaskColumn(database, 'termination_strategy', 'TEXT');
@@ -119,6 +133,9 @@ export function migrateTaskStore(database) {
   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');
+  // No backfill: every pre-v5 row has no OMP session concept, so NULL is exact truth, never a
+  // fabricated value. A non-OMP task's resume path is untouched by this column.
+  ensureTaskColumn(database, 'omp_session_ownership', 'TEXT');
   database.exec(`
     CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_spawn_ownership_token
       ON tasks(spawn_ownership_token)
@@ -144,6 +161,9 @@ export function migrateTaskStore(database) {
     if (version < 4) {
       database.prepare('UPDATE tasks SET resume_identity_verified = 0').run();
     }
+    if (version < 5) {
+      // omp_session_ownership already defaults to NULL via ensureTaskColumn above; no backfill.
+    }
     database.pragma(`user_version = ${TASK_STORE_SCHEMA_VERSION}`);
   })();
 }
@@ -192,6 +212,7 @@ function rowToTask(row) {
     commandCleanup: parseCommandCleanup(row.command_cleanup),
     cancelRequested: Boolean(row.cancel_requested),
     spawnOwnershipToken: row.spawn_ownership_token,
+    ompSessionOwnership: parseOmpSessionOwnership(row.omp_session_ownership),
   };
 }
 
@@ -220,12 +241,12 @@ export function saveTasks(tasks) {
       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,
-      command_cleanup, cancel_requested, spawn_ownership_token
+      command_cleanup, cancel_requested, spawn_ownership_token, omp_session_ownership
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
       @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy,
-      @commandCleanup, @cancelRequested, @spawnOwnershipToken
+      @commandCleanup, @cancelRequested, @spawnOwnershipToken, @ompSessionOwnership
     )
   `);
 
@@ -260,6 +281,7 @@ export function saveTasks(tasks) {
         commandCleanup: serializeCommandCleanup(task.commandCleanup),
         cancelRequested: task.cancelRequested ? 1 : 0,
         spawnOwnershipToken: task.spawnOwnershipToken || null,
+        ompSessionOwnership: serializeOmpSessionOwnership(task.ompSessionOwnership || null),
       });
     }
   });
@@ -350,7 +372,15 @@ export function updateTask(id, updates) {
       termination_strategy = @terminationStrategy,
       command_cleanup = @commandCleanup,
       cancel_requested =
-        CASE WHEN @hasCancelRequested = 1 THEN @cancelRequested ELSE cancel_requested END
+        CASE WHEN @hasCancelRequested = 1 THEN @cancelRequested ELSE cancel_requested END,
+      -- Only ever written when the caller explicitly supplies it. This is a read-modify-write
+      -- update, so unconditionally rewriting the ownership column would let an unrelated
+      -- updateTask (the watcher persisting spawn evidence, say) clobber an owner-fenced
+      -- compare-and-swap another process performed in between — see
+      -- task-lib/omp-session-ownership.js, whose transitions bypass this statement for exactly
+      -- that reason.
+      omp_session_ownership =
+        CASE WHEN @hasOmpSessionOwnership = 1 THEN @ompSessionOwnership ELSE omp_session_ownership END
     WHERE id = @id
   `
     )
@@ -379,6 +409,10 @@ export function updateTask(id, updates) {
       commandCleanup: serializeCommandCleanup(updated.commandCleanup),
       hasCancelRequested: Object.prototype.hasOwnProperty.call(updates, 'cancelRequested') ? 1 : 0,
       cancelRequested: updated.cancelRequested ? 1 : 0,
+      hasOmpSessionOwnership: Object.prototype.hasOwnProperty.call(updates, 'ompSessionOwnership')
+        ? 1
+        : 0,
+      ompSessionOwnership: serializeOmpSessionOwnership(updated.ompSessionOwnership || null),
     });
 
   return updated;
@@ -404,12 +438,12 @@ export function addTask(task) {
       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,
-      command_cleanup, cancel_requested, spawn_ownership_token
+      command_cleanup, cancel_requested, spawn_ownership_token, omp_session_ownership
     ) VALUES (
       @id, @prompt, @fullPrompt, @cwd, @status, @pid, @sessionId, @sessionIdConflict, @requestedResumeSessionId, @resumeIdentityVerified, @logFile,
       @createdAt, @updatedAt, @exitCode, @error, @provider, @model,
       @scheduleId, @socketPath, @attachable, @processGroupId, @terminationStrategy,
-      @commandCleanup, @cancelRequested, @spawnOwnershipToken
+      @commandCleanup, @cancelRequested, @spawnOwnershipToken, @ompSessionOwnership
     )
   `
     )
@@ -439,6 +473,7 @@ export function addTask(task) {
       commandCleanup: serializeCommandCleanup(fullTask.commandCleanup),
       cancelRequested: fullTask.cancelRequested ? 1 : 0,
       spawnOwnershipToken: fullTask.spawnOwnershipToken || null,
+      ompSessionOwnership: serializeOmpSessionOwnership(fullTask.ompSessionOwnership || null),
     });
 
   return fullTask;