@the-open-engine/zeroshot 6.24.0 → 6.25.1

package/task-lib/runner.js

@@ -1,16 +1,29 @@
 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 { addTask, generateId, ensureDirs, updateTask } from './store.js';
+import {
+  isOmpSessionlessRun,
+  resolveOmpStorageRoot,
+  resolveOmpOwnerKind,
+} from './omp-storage-root.js';
+import {
+  readOwnership,
+  retireOmpOwnershipAtTerminalBoundary,
+  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 +36,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 +50,194 @@ 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),
+  };
+}
+
+/**
+ * Close a spawn that failed after its row was written but before anything could own the task.
+ *
+ * Two durable transitions, in this order and both idempotent, so a retry or a crash-recovery
+ * replay converges on the same state:
+ *   1. the OMP ownership record is retired to `cleanup-required`, releasing the partition claim
+ *      that would otherwise block every future reclaim of that directory;
+ *   2. the task row reaches a terminal status, so nothing downstream (status, kill, resume, the
+ *      stuck-task recovery sweep) keeps treating it as a live run.
+ *
+ * The decision comes from this boundary alone. Whether the partition directory exists is not
+ * consulted and must not be: a partial mkdir and a clean failure are indistinguishable on disk,
+ * and the row is the only thing that knows a spawn was attempted at all.
+ */
+function failSpawnAtProvisionalBoundary(id, error) {
+  retireOmpOwnershipAtTerminalBoundary(id, (ownershipError) => {
+    console.warn(
+      `Warning: failed to retire the OMP session ownership of task ${id}: ${ownershipError.message}`
+    );
+  });
+  try {
+    updateTask(id, {
+      status: 'failed',
+      pid: null,
+      exitCode: 1,
+      error: `Task spawn failed before the provider started: ${error.message}`,
+    });
+  } catch (updateError) {
+    console.warn(`Warning: failed to mark task ${id} failed: ${updateError.message}`);
+  }
+}
+
 export function spawnTask(prompt, options = {}) {
   ensureDirs();
 
@@ -41,10 +247,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 +267,34 @@ 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.
+  //
+  // A *thrown* materialization failure is different, and must not be left to recovery: this
+  // process is still alive and owns the row, so it has to close the boundary itself. Without this,
+  // an EACCES/ENOSPC mkdir left a row that looks forever like a live task holding a live
+  // provisional claim on a partition — permanently unreclaimable, because cleanup refuses to touch
+  // a partition any other row still claims provisionally.
   addTask(task);
+  try {
+    ompPlan?.createDirectory();
+  } catch (error) {
+    failSpawnAtProvisionalBoundary(id, error);
+    throw error;
+  }
 
   const watcherConfig = buildWatcherConfig(
     outputFormat,
     jsonSchema,
     options,
     providerName,
-    commandSpec
+    commandSpec,
+    ompPlan
   );
   const watcherScript = resolveWatcherScript(
     {
@@ -137,6 +363,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 +445,7 @@ export function buildTaskRecord({
   providerName,
   modelSpec,
   commandSpec = {},
+  ompSessionOwnership = null,
 }) {
   return {
     id,
@@ -251,6 +479,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 +496,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 +507,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,14 @@ import { join } from 'path';
 import Database from 'better-sqlite3';
 import { TASKS_DIR, LOGS_DIR } from './config.js';
 import { generateName } from './name-generator.js';
+import {
+  inspectStoredOmpSessionOwnership,
+  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 +64,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 +116,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 +134,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 +162,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,9 +213,23 @@ function rowToTask(row) {
     commandCleanup: parseCommandCleanup(row.command_cleanup),
     cancelRequested: Boolean(row.cancel_requested),
     spawnOwnershipToken: row.spawn_ownership_token,
+    ompSessionOwnership: parseOmpSessionOwnership(row.omp_session_ownership),
+    // Raw-presence seam (see inspectStoredOmpSessionOwnership). `ompSessionOwnership: null` alone
+    // cannot distinguish "this task never had an OMP session" from "this task's owner record is
+    // unreadable", and those demand opposite handling: the first is nothing to clean, the second
+    // means a partition may exist that only this row still points at. The malformed bytes
+    // themselves are deliberately not exposed — nothing may act on them.
+    ompSessionOwnershipPresent: inspectStoredOmpSessionOwnership(row.omp_session_ownership).present,
   };
 }
 
+/** True when a task row carries an `omp_session_ownership` value that exists but cannot be read as
+ * the closed schema. Such a row is retained by every cleanup surface with a warning: deleting it
+ * would orphan whatever partition the unreadable record described. */
+export function hasUnreadableOmpSessionOwnership(task) {
+  return Boolean(task?.ompSessionOwnershipPresent) && !task?.ompSessionOwnership;
+}
+
 /**
  * Load all tasks as object keyed by id
  * @returns {Object.<string, Object>}
@@ -209,77 +244,6 @@ export function loadTasks() {
   return tasks;
 }
 
-/**
- * Save all tasks (replaces entire store - for migration compatibility)
- * @param {Object.<string, Object>} tasks
- */
-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, 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
-    ) 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
-    )
-  `);
-
-  const insertMany = database.transaction((tasksObj) => {
-    // Clear existing
-    database.prepare('DELETE FROM tasks').run();
-    // Insert all
-    for (const task of Object.values(tasksObj)) {
-      insert.run({
-        id: task.id,
-        prompt: task.prompt || null,
-        fullPrompt: task.fullPrompt || null,
-        cwd: task.cwd || null,
-        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(),
-        exitCode: task.exitCode ?? null,
-        error: task.error || null,
-        provider: task.provider || null,
-        model: task.model || null,
-        scheduleId: task.scheduleId || null,
-        socketPath: task.socketPath || null,
-        attachable: task.attachable ? 1 : 0,
-        processGroupId: task.processGroupId || null,
-        terminationStrategy: task.terminationStrategy || null,
-        commandCleanup: serializeCommandCleanup(task.commandCleanup),
-        cancelRequested: task.cancelRequested ? 1 : 0,
-        spawnOwnershipToken: task.spawnOwnershipToken || null,
-      });
-    }
-  });
-
-  insertMany(tasks);
-}
-
-/**
- * For API compatibility - just runs the modifier synchronously
- * SQLite WAL handles concurrency, no lock needed
- * @param {Function} modifier
- * @returns {any}
- */
-export function withTasksLock(modifier) {
-  const tasks = loadTasks();
-  const result = modifier(tasks);
-  saveTasks(tasks);
-  return result;
-}
-
 /**
  * Get a single task by id
  * @param {string} id
@@ -350,7 +314,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 +351,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 +380,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 +415,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;
@@ -452,6 +429,59 @@ export function removeTask(id) {
   getDb().prepare('DELETE FROM tasks WHERE id = ?').run(id);
 }
 
+/**
+ * Remove a task row only while it still matches the snapshot the caller validated.
+ *
+ * `clean`/`purge` decide what to remove from one `loadTasks()` snapshot and then do real work
+ * (partition staging, command cleanup, log deletion) before they get to the delete. A watcher,
+ * a resume's ownership transfer, or a kill can land in that window; deleting on the strength of a
+ * stale snapshot would destroy a row that is no longer the row that was examined. The status and
+ * the exact ownership bytes are the two fields that decide whether removal is still correct, so
+ * both are the fence. `store.js` writes the ownership column only through
+ * `serializeOmpSessionOwnership`, whose output is canonical per record, which is what makes a
+ * byte comparison an exact "same record" test.
+ *
+ * @param {string} id
+ * @param {{status: string, ompSessionOwnership: object|null}} expected snapshot values
+ * @returns {boolean} true when the row was removed
+ */
+export function removeTaskIfUnchanged(id, expected) {
+  const result = getDb()
+    .prepare(
+      `DELETE FROM tasks
+       WHERE id = ? AND status IS ? AND omp_session_ownership IS ?`
+    )
+    .run(
+      id,
+      expected?.status ?? null,
+      serializeOmpSessionOwnership(expected?.ompSessionOwnership || null)
+    );
+  return result.changes === 1;
+}
+
+/**
+ * Clear one row's persisted command-cleanup receipt, and nothing else, only if it is still the
+ * exact serialized receipt the caller processed.
+ *
+ * Deliberately narrower than updateTask(), which is a read-modify-write over every column and
+ * would write back whatever the caller's snapshot held for the rest of the row. This is used on
+ * the retained path of `clean`, where a concurrent writer may already have installed a new cleanup
+ * receipt that must survive.
+ *
+ * @param {string} id
+ * @param {object} expected exact command-cleanup receipt processed by the caller
+ * @returns {boolean} true when that exact receipt was cleared
+ */
+export function clearTaskCommandCleanup(id, expected) {
+  const result = getDb()
+    .prepare(
+      `UPDATE tasks SET command_cleanup = NULL, updated_at = ?
+       WHERE id = ? AND command_cleanup IS ?`
+    )
+    .run(new Date().toISOString(), id, serializeCommandCleanup(expected));
+  return result.changes === 1;
+}
+
 export function generateId() {
   return generateName('task');
 }