@the-open-engine/zeroshot 6.25.0 → 6.25.1

package/cli/index.js

@@ -2086,12 +2086,9 @@ async function getPurgeData(orchestrator) {
       cluster.state === 'running' || cluster.state === 'initializing' || cluster.state === 'setup'
   );
   const { loadTasks } = await import('../task-lib/store.js');
-  const { isProcessRunning } = await import('../task-lib/runner.js');
   const tasks = Object.values(loadTasks());
-  const runningTasks = tasks.filter(
-    (task) => task.status === 'running' && isProcessRunning(task.pid)
-  );
-  return { clusters, runningClusters, tasks, runningTasks, isProcessRunning };
+  const runningTasks = tasks.filter((task) => task.status === 'running');
+  return { clusters, runningClusters, tasks, runningTasks };
 }
 
 function printPurgeSummary({ clusters, runningClusters, tasks, runningTasks }) {
@@ -2133,45 +2130,105 @@ async function confirmPurge(options) {
   return answer.toLowerCase() === 'y';
 }
 
+function validateClusterKillResults(runningClusters, clusterResults) {
+  if (
+    clusterResults === null ||
+    typeof clusterResults !== 'object' ||
+    !Array.isArray(clusterResults.killed) ||
+    !Array.isArray(clusterResults.errors)
+  ) {
+    throw new Error(
+      'Refusing destructive cluster cleanup: kill-all returned incomplete or invalid results ' +
+        '(malformed fields: killed or errors). Retry after confirming every cluster process ' +
+        'boundary is terminal.'
+    );
+  }
+
+  const expectedIds = runningClusters.map((cluster) => cluster.id);
+  const expected = new Set(expectedIds);
+  const outcomeIds = [...clusterResults.killed, ...clusterResults.errors.map((error) => error?.id)];
+  const counts = outcomeIds.reduce((byId, id) => {
+    byId.set(id, (byId.get(id) || 0) + 1);
+    return byId;
+  }, new Map());
+  const problems = [
+    ['unknown outcomes', outcomeIds.filter((id) => typeof id !== 'string' || !expected.has(id))],
+    ['duplicate outcomes', expectedIds.filter((id) => (counts.get(id) || 0) > 1)],
+    ['missing outcomes', expectedIds.filter((id) => (counts.get(id) || 0) === 0)],
+  ]
+    .filter(([, ids]) => ids.length > 0)
+    .map(([label, ids]) => `${label}: ${ids.join(', ')}`);
+
+  if (problems.length > 0) {
+    throw new Error(
+      `Refusing destructive cluster cleanup: kill-all returned incomplete or invalid results (${problems.join(
+        '; '
+      )}). Retry after confirming every cluster process boundary is terminal.`
+    );
+  }
+
+  return clusterResults;
+}
+
 async function killRunningClusters(orchestrator, runningClusters) {
   if (runningClusters.length === 0) {
     return;
   }
   console.log(chalk.bold('Killing running clusters...'));
-  const clusterResults = await orchestrator.killAll();
-  for (const id of clusterResults.killed) {
+  const { killed, errors } = validateClusterKillResults(
+    runningClusters,
+    await orchestrator.killAll()
+  );
+
+  for (const id of killed) {
     console.log(chalk.green(`✓ Killed cluster: ${id}`));
   }
-  for (const err of clusterResults.errors) {
-    console.log(chalk.red(`✗ Failed to kill cluster ${err.id}: ${err.error}`));
+  if (errors.length > 0) {
+    for (const err of errors) {
+      console.log(chalk.red(`✗ Failed to kill cluster ${err.id}: ${err.error}`));
+    }
+    throw new Error(
+      `Refusing destructive cluster cleanup: termination failed for ${errors
+        .map((error) => error.id)
+        .join(', ')}. Retry after confirming every cluster process boundary is terminal.`
+    );
   }
 }
 
-async function killRunningTasks(runningTasks, isProcessRunning) {
+async function killRunningTasks(runningTasks) {
   if (runningTasks.length === 0) {
     return;
   }
   console.log(chalk.bold('Killing running tasks...'));
-  const { killTask } = await import('../task-lib/runner.js');
-  const { updateTask } = await import('../task-lib/store.js');
-
+  const [{ killTaskCommand }, { getTask }] = await Promise.all([
+    import('../task-lib/commands/kill.js'),
+    import('../task-lib/store.js'),
+  ]);
+  const unconfirmed = [];
+
+  // Reuse the standalone kill boundary instead of treating successful signal delivery as process
+  // termination. Then verify its durable terminal write: killTaskCommand also serves the interactive
+  // CLI and reports an unconfirmed boundary through process.exitCode rather than throwing. Purge
+  // must turn that report into a hard gate before it reaches any destructive cleanup.
   for (const task of runningTasks) {
-    if (!isProcessRunning(task.pid)) {
-      updateTask(task.id, {
-        status: 'stale',
-        error: 'Process died unexpectedly',
-      });
-      console.log(chalk.yellow(`○ Task ${task.id} was already dead, marked stale`));
-      continue;
-    }
-
-    const killed = killTask(task.pid);
-    if (killed) {
-      updateTask(task.id, { status: 'killed', error: 'Killed by clear' });
-      console.log(chalk.green(`✓ Killed task: ${task.id}`));
-    } else {
-      console.log(chalk.red(`✗ Failed to kill task: ${task.id}`));
-    }
+    await killTaskCommand(task.id);
+    const current = getTask(task.id);
+    if (
+      !current ||
+      current.status === 'running' ||
+      Number.isInteger(current.pid) ||
+      Number.isInteger(current.processGroupId)
+    ) {
+      unconfirmed.push(task.id);
+    }
+  }
+
+  if (unconfirmed.length > 0) {
+    throw new Error(
+      `Refusing destructive task cleanup: provider termination is unconfirmed for ${unconfirmed.join(
+        ', '
+      )}. Retry after confirming the persisted provider process boundary is terminal.`
+    );
   }
 }
 
@@ -2183,17 +2240,18 @@ async function killRunningTasks(runningTasks, isProcessRunning) {
  * cannot be safely resolved keeps its owner record plus a warning instead of being deleted.
  */
 async function deleteClusterOmpSessions(clusters) {
-  const { cleanupOmpSessionPartitionsForCluster } = await import(
-    '../task-lib/omp-session-cleanup.js'
-  );
+  const { cleanupOmpSessionPartitionsForCluster } =
+    await import('../task-lib/omp-session-cleanup.js');
   let deleted = 0;
   let retained = 0;
+  const unreadable = new Set();
   for (const cluster of clusters) {
     const result = cleanupOmpSessionPartitionsForCluster(cluster.id, (message) =>
       console.log(chalk.yellow(`Warning: ${message}`))
     );
     deleted += result.deleted.length;
     retained += result.retained.length;
+    for (const taskId of result.unreadable) unreadable.add(taskId);
   }
   if (deleted > 0) {
     console.log(chalk.green(`✓ Deleted ${deleted} OMP session partition(s)`));
@@ -2201,6 +2259,13 @@ async function deleteClusterOmpSessions(clusters) {
   if (retained > 0) {
     console.log(chalk.yellow(`○ Retained ${retained} OMP session partition(s) for inspection`));
   }
+  if (unreadable.size > 0) {
+    console.log(
+      chalk.yellow(
+        `○ ${unreadable.size} task row(s) hold an unreadable OMP session ownership record and were left intact`
+      )
+    );
+  }
 }
 
 async function deleteClusterData(orchestrator, clusters) {
@@ -3204,11 +3269,8 @@ program
       );
 
       const { loadTasks } = await import('../task-lib/store.js');
-      const { isProcessRunning } = await import('../task-lib/runner.js');
       const tasks = loadTasks();
-      const runningTasks = Object.values(tasks).filter(
-        (t) => t.status === 'running' && isProcessRunning(t.pid)
-      );
+      const runningTasks = Object.values(tasks).filter((task) => task.status === 'running');
 
       const totalCount = runningClusters.length + runningTasks.length;
 
@@ -3253,44 +3315,9 @@ program
 
       console.log('');
 
-      // Kill clusters
-      if (runningClusters.length > 0) {
-        const clusterResults = await orchestrator.killAll();
-        for (const id of clusterResults.killed) {
-          console.log(chalk.green(`✓ Killed cluster: ${id}`));
-        }
-        for (const err of clusterResults.errors) {
-          console.log(chalk.red(`✗ Failed to kill cluster ${err.id}: ${err.error}`));
-        }
-      }
-
-      // Kill tasks
-      if (runningTasks.length > 0) {
-        const { killTask, isProcessRunning: checkPid } = await import('../task-lib/runner.js');
-        const { updateTask } = await import('../task-lib/store.js');
-
-        for (const task of runningTasks) {
-          if (!checkPid(task.pid)) {
-            updateTask(task.id, {
-              status: 'stale',
-              error: 'Process died unexpectedly',
-            });
-            console.log(chalk.yellow(`○ Task ${task.id} was already dead, marked stale`));
-            continue;
-          }
+      await killRunningClusters(orchestrator, runningClusters);
 
-          const killed = killTask(task.pid);
-          if (killed) {
-            updateTask(task.id, {
-              status: 'killed',
-              error: 'Killed by kill-all',
-            });
-            console.log(chalk.green(`✓ Killed task: ${task.id}`));
-          } else {
-            console.log(chalk.red(`✗ Failed to kill task: ${task.id}`));
-          }
-        }
-      }
+      await killRunningTasks(runningTasks);
 
       console.log(chalk.bold.green(`\nDone.`));
     } catch (error) {
@@ -3801,7 +3828,7 @@ program
       console.log('');
 
       await killRunningClusters(orchestrator, purgeData.runningClusters);
-      await killRunningTasks(purgeData.runningTasks, purgeData.isProcessRunning);
+      await killRunningTasks(purgeData.runningTasks);
       await deleteClusterData(orchestrator, purgeData.clusters);
       await deleteTaskData(purgeData.tasks);
 
@@ -6089,4 +6116,5 @@ module.exports = {
   renderRecentMessagesToTerminal,
   isStartupUpdateEligible,
   resolveRunMode,
+  killRunningClusters,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.25.0",
+  "version": "6.25.1",
   "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {

package/src/agent/provider-session.js

@@ -65,13 +65,25 @@ const OMP_SESSION_KEYS = new Set([
 ]);
 const IDENTITY_KEYS = new Set(['device', 'inode']);
 
+/**
+ * A `{device, inode}` pair, both already canonical unsigned decimal *strings* (issue #866).
+ *
+ * The type is required, not coerced. `String(value.device)` used to accept a JSON number, a
+ * boxed String, a one-element array, or anything else whose `toString()` happened to look decimal,
+ * and then write the coerced result into the snapshot — so a snapshot that had never contained the
+ * canonical form would compare equal to the persisted ownership record it is supposed to be
+ * checked against. A snapshot that is not already canonical is not this writer's snapshot, and is
+ * rejected rather than repaired. Both keys are required and no others are allowed.
+ */
 function normalizeIdentity(value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-  if (!Object.keys(value).every((key) => IDENTITY_KEYS.has(key))) return null;
-  if (!DECIMAL_STRING.test(String(value.device)) || !DECIMAL_STRING.test(String(value.inode))) {
+  const keys = Object.keys(value);
+  if (keys.length !== IDENTITY_KEYS.size || !keys.every((key) => IDENTITY_KEYS.has(key))) {
     return null;
   }
-  return { device: String(value.device), inode: String(value.inode) };
+  if (typeof value.device !== 'string' || typeof value.inode !== 'string') return null;
+  if (!DECIMAL_STRING.test(value.device) || !DECIMAL_STRING.test(value.inode)) return null;
+  return { device: value.device, inode: value.inode };
 }
 
 /**
@@ -299,7 +311,9 @@ function providerSessionFromCompletedTask({
   // rpc-watcher.js never populates the generic sessionId column; the OMP-observed session ID
   // committed alongside ompSession is the one authoritative identity for this provider.
   const sessionId = isOmp
-    ? normalizeNonEmptyString(ompOwnership?.state === 'committed' ? ompOwnership.session?.sessionId : null)
+    ? normalizeNonEmptyString(
+        ompOwnership?.state === 'committed' ? ompOwnership.session?.sessionId : null
+      )
     : normalizeNonEmptyString(taskInfo.sessionId);
   const taskId = normalizeNonEmptyString(taskInfo.id);
   const generation = agent?.iteration;

package/src/omp-session-limits.js

@@ -14,4 +14,28 @@ const OMP_SESSION_LIMITS = Object.freeze({
   maxReferencedBlobBytes: 67108864,
 });
 
-module.exports = { OMP_SESSION_LIMITS };
+/**
+ * The largest single JSONL record the verifier will buffer, DERIVED from the constants above
+ * rather than chosen — it is `maxReferencedBlobBytes`, and it is not a new knob (there is nothing
+ * to configure and no caller may override it).
+ *
+ * Why a per-record bound is needed at all: `maxSessionBytes` bounds the *file*, not a line within
+ * it. A hostile 256 MiB session with no newline in it is one record, and buffering it would cost
+ * the raw bytes, a concatenated copy, a UTF-16 string for JSON.parse, and the parsed value — a
+ * multi-hundred-megabyte spike driven entirely by the attacker's choice of where to put newlines.
+ *
+ * Why this value: `maxReferencedBlobBytes` is the issue's own answer to "how large may one
+ * addressable unit of session content be". OMP externalizes anything bigger than a message to the
+ * shared CAS store (blob-store.ts) and leaves only a 76-byte `blob:sha256:<hex>` reference in the
+ * record, so a legitimate record is orders of magnitude smaller than this; the bound exists to cap
+ * the pathological case, not to constrain real transcripts.
+ *
+ * Remaining allocation, exactly: verification buffers at most MAX_SESSION_RECORD_BYTES of raw
+ * record bytes, and `JSON.parse` necessarily materializes that record as one UTF-16 string plus its
+ * parsed value. Peak per-record cost is therefore O(MAX_SESSION_RECORD_BYTES) and independent of
+ * `maxSessionBytes`, the record count, and the file's newline placement. Nothing else in the
+ * verifier accumulates session, artifact, or blob bytes.
+ */
+const MAX_SESSION_RECORD_BYTES = OMP_SESSION_LIMITS.maxReferencedBlobBytes;
+
+module.exports = { OMP_SESSION_LIMITS, MAX_SESSION_RECORD_BYTES };

package/src/omp-session-partition.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { randomUUID } = require('crypto');
+const { createHash, randomUUID } = require('crypto');
 const { isInsideOmpBlobsDir } = require('./omp-blob-root');
 
 // Every OMP session partition lives under <storageRoot>/omp-sessions/<uuid>/. storageRoot is the
@@ -83,16 +83,34 @@ function currentUid() {
   return typeof process.getuid === 'function' ? String(process.getuid()) : '0';
 }
 
+function stagingPathForOwnership(root, ownership) {
+  const owner = ownership.owner ?? {};
+  const persistedOwnerIdentity = JSON.stringify([
+    ownership.partitionId,
+    ownership.ownerUid ?? null,
+    ownership.storageRootIdentity?.device ?? null,
+    ownership.storageRootIdentity?.inode ?? null,
+    ownership.partitionIdentity?.device ?? null,
+    ownership.partitionIdentity?.inode ?? null,
+    owner.kind ?? null,
+    owner.clusterId ?? null,
+    owner.agentId ?? null,
+    owner.taskId ?? null,
+  ]);
+  const digest = createHash('sha256').update(persistedOwnerIdentity).digest('hex');
+  return path.join(root, `${DELETING_PREFIX}${ownership.partitionId}-${digest}`);
+}
+
 /**
  * Phase 1 of deletion: validate the owner record against what is actually on disk and move the
  * partition out of its canonical name.
  *
  * The check/use race (CodeQL js/file-system-race) is closed by *moving before deleting*: the
- * partition is renamed, within its own parent, to an unguessable `.zeroshot-deleting-<uuid>` name
- * and only then re-pinned. `rename(2)` is atomic, so after it succeeds the object under that fresh
- * name can no longer be swapped by racing the original path; the post-rename identity comparison
- * proves it is still the same directory that passed validation, and any mismatch aborts with the
- * directory parked under its clearly-marked name rather than recursively deleting an unknown tree.
+ * partition is renamed, within its own parent, to a deterministic staging name bound to its
+ * partition id and exact persisted owner identity, and only then re-pinned. A retry can therefore
+ * recover the staged directory after a crash or failed recursive removal. `rename(2)` is atomic,
+ * and the post-rename identity comparison proves it is still the same directory that passed
+ * validation. A canonical/staged conflict or identity mismatch leaves both names untouched.
  *
  * Splitting the rename from the recursive removal is what lets a caller hold a *task-store* write
  * fence across "no other row claims this partition" -> "the partition no longer answers to its
@@ -178,28 +196,100 @@ function stageOmpSessionPartitionForDeletion(ownership) {
     };
   }
   if (String(storagePin.uid) !== currentUid()) {
-    return { staged: false, deleted: false, reason: `${storageRoot} is not owned by the current user` };
+    return {
+      staged: false,
+      deleted: false,
+      reason: `${storageRoot} is not owned by the current user`,
+    };
+  }
+
+  let stagingPath;
+  try {
+    stagingPath = stagingPathForOwnership(root, ownership);
+  } catch (error) {
+    return {
+      staged: false,
+      deleted: false,
+      reason: `could not derive a staging name from the persisted owner identity: ${error.message}`,
+    };
   }
 
   let before;
   try {
     before = pinDirectoryIdentity(expectedPartitionPath);
   } catch (error) {
-    if (error.code === 'ENOENT') return { staged: false, deleted: true, reason: 'already absent' };
-    if (error.code === 'ELOOP' || error.code === 'EMLINK') {
-      return { staged: false, deleted: false, reason: `${expectedPartitionPath} is a symlink; refusing to delete` };
+    if (error.code !== 'ENOENT') {
+      if (error.code === 'ELOOP' || error.code === 'EMLINK') {
+        return {
+          staged: false,
+          deleted: false,
+          reason: `${expectedPartitionPath} is a symlink; refusing to delete`,
+        };
+      }
+      if (error.code === 'ENOTDIR') {
+        return {
+          staged: false,
+          deleted: false,
+          reason: `${expectedPartitionPath} is not a real directory; refusing to delete`,
+        };
+      }
+      return { staged: false, deleted: false, reason: error.message };
     }
-    if (error.code === 'ENOTDIR') {
+
+    let recovered;
+    try {
+      recovered = pinDirectoryIdentity(stagingPath);
+    } catch (stagedError) {
+      if (stagedError.code === 'ENOENT') {
+        return { staged: false, deleted: true, reason: 'already absent' };
+      }
       return {
         staged: false,
         deleted: false,
-        reason: `${expectedPartitionPath} is not a real directory; refusing to delete`,
+        reason: `canonical partition is absent, but staged ${stagingPath} is unsafe: ${stagedError.message}`,
+      };
+    }
+    if (String(recovered.uid) !== currentUid()) {
+      return {
+        staged: false,
+        deleted: false,
+        reason: `staged ${stagingPath} is not owned by the current user`,
+      };
+    }
+    if (
+      ownership.partitionIdentity &&
+      !sameIdentity(recovered.identity, ownership.partitionIdentity)
+    ) {
+      return {
+        staged: false,
+        deleted: false,
+        reason: `staged ${stagingPath} identity ${recovered.identity.device}:${recovered.identity.inode} does not match the recorded ${ownership.partitionIdentity.device}:${ownership.partitionIdentity.inode}`,
+      };
+    }
+    return { staged: true, stagingPath };
+  }
+  try {
+    pinDirectoryIdentity(stagingPath);
+    return {
+      staged: false,
+      deleted: false,
+      reason: `both canonical ${expectedPartitionPath} and staged ${stagingPath} exist; refusing to choose one`,
+    };
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      return {
+        staged: false,
+        deleted: false,
+        reason: `staging conflict at ${stagingPath}: ${error.message}`,
       };
     }
-    return { staged: false, deleted: false, reason: error.message };
   }
   if (String(before.uid) !== currentUid()) {
-    return { staged: false, deleted: false, reason: `${expectedPartitionPath} is not owned by the current user` };
+    return {
+      staged: false,
+      deleted: false,
+      reason: `${expectedPartitionPath} is not owned by the current user`,
+    };
   }
   if (ownership.partitionIdentity && !sameIdentity(before.identity, ownership.partitionIdentity)) {
     return {
@@ -209,12 +299,14 @@ function stageOmpSessionPartitionForDeletion(ownership) {
     };
   }
 
-  const stagingPath = path.join(root, `${DELETING_PREFIX}${randomUUID()}`);
   try {
     fs.renameSync(expectedPartitionPath, stagingPath);
   } catch (error) {
-    if (error.code === 'ENOENT') return { staged: false, deleted: true, reason: 'already absent' };
-    return { staged: false, deleted: false, reason: `could not stage ${expectedPartitionPath}: ${error.message}` };
+    return {
+      staged: false,
+      deleted: false,
+      reason: `could not stage ${expectedPartitionPath}: ${error.message}`,
+    };
   }
 
   let after;
@@ -224,7 +316,7 @@ function stageOmpSessionPartitionForDeletion(ownership) {
     return {
       staged: false,
       deleted: false,
-      reason: `staged ${stagingPath} could not be pinned (${error.message}); left in place for inspection`,
+      reason: `staged ${stagingPath} could not be pinned (${error.message}); left in place for retry or inspection`,
     };
   }
   if (!sameIdentity(after.identity, before.identity)) {
@@ -239,26 +331,61 @@ function stageOmpSessionPartitionForDeletion(ownership) {
 }
 
 /**
- * Phase 2: remove a directory that {@link stageOmpSessionPartitionForDeletion} already parked under
- * its unguessable staging name. Safe to run outside any lock — the tree no longer answers to a name
- * anything else knows.
+ * Phase 2: remove a directory that {@link stageOmpSessionPartitionForDeletion} parked under its
+ * deterministic, owner-bound staging name. Safe to run outside the task-store lock after
+ * revalidating that exact staged name and its persisted partition identity.
  */
-function removeStagedOmpSessionPartition(stagingPath) {
-  // This is an exported recursive delete, so it re-derives that its argument really is a staging
-  // name this module minted — a direct `.zeroshot-deleting-*` child of an `omp-sessions/` root —
-  // rather than trusting the caller to have got it from stageOmpSessionPartitionForDeletion.
-  if (typeof stagingPath !== 'string' || !path.isAbsolute(stagingPath)) {
-    return { deleted: false, reason: `${stagingPath} is not an absolute staged partition path` };
+function removeStagedOmpSessionPartition(stagingPath, ownership) {
+  if (!ownership || typeof ownership !== 'object') {
+    return { deleted: false, reason: 'no ownership record for staged partition removal' };
   }
-  if (!path.basename(stagingPath).startsWith(DELETING_PREFIX)) {
-    return { deleted: false, reason: `${stagingPath} is not a staged partition directory` };
+
+  let expectedPartitionPath;
+  try {
+    expectedPartitionPath = partitionPathFor(ownership.storageRoot, ownership.partitionId);
+  } catch (error) {
+    return { deleted: false, reason: error.message };
   }
-  if (path.basename(path.dirname(stagingPath)) !== OMP_SESSIONS_SUBDIR) {
+  if (expectedPartitionPath !== ownership.partitionPath) {
     return {
       deleted: false,
-      reason: `${stagingPath} does not live directly under an ${OMP_SESSIONS_SUBDIR}/ root`,
+      reason: `${ownership.partitionPath} is not the canonical partition path for ${ownership.partitionId}`,
     };
   }
+  const root = ompSessionsRoot(ownership.storageRoot);
+  let expectedStagingPath;
+  try {
+    expectedStagingPath = stagingPathForOwnership(root, ownership);
+  } catch (error) {
+    return {
+      deleted: false,
+      reason: `could not derive a staging name from the persisted owner identity: ${error.message}`,
+    };
+  }
+  if (stagingPath !== expectedStagingPath) {
+    return {
+      deleted: false,
+      reason: `${stagingPath} is not the staged path bound to partition ${ownership.partitionId} and its persisted owner identity`,
+    };
+  }
+
+  let staged;
+  try {
+    staged = pinDirectoryIdentity(stagingPath);
+  } catch (error) {
+    if (error.code === 'ENOENT') return { deleted: true, reason: 'already absent' };
+    return { deleted: false, reason: `${stagingPath}: ${error.message}` };
+  }
+  if (String(staged.uid) !== currentUid()) {
+    return { deleted: false, reason: `${stagingPath} is not owned by the current user` };
+  }
+  if (ownership.partitionIdentity && !sameIdentity(staged.identity, ownership.partitionIdentity)) {
+    return {
+      deleted: false,
+      reason: `${stagingPath} identity ${staged.identity.device}:${staged.identity.inode} does not match the recorded ${ownership.partitionIdentity.device}:${ownership.partitionIdentity.inode}`,
+    };
+  }
+
   try {
     fs.rmSync(stagingPath, { recursive: true, force: true });
   } catch (error) {
@@ -279,7 +406,7 @@ function removeStagedOmpSessionPartition(stagingPath) {
 function deleteOmpSessionPartition(ownership) {
   const staged = stageOmpSessionPartitionForDeletion(ownership);
   if (!staged.staged) return { deleted: staged.deleted === true, reason: staged.reason };
-  return removeStagedOmpSessionPartition(staged.stagingPath);
+  return removeStagedOmpSessionPartition(staged.stagingPath, ownership);
 }
 
 module.exports = {