@fro.bot/systematic 3.5.5 → 3.5.6

package/dist/index.js

@@ -19,8 +19,8 @@ import {
 
 // src/index.ts
 import { createHash as createHash5 } from "crypto";
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL3 } from "url";
 
 // src/lib/bootstrap.ts
@@ -1333,10 +1333,20 @@ function digest(domain, facts) {
 function isCommandTimeout(error) {
   return error !== null && typeof error === "object" && "code" in error && error.code === "ETIMEDOUT";
 }
+function sanitizedEnvironment() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("GIT_")) {
+      delete env[key];
+    }
+  }
+  return env;
+}
 function defaultCommandRunner(args2, cwd, maxOutputBytes, timeoutMs) {
   try {
     const result = spawnSync("git", [...args2], {
       cwd,
+      env: sanitizedEnvironment(),
       encoding: "utf8",
       maxBuffer: maxOutputBytes,
       timeout: timeoutMs
@@ -1355,6 +1365,7 @@ function defaultRemoteCommandRunner(executable, args2, cwd, maxOutputBytes, time
   try {
     const result = spawnSync(executable, [...args2], {
       cwd,
+      env: sanitizedEnvironment(),
       encoding: "utf8",
       maxBuffer: maxOutputBytes,
       timeout: timeoutMs
@@ -1429,6 +1440,140 @@ function runCommand(runner, args2, cwd, limits) {
   }
   return { status: "ok", output: { stdout: result.stdout } };
 }
+function canonicalPath(filePath, realPath = fs8.realpathSync) {
+  try {
+    return realPath(filePath);
+  } catch {
+    return;
+  }
+}
+function requiredGitPath(runner, args2, cwd, limits, realPath = fs8.realpathSync) {
+  const result = runCommand(runner, args2, cwd, limits);
+  if (result.status === "error")
+    return result;
+  const rawValue = result.output.stdout.trim();
+  if (!path8.isAbsolute(rawValue)) {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  const value = canonicalPath(rawValue, realPath);
+  return value === undefined ? { status: "error", reasonCode: "target-unavailable" } : { status: "ok", value };
+}
+function captureParentIdentity(targetDirectory, runner, limits, realPath = fs8.realpathSync) {
+  const targetRoot = requiredGitPath(runner, ["rev-parse", "--show-toplevel"], targetDirectory, limits, realPath);
+  if (targetRoot.status === "error")
+    return targetRoot;
+  const gitDir = requiredGitPath(runner, ["rev-parse", "--absolute-git-dir"], targetDirectory, limits, realPath);
+  if (gitDir.status === "error")
+    return gitDir;
+  const commonDir = requiredGitPath(runner, ["rev-parse", "--path-format=absolute", "--git-common-dir"], targetDirectory, limits, realPath);
+  if (commonDir.status === "error")
+    return commonDir;
+  const worktreeList = runCommand(runner, ["worktree", "list", "--porcelain", "-z"], targetDirectory, limits);
+  if (worktreeList.status === "error")
+    return worktreeList;
+  const registeredWorktreeRoots = worktreeList.output.stdout.split("\x00").filter((record) => record.startsWith("worktree ")).map((record) => canonicalPath(record.slice("worktree ".length), realPath));
+  if (registeredWorktreeRoots.some((root) => root === undefined)) {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  const roots = registeredWorktreeRoots.filter((root) => root !== undefined);
+  return roots.length > 0 ? {
+    status: "ok",
+    identity: {
+      targetRoot: targetRoot.value,
+      gitDir: gitDir.value,
+      commonDir: commonDir.value,
+      registeredWorktreeRoots: roots
+    }
+  } : { status: "error", reasonCode: "target-unavailable" };
+}
+function readGitfileTarget(gitfilePath, realPath = fs8.realpathSync) {
+  let contents;
+  try {
+    contents = fs8.readFileSync(gitfilePath, "utf8");
+  } catch {
+    return;
+  }
+  const match = /^gitdir:\s*(.+?)\s*$/im.exec(contents);
+  if (!match)
+    return;
+  const target = path8.isAbsolute(match[1]) ? match[1] : path8.resolve(path8.dirname(gitfilePath), match[1]);
+  return canonicalPath(target, realPath);
+}
+function readGitdirBacklink(backlinkPath, realPath) {
+  let contents;
+  try {
+    contents = fs8.readFileSync(backlinkPath, "utf8").trim();
+  } catch {
+    return;
+  }
+  if (contents.length === 0)
+    return;
+  const target = path8.isAbsolute(contents) ? contents : path8.resolve(path8.dirname(backlinkPath), contents);
+  return canonicalPath(target, realPath);
+}
+function isPathWithin(root, candidate) {
+  const relative = path8.relative(root, candidate);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path8.sep}`) && !path8.isAbsolute(relative);
+}
+function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
+  const dotGit = path8.join(targetRoot, ".git");
+  let dotGitStat;
+  try {
+    dotGitStat = fs8.lstatSync(dotGit);
+  } catch {
+    return false;
+  }
+  if (dotGitStat.isDirectory()) {
+    return gitDir === commonDir && canonicalPath(dotGit, realPath) === commonDir;
+  }
+  if (!dotGitStat.isFile() || dotGitStat.isSymbolicLink() || !isPathWithin(path8.join(commonDir, "worktrees"), gitDir) || readGitfileTarget(dotGit, realPath) !== gitDir) {
+    return false;
+  }
+  const backlinkPath = path8.join(gitDir, "gitdir");
+  let backlinkStat;
+  try {
+    backlinkStat = fs8.lstatSync(backlinkPath);
+  } catch {
+    return false;
+  }
+  return backlinkStat.isFile() && !backlinkStat.isSymbolicLink() && readGitdirBacklink(backlinkPath, realPath) === canonicalPath(dotGit, realPath);
+}
+function validateRegisteredWorktree(candidateDirectory, parentIdentity, options = {}) {
+  const runner = options.commandRunner ?? defaultCommandRunner;
+  const limits = mergeLimits(options.limits);
+  const realPath = options.realPath ?? fs8.realpathSync;
+  const candidateRoot = canonicalPath(candidateDirectory, realPath);
+  if (candidateRoot === undefined) {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  const inside = runCommand(runner, ["rev-parse", "--is-inside-work-tree"], candidateRoot, limits);
+  if (inside.status === "error")
+    return inside;
+  if (inside.output.stdout.trim() !== "true") {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  const targetRoot = requiredGitPath(runner, ["rev-parse", "--show-toplevel"], candidateRoot, limits, realPath);
+  if (targetRoot.status === "error")
+    return targetRoot;
+  const gitDir = requiredGitPath(runner, ["rev-parse", "--absolute-git-dir"], candidateRoot, limits, realPath);
+  if (gitDir.status === "error")
+    return gitDir;
+  const commonDir = requiredGitPath(runner, ["rev-parse", "--path-format=absolute", "--git-common-dir"], candidateRoot, limits, realPath);
+  if (commonDir.status === "error")
+    return commonDir;
+  if (commonDir.value !== parentIdentity.commonDir || !parentIdentity.registeredWorktreeRoots.includes(targetRoot.value)) {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  if (!validateDotGitLinkage(targetRoot.value, gitDir.value, commonDir.value, realPath)) {
+    return { status: "error", reasonCode: "target-unavailable" };
+  }
+  return {
+    status: "ok",
+    targetRoot: targetRoot.value,
+    gitDir: gitDir.value,
+    commonDir: commonDir.value
+  };
+}
 function readRevision(runner, context, limits) {
   const branch = runCommand(runner, ["symbolic-ref", "--short", "HEAD"], context.commandDirectory, limits);
   if (branch.status === "error" && branch.reasonCode !== "command-failed") {
@@ -1785,9 +1930,11 @@ function createOpencodeOperationObserver(options) {
   } catch {
     targetDirectory = path8.resolve(options.targetDirectory);
   }
-  const targetDigest = digest("target", [targetDirectory]);
   const runner = options.commandRunner ?? defaultCommandRunner;
   const remoteRunner = options.remoteCommandRunner ?? defaultRemoteCommandRunner;
+  const realPath = options.realPath ?? fs8.realpathSync;
+  const parentIdentityResult = captureParentIdentity(targetDirectory, runner, limits, realPath);
+  const targetDigest = digest("target", [targetDirectory]);
   const fileReader = options.fileReader ?? fs8.readFileSync;
   const symlinkReader = options.symlinkReader ?? fs8.readlinkSync;
   const statReader = options.statReader ?? ((filePath) => {
@@ -1802,6 +1949,11 @@ function createOpencodeOperationObserver(options) {
   });
   return {
     targetDigest,
+    validateRegisteredWorktree(candidateDirectory) {
+      if (parentIdentityResult.status === "error")
+        return parentIdentityResult;
+      return validateRegisteredWorktree(candidateDirectory, parentIdentityResult.identity, { commandRunner: runner, limits, realPath });
+    },
     async snapshot() {
       const rootResult = runCommand(runner, ["rev-parse", "--show-toplevel"], targetDirectory, limits);
       if (rootResult.status === "error")
@@ -1849,6 +2001,8 @@ function createOpencodeOperationObserver(options) {
 
 // src/lib/opencode-workflow-guard.ts
 import { randomBytes as randomBytes4 } from "crypto";
+import fs10 from "fs";
+import path9 from "path";
 
 // src/lib/question-attestation.ts
 import { createHash as createHash3, randomBytes } from "crypto";
@@ -2369,8 +2523,10 @@ import { randomBytes as randomBytes2 } from "crypto";
 
 // src/lib/receipt-readback.ts
 import { createHash as createHash4 } from "crypto";
-var RECEIPT_READBACK_SCHEMA_VERSION = 1;
-var RECEIPT_READBACK_PROTOCOL_VERSION = 1;
+var RECEIPT_READBACK_SCHEMA_VERSION = 2;
+var RECEIPT_READBACK_PROTOCOL_VERSION = 2;
+var LEGACY_RECEIPT_READBACK_SCHEMA_VERSION = 1;
+var LEGACY_RECEIPT_READBACK_PROTOCOL_VERSION = 1;
 var MAX_CAPABILITIES = 16;
 var MAX_CAPABILITY_LENGTH = 128;
 var MAX_MARKERS = 128;
@@ -2412,6 +2568,12 @@ var CANONICAL_REQUIRED_KEYS = [
   "timestamp"
 ];
 var CANONICAL_OPTIONAL_KEYS = [
+  "repositoryDigest",
+  "worktreeDigest",
+  "operationTargetIdentity",
+  "resourceDigest"
+];
+var LEGACY_CANONICAL_OPTIONAL_KEYS = [
   "repositoryDigest",
   "worktreeDigest",
   "resourceDigest"
@@ -2465,12 +2627,14 @@ var UNIT_PROGRESSION_KEYS = [
   "family",
   "requiredOperations",
   "resourceScopes",
+  "pinnedOperationTargetIdentity",
   "state",
   "transitionDigest",
   "timestamp",
   "sessionSalt",
   "integrity"
 ];
+var LEGACY_UNIT_PROGRESSION_KEYS = UNIT_PROGRESSION_KEYS.filter((key) => key !== "pinnedOperationTargetIdentity");
 var RESOURCE_SCOPE_KEYS = ["operation", "resourceIdentity"];
 var LEDGER_METADATA_KEYS = [
   "schemaVersion",
@@ -2489,6 +2653,12 @@ function hasExactKeys(value, required, optional = []) {
   const keys = Object.keys(value);
   return required.every((key) => Object.hasOwn(value, key)) && keys.every((key) => allowed.has(key));
 }
+function isCurrentVersionPair(schemaVersion, protocolVersion) {
+  return schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION && protocolVersion === RECEIPT_READBACK_PROTOCOL_VERSION;
+}
+function isLegacyVersionPair(schemaVersion, protocolVersion) {
+  return schemaVersion === LEGACY_RECEIPT_READBACK_SCHEMA_VERSION && protocolVersion === LEGACY_RECEIPT_READBACK_PROTOCOL_VERSION;
+}
 function isDigest(value) {
   return typeof value === "string" && DIGEST_PATTERN.test(value);
 }
@@ -2589,6 +2759,7 @@ function cloneCanonical(canonical) {
     workspaceDigest: canonical.workspaceDigest,
     repositoryDigest: canonical.repositoryDigest,
     worktreeDigest: canonical.worktreeDigest,
+    ...isLocalOperation(canonical.operation) ? { operationTargetIdentity: canonical.operationTargetIdentity } : {},
     resourceDigest: canonical.resourceDigest,
     operation: canonical.operation,
     result: "success",
@@ -2610,16 +2781,19 @@ function cloneEnvelope(envelope) {
 function parseEnvelope(value) {
   if (!isRecord3(value) || !hasExactKeys(value, ENVELOPE_KEYS))
     return;
-  if (value.schemaVersion !== 1 || value.protocolVersion !== 1 || value.compatibility !== "compatible" || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags) || !isRecord3(value.canonical)) {
+  const currentVersion = isCurrentVersionPair(value.schemaVersion, value.protocolVersion);
+  const legacyVersion = isLegacyVersionPair(value.schemaVersion, value.protocolVersion);
+  if (!currentVersion && !legacyVersion || value.compatibility !== "compatible" || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags) || !isRecord3(value.canonical)) {
     return;
   }
   const canonical = value.canonical;
-  if (!hasExactKeys(canonical, CANONICAL_REQUIRED_KEYS, CANONICAL_OPTIONAL_KEYS) || !isReceiptId(canonical.receiptId) || !isDigest(canonical.registrationDigest) || !isDigest(canonical.callDigest) || !isDigest(canonical.epochDigest) || !isDigest(canonical.unitDigest) || !isDigest(canonical.workspaceDigest) || canonical.repositoryDigest !== undefined && !isDigest(canonical.repositoryDigest) || canonical.worktreeDigest !== undefined && !isDigest(canonical.worktreeDigest) || canonical.resourceDigest !== undefined && !isDigest(canonical.resourceDigest) || !isOperation(canonical.operation) || canonical.result !== "success" || canonical.source !== "runtime-verified" || canonical.consumption !== "available" && canonical.consumption !== "consumed" || !isTimestamp(canonical.timestamp) || canonical.registrationDigest !== value.registrationDigest) {
+  const operation = isOperation(canonical.operation) ? canonical.operation : undefined;
+  if (!hasExactKeys(canonical, CANONICAL_REQUIRED_KEYS, currentVersion ? CANONICAL_OPTIONAL_KEYS : LEGACY_CANONICAL_OPTIONAL_KEYS) || !isReceiptId(canonical.receiptId) || !isDigest(canonical.registrationDigest) || !isDigest(canonical.callDigest) || !isDigest(canonical.epochDigest) || !isDigest(canonical.unitDigest) || !isDigest(canonical.workspaceDigest) || canonical.repositoryDigest !== undefined && !isDigest(canonical.repositoryDigest) || canonical.worktreeDigest !== undefined && !isDigest(canonical.worktreeDigest) || canonical.operationTargetIdentity !== undefined && !isDigest(canonical.operationTargetIdentity) || operation === undefined || currentVersion && isLocalOperation(operation) && !isDigest(canonical.operationTargetIdentity) || currentVersion && !isLocalOperation(operation) && Object.hasOwn(canonical, "operationTargetIdentity") || legacyVersion && Object.hasOwn(canonical, "operationTargetIdentity") || canonical.resourceDigest !== undefined && !isDigest(canonical.resourceDigest) || canonical.result !== "success" || canonical.source !== "runtime-verified" || canonical.consumption !== "available" && canonical.consumption !== "consumed" || !isTimestamp(canonical.timestamp) || canonical.registrationDigest !== value.registrationDigest) {
     return;
   }
   return {
-    schemaVersion: 1,
-    protocolVersion: 1,
+    schemaVersion: currentVersion ? RECEIPT_READBACK_SCHEMA_VERSION : LEGACY_RECEIPT_READBACK_SCHEMA_VERSION,
+    protocolVersion: currentVersion ? RECEIPT_READBACK_PROTOCOL_VERSION : LEGACY_RECEIPT_READBACK_PROTOCOL_VERSION,
     registrationDigest: value.registrationDigest,
     capabilityFlags: [...value.capabilityFlags],
     compatibility: "compatible",
@@ -2632,8 +2806,9 @@ function parseEnvelope(value) {
       workspaceDigest: canonical.workspaceDigest,
       repositoryDigest: canonical.repositoryDigest,
       worktreeDigest: canonical.worktreeDigest,
+      ...isLocalOperation(operation) ? { operationTargetIdentity: canonical.operationTargetIdentity } : {},
       resourceDigest: canonical.resourceDigest,
-      operation: canonical.operation,
+      operation,
       result: "success",
       source: "runtime-verified",
       consumption: canonical.consumption,
@@ -2642,40 +2817,42 @@ function parseEnvelope(value) {
   };
 }
 function parseLedgerMetadata(value) {
-  if (!isRecord3(value) || !hasExactKeys(value, LEDGER_METADATA_KEYS) || value.schemaVersion !== 1 || value.protocolVersion !== 1 || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags)) {
+  if (!isRecord3(value) || !hasExactKeys(value, LEDGER_METADATA_KEYS) || value.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION || value.protocolVersion !== RECEIPT_READBACK_PROTOCOL_VERSION || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags)) {
     return;
   }
   return {
-    schemaVersion: 1,
-    protocolVersion: 1,
+    schemaVersion: RECEIPT_READBACK_SCHEMA_VERSION,
+    protocolVersion: RECEIPT_READBACK_PROTOCOL_VERSION,
     registrationDigest: value.registrationDigest,
     capabilityFlags: [...value.capabilityFlags]
   };
 }
 function serializeEnvelope(envelope) {
   const canonical = envelope.canonical;
+  const canonicalFields = {
+    receiptId: canonical.receiptId,
+    registrationDigest: canonical.registrationDigest,
+    callDigest: canonical.callDigest,
+    epochDigest: canonical.epochDigest,
+    unitDigest: canonical.unitDigest,
+    workspaceDigest: canonical.workspaceDigest,
+    repositoryDigest: canonical.repositoryDigest ?? null,
+    worktreeDigest: canonical.worktreeDigest ?? null,
+    ...envelope.schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION ? { operationTargetIdentity: canonical.operationTargetIdentity ?? null } : {},
+    resourceDigest: canonical.resourceDigest ?? null,
+    operation: canonical.operation,
+    result: canonical.result,
+    source: canonical.source,
+    consumption: canonical.consumption,
+    timestamp: canonical.timestamp
+  };
   return JSON.stringify({
     schemaVersion: envelope.schemaVersion,
     protocolVersion: envelope.protocolVersion,
     registrationDigest: envelope.registrationDigest,
     capabilityFlags: [...envelope.capabilityFlags],
     compatibility: envelope.compatibility,
-    canonical: {
-      receiptId: canonical.receiptId,
-      registrationDigest: canonical.registrationDigest,
-      callDigest: canonical.callDigest,
-      epochDigest: canonical.epochDigest,
-      unitDigest: canonical.unitDigest,
-      workspaceDigest: canonical.workspaceDigest,
-      repositoryDigest: canonical.repositoryDigest ?? null,
-      worktreeDigest: canonical.worktreeDigest ?? null,
-      resourceDigest: canonical.resourceDigest ?? null,
-      operation: canonical.operation,
-      result: canonical.result,
-      source: canonical.source,
-      consumption: canonical.consumption,
-      timestamp: canonical.timestamp
-    }
+    canonical: canonicalFields
   });
 }
 function hashIntegrity(scope, value) {
@@ -2711,7 +2888,10 @@ function progressionIntegrity(marker) {
     unitDigest: marker.unitDigest,
     family: marker.family,
     requiredOperations: [...marker.requiredOperations],
-    resourceScopes: marker.resourceScopes.map((scope) => ({ ...scope }))
+    resourceScopes: marker.resourceScopes.map((scope) => ({ ...scope })),
+    ...marker.schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION ? {
+      pinnedOperationTargetIdentity: marker.pinnedOperationTargetIdentity ?? null
+    } : {}
   };
   return hashIntegrity("progression", JSON.stringify({
     kind: marker.kind,
@@ -2737,15 +2917,21 @@ function parseMintMarker(value) {
   if (value.kind !== "mint") {
     return markerResult(value.kind === "control" ? "unknown-kind" : "unknown-kind");
   }
-  if (value.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION)
-    return markerResult("unknown-schema");
-  if (value.protocolVersion !== RECEIPT_READBACK_PROTOCOL_VERSION)
+  const currentVersion = isCurrentVersionPair(value.schemaVersion, value.protocolVersion);
+  const legacyVersion = isLegacyVersionPair(value.schemaVersion, value.protocolVersion);
+  if (!currentVersion && !legacyVersion) {
+    if (value.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION && value.schemaVersion !== LEGACY_RECEIPT_READBACK_SCHEMA_VERSION)
+      return markerResult("unknown-schema");
     return markerResult("unknown-protocol");
+  }
   if (!hasExactKeys(value, MINT_KEYS))
     return markerResult("forbidden-field");
   const envelope = parseEnvelope(value.envelope);
   if (!envelope)
     return markerResult("malformed");
+  if (currentVersion && envelope.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION || legacyVersion && envelope.schemaVersion !== 1) {
+    return markerResult("malformed");
+  }
   if (!isSessionSaltHex(value.sessionSalt))
     return markerResult("malformed");
   if (!isDigest(value.integrity))
@@ -2754,8 +2940,8 @@ function parseMintMarker(value) {
     return markerResult("malformed");
   const marker = {
     kind: "mint",
-    schemaVersion: RECEIPT_READBACK_SCHEMA_VERSION,
-    protocolVersion: RECEIPT_READBACK_PROTOCOL_VERSION,
+    schemaVersion: value.schemaVersion,
+    protocolVersion: value.protocolVersion,
     envelope,
     sessionSalt: value.sessionSalt,
     integrity: value.integrity
@@ -2767,13 +2953,15 @@ function parseMintMarker(value) {
 function parseConsumeMarker(value) {
   if (!hasExactKeys(value, CONSUME_KEYS))
     return markerResult("forbidden-field");
-  if (value.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION || value.protocolVersion !== RECEIPT_READBACK_PROTOCOL_VERSION || value.kind !== "control" || value.control !== "consume" || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags) || !isReceiptId(value.receiptId) || !isDigest(value.transitionDigest) || !isTimestamp(value.timestamp) || !isDigest(value.integrity)) {
+  const currentVersion = isCurrentVersionPair(value.schemaVersion, value.protocolVersion);
+  const legacyVersion = isLegacyVersionPair(value.schemaVersion, value.protocolVersion);
+  if (!currentVersion && !legacyVersion || value.kind !== "control" || value.control !== "consume" || !isDigest(value.registrationDigest) || !isCapabilityList(value.capabilityFlags) || !isReceiptId(value.receiptId) || !isDigest(value.transitionDigest) || !isTimestamp(value.timestamp) || !isDigest(value.integrity)) {
     return markerResult("malformed");
   }
   const marker = {
     kind: "control",
-    schemaVersion: RECEIPT_READBACK_SCHEMA_VERSION,
-    protocolVersion: RECEIPT_READBACK_PROTOCOL_VERSION,
+    schemaVersion: value.schemaVersion,
+    protocolVersion: value.protocolVersion,
     registrationDigest: value.registrationDigest,
     capabilityFlags: [...value.capabilityFlags],
     control: "consume",
@@ -2794,8 +2982,10 @@ function parseProgressionMarker(value) {
   return markerResult("unknown-kind");
 }
 function parseProgressionBase(value) {
-  if (value.schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION && value.protocolVersion === RECEIPT_READBACK_PROTOCOL_VERSION && value.kind === "control" && value.control === "progression" && isDigest(value.registrationDigest) && isCapabilityList(value.capabilityFlags) && (value.state === "started" || value.state === "completed") && isDigest(value.transitionDigest) && isTimestamp(value.timestamp) && isSessionSaltHex(value.sessionSalt) && isDigest(value.integrity)) {
+  if ((isCurrentVersionPair(value.schemaVersion, value.protocolVersion) || isLegacyVersionPair(value.schemaVersion, value.protocolVersion)) && value.kind === "control" && value.control === "progression" && isDigest(value.registrationDigest) && isCapabilityList(value.capabilityFlags) && (value.state === "started" || value.state === "completed") && isDigest(value.transitionDigest) && isTimestamp(value.timestamp) && isSessionSaltHex(value.sessionSalt) && isDigest(value.integrity)) {
     return {
+      schemaVersion: value.schemaVersion,
+      protocolVersion: value.protocolVersion,
       registrationDigest: value.registrationDigest,
       capabilityFlags: [...value.capabilityFlags],
       state: value.state,
@@ -2817,8 +3007,8 @@ function parseEpochProgressionMarker(value) {
   }
   const marker = {
     kind: "control",
-    schemaVersion: RECEIPT_READBACK_SCHEMA_VERSION,
-    protocolVersion: RECEIPT_READBACK_PROTOCOL_VERSION,
+    schemaVersion: base.schemaVersion,
+    protocolVersion: base.protocolVersion,
     registrationDigest: base.registrationDigest,
     capabilityFlags: [...base.capabilityFlags],
     control: "progression",
@@ -2835,19 +3025,21 @@ function parseEpochProgressionMarker(value) {
   return progressionMarkerValidation(marker);
 }
 function parseUnitProgressionMarker(value) {
-  if (!hasExactKeys(value, UNIT_PROGRESSION_KEYS)) {
+  const currentVersion = isCurrentVersionPair(value.schemaVersion, value.protocolVersion);
+  if (!hasExactKeys(value, LEGACY_UNIT_PROGRESSION_KEYS, currentVersion ? ["pinnedOperationTargetIdentity"] : [])) {
     return Object.hasOwn(value, "epochId") && Object.hasOwn(value, "unitId") ? markerResult("forbidden-field") : markerResult("missing-internal-id");
   }
   const requiredOperations = canonicalRequiredOperations(value.requiredOperations);
   const resourceScopes = canonicalResourceScopes(value.resourceScopes);
+  const pinnedOperationTargetIdentity = value.pinnedOperationTargetIdentity === undefined ? undefined : isDigest(value.pinnedOperationTargetIdentity) ? value.pinnedOperationTargetIdentity : undefined;
   const base = parseProgressionBase(value);
-  if (!base || !isInternalId(value.epochId) || !isDigest(value.epochDigest) || !isInternalId(value.unitId) || !isDigest(value.unitDigest) || !isFamily(value.family) || !requiredOperations || !resourceScopes) {
+  if (!base || !isInternalId(value.epochId) || !isDigest(value.epochDigest) || !isInternalId(value.unitId) || !isDigest(value.unitDigest) || !isFamily(value.family) || !requiredOperations || !resourceScopes || value.pinnedOperationTargetIdentity !== undefined && pinnedOperationTargetIdentity === undefined) {
     return value.epochId === undefined || value.unitId === undefined ? markerResult("missing-internal-id") : markerResult("malformed");
   }
   const marker = {
     kind: "control",
-    schemaVersion: RECEIPT_READBACK_SCHEMA_VERSION,
-    protocolVersion: RECEIPT_READBACK_PROTOCOL_VERSION,
+    schemaVersion: base.schemaVersion,
+    protocolVersion: base.protocolVersion,
     registrationDigest: base.registrationDigest,
     capabilityFlags: [...base.capabilityFlags],
     control: "progression",
@@ -2859,6 +3051,7 @@ function parseUnitProgressionMarker(value) {
     family: value.family,
     requiredOperations: [...requiredOperations],
     resourceScopes: resourceScopes.map((scope) => ({ ...scope })),
+    ...pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity } : {},
     state: base.state,
     transitionDigest: base.transitionDigest,
     timestamp: base.timestamp,
@@ -2877,10 +3070,11 @@ function validateReceiptMarker(input) {
     return parseMintMarker(input);
   if (input.kind !== "control")
     return markerResult("unknown-kind");
-  if (input.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION)
-    return markerResult("unknown-schema");
-  if (input.protocolVersion !== RECEIPT_READBACK_PROTOCOL_VERSION)
+  if (!isCurrentVersionPair(input.schemaVersion, input.protocolVersion) && !isLegacyVersionPair(input.schemaVersion, input.protocolVersion)) {
+    if (input.schemaVersion !== RECEIPT_READBACK_SCHEMA_VERSION && input.schemaVersion !== LEGACY_RECEIPT_READBACK_SCHEMA_VERSION)
+      return markerResult("unknown-schema");
     return markerResult("unknown-protocol");
+  }
   if (input.control === "consume")
     return parseConsumeMarker(input);
   if (input.control === "progression")
@@ -3010,7 +3204,7 @@ function projectEpochMarker(source, input, context) {
   };
 }
 function projectUnitMarker(source, input, context) {
-  if (!isInternalId(input.epochId) || !isInternalId(input.unitId) || !isFamily(input.family) || normalizeRequiredOperations(input.requiredOperations) === undefined || normalizeResourceScopes(input.resourceScopes) === undefined) {
+  if (!isInternalId(input.epochId) || !isInternalId(input.unitId) || !isFamily(input.family) || normalizeRequiredOperations(input.requiredOperations) === undefined || normalizeResourceScopes(input.resourceScopes) === undefined || input.pinnedOperationTargetIdentity !== undefined && !isDigest(input.pinnedOperationTargetIdentity)) {
     return;
   }
   const requiredOperations = normalizeRequiredOperations(input.requiredOperations);
@@ -3032,6 +3226,7 @@ function projectUnitMarker(source, input, context) {
     family: input.family,
     requiredOperations: [...requiredOperations],
     resourceScopes: resourceScopes.map((scope) => ({ ...scope })),
+    ...input.pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity: input.pinnedOperationTargetIdentity } : {},
     state: input.state,
     transitionDigest: input.transitionDigest,
     timestamp: context.timestamp,
@@ -3107,6 +3302,7 @@ function cloneMarker(marker) {
     family: marker.family,
     requiredOperations: [...marker.requiredOperations],
     resourceScopes: marker.resourceScopes.map((scope) => ({ ...scope })),
+    ...marker.pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity: marker.pinnedOperationTargetIdentity } : {},
     state: marker.state,
     transitionDigest: marker.transitionDigest,
     timestamp: marker.timestamp,
@@ -3173,6 +3369,9 @@ function serializeMarker(marker) {
     family: marker.family,
     requiredOperations: [...marker.requiredOperations],
     resourceScopes: marker.resourceScopes.map((scope) => ({ ...scope })),
+    ...marker.schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION ? {
+      pinnedOperationTargetIdentity: marker.pinnedOperationTargetIdentity ?? null
+    } : {},
     state: marker.state,
     transitionDigest: marker.transitionDigest,
     timestamp: marker.timestamp,
@@ -3196,6 +3395,12 @@ function sameEnvelope(first, second) {
 function foldMintMarker(marker, context) {
   if (marker.sessionSalt !== context.expectedSalt)
     return "salt-mismatch";
+  if (marker.envelope.schemaVersion === 1 && context.expectation.operationTargetIdentity) {
+    return "identity-digest-mismatch";
+  }
+  if (marker.envelope.schemaVersion === RECEIPT_READBACK_SCHEMA_VERSION && context.expectation.operationTargetIdentity && marker.envelope.canonical.operationTargetIdentity !== context.expectation.operationTargetIdentity) {
+    return "identity-digest-mismatch";
+  }
   const registrationMatches = marker.envelope.registrationDigest === context.expectation.registrationDigest && marker.envelope.canonical.registrationDigest === context.expectation.registrationDigest;
   if (!registrationMatches)
     return "cross-registration";
@@ -3261,6 +3466,7 @@ function progressionSnapshot(marker) {
     family: marker.family,
     requiredOperations: [...marker.requiredOperations],
     resourceScopes: marker.resourceScopes.map((scope) => ({ ...scope })),
+    ...marker.pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity: marker.pinnedOperationTargetIdentity } : {},
     transitionDigest: marker.transitionDigest
   };
 }
@@ -3338,13 +3544,14 @@ function applyUnitStart(marker, epoch, context) {
     if (!sameUnitDeclaration(current, marker) && unitHasMintedEvidence(current, context)) {
       return "out-of-order";
     }
-    if (sameUnitDeclaration(current, marker) && current.transitionDigest !== marker.transitionDigest) {
+    if (sameUnitDeclaration(current, marker) && current.transitionDigest !== marker.transitionDigest && current.pinnedOperationTargetIdentity === marker.pinnedOperationTargetIdentity) {
       return "conflicting-marker";
     }
     if (!unitDeclarationExtends(current, marker))
       return "conflicting-marker";
-    if (sameUnitDeclaration(current, marker))
+    if (sameUnitDeclaration(current, marker) && current.pinnedOperationTargetIdentity === marker.pinnedOperationTargetIdentity) {
       return;
+    }
     context.progression = { epoch, unit: snapshot };
     return;
   }
@@ -3388,7 +3595,10 @@ function unitDeclarationExtends(current, marker) {
     scope.operation,
     scope.resourceIdentity
   ]));
-  return [...current.resourceScopes].every((scope) => nextScopes.get(scope.operation) === scope.resourceIdentity);
+  if (![...current.resourceScopes].every((scope) => nextScopes.get(scope.operation) === scope.resourceIdentity)) {
+    return false;
+  }
+  return current.pinnedOperationTargetIdentity === undefined || current.pinnedOperationTargetIdentity === marker.pinnedOperationTargetIdentity;
 }
 function foldProgressionMarker(marker, context) {
   return marker.target === "epoch" ? applyEpochProgression(marker, context) : applyUnitProgression(marker, context);
@@ -3455,18 +3665,21 @@ function foldReceiptReadback(inputs, expectation) {
     }
   };
 }
-function receiptReadbackExpectationFromMetadata(metadata2, sessionSalt) {
+function receiptReadbackExpectationFromMetadata(metadata2, sessionSalt, operationTargetIdentity) {
   return {
     registrationDigest: metadata2.registrationDigest,
     capabilityFlags: [...metadata2.capabilityFlags],
     sessionSalt: new Uint8Array(sessionSalt),
-    source: "runtime-verified"
+    source: "runtime-verified",
+    operationTargetIdentity
   };
 }
 
 // src/lib/receipt-ledger.ts
-var RECEIPT_SCHEMA_VERSION = 1;
-var RECEIPT_PROTOCOL_VERSION = 1;
+var RECEIPT_SCHEMA_VERSION = 2;
+var RECEIPT_PROTOCOL_VERSION = 2;
+var LEGACY_RECEIPT_SCHEMA_VERSION = 1;
+var LEGACY_RECEIPT_PROTOCOL_VERSION = 1;
 var OPERATION_SET = new Set([
   "implementation",
   "verification",
@@ -3514,6 +3727,9 @@ function isStringArray(value) {
 function isOperation2(value) {
   return typeof value === "string" && OPERATION_SET.has(value);
 }
+function isLocalOperation(operation) {
+  return operation === "implementation" || operation === "verification" || operation === "commit";
+}
 function isReceiptReasonCode(value) {
   return typeof value === "string" && new Set([
     "already-consumed",
@@ -3573,7 +3789,7 @@ function cloneEnvelope2(envelope) {
   };
 }
 function envelopesEqual(first, second) {
-  return first.schemaVersion === second.schemaVersion && first.protocolVersion === second.protocolVersion && first.registrationDigest === second.registrationDigest && capabilityListsEqual(first.capabilityFlags, second.capabilityFlags) && first.compatibility === second.compatibility && first.canonical.receiptId === second.canonical.receiptId && first.canonical.registrationDigest === second.canonical.registrationDigest && first.canonical.callDigest === second.canonical.callDigest && first.canonical.epochDigest === second.canonical.epochDigest && first.canonical.unitDigest === second.canonical.unitDigest && first.canonical.workspaceDigest === second.canonical.workspaceDigest && first.canonical.repositoryDigest === second.canonical.repositoryDigest && first.canonical.worktreeDigest === second.canonical.worktreeDigest && first.canonical.resourceDigest === second.canonical.resourceDigest && first.canonical.operation === second.canonical.operation && first.canonical.result === second.canonical.result && first.canonical.source === second.canonical.source && first.canonical.consumption === second.canonical.consumption && first.canonical.timestamp === second.canonical.timestamp;
+  return first.schemaVersion === second.schemaVersion && first.protocolVersion === second.protocolVersion && first.registrationDigest === second.registrationDigest && capabilityListsEqual(first.capabilityFlags, second.capabilityFlags) && first.compatibility === second.compatibility && first.canonical.receiptId === second.canonical.receiptId && first.canonical.registrationDigest === second.canonical.registrationDigest && first.canonical.callDigest === second.canonical.callDigest && first.canonical.epochDigest === second.canonical.epochDigest && first.canonical.unitDigest === second.canonical.unitDigest && first.canonical.workspaceDigest === second.canonical.workspaceDigest && first.canonical.repositoryDigest === second.canonical.repositoryDigest && first.canonical.worktreeDigest === second.canonical.worktreeDigest && first.canonical.operationTargetIdentity === second.canonical.operationTargetIdentity && first.canonical.resourceDigest === second.canonical.resourceDigest && first.canonical.operation === second.canonical.operation && first.canonical.result === second.canonical.result && first.canonical.source === second.canonical.source && first.canonical.consumption === second.canonical.consumption && first.canonical.timestamp === second.canonical.timestamp;
 }
 function cloneProgressionState(progression) {
   return {
@@ -3621,6 +3837,7 @@ function storedReceiptFromEnvelope(envelope) {
       workspaceDigest: envelope.canonical.workspaceDigest,
       repositoryDigest: envelope.canonical.repositoryDigest,
       worktreeDigest: envelope.canonical.worktreeDigest,
+      operationTargetIdentity: envelope.canonical.operationTargetIdentity,
       resourceDigest: envelope.canonical.resourceDigest
     }
   };
@@ -3759,8 +3976,9 @@ function parseContext(value) {
     return;
   const repositoryIdentity = value.repositoryIdentity === undefined ? undefined : normalizedIdentity(value.repositoryIdentity);
   const worktreeIdentity = value.worktreeIdentity === undefined ? undefined : normalizedIdentity(value.worktreeIdentity);
+  const operationTargetIdentity = value.operationTargetIdentity === undefined ? undefined : isDigest2(value.operationTargetIdentity) ? value.operationTargetIdentity : undefined;
   const resourceIdentity = value.resourceIdentity === undefined ? undefined : normalizedIdentity(value.resourceIdentity);
-  if (value.repositoryIdentity !== undefined && !repositoryIdentity || value.worktreeIdentity !== undefined && !worktreeIdentity || value.resourceIdentity !== undefined && !resourceIdentity) {
+  if (value.repositoryIdentity !== undefined && !repositoryIdentity || value.worktreeIdentity !== undefined && !worktreeIdentity || value.operationTargetIdentity !== undefined && !isDigest2(operationTargetIdentity) || value.resourceIdentity !== undefined && !resourceIdentity) {
     return;
   }
   return {
@@ -3769,6 +3987,7 @@ function parseContext(value) {
     workspaceIdentity,
     repositoryIdentity,
     worktreeIdentity,
+    operationTargetIdentity,
     resourceIdentity
   };
 }
@@ -3784,6 +4003,7 @@ function parseAfter(value) {
     workspaceIdentity: context.workspaceIdentity,
     repositoryIdentity: context.repositoryIdentity,
     worktreeIdentity: context.worktreeIdentity,
+    operationTargetIdentity: context.operationTargetIdentity,
     resourceIdentity: context.resourceIdentity
   };
 }
@@ -3857,6 +4077,8 @@ function compareDigestedContexts(expected, actual) {
     return "workspace-mismatch";
   if (expected.worktreeDigest !== actual.worktreeDigest)
     return "workspace-mismatch";
+  if (expected.operationTargetIdentity !== actual.operationTargetIdentity)
+    return "workspace-mismatch";
   if (expected.resourceDigest !== actual.resourceDigest)
     return "workspace-mismatch";
   return;
@@ -3877,7 +4099,9 @@ function validateEnvelopeInput(input) {
   if (!("schemaVersion" in input) || !("protocolVersion" in input)) {
     return { compatibility: "unavailable", reasonCode: "incomplete-envelope" };
   }
-  if (input.schemaVersion !== RECEIPT_SCHEMA_VERSION || input.protocolVersion !== RECEIPT_PROTOCOL_VERSION) {
+  const currentVersion = input.schemaVersion === RECEIPT_SCHEMA_VERSION && input.protocolVersion === RECEIPT_PROTOCOL_VERSION;
+  const legacyVersion = input.schemaVersion === LEGACY_RECEIPT_SCHEMA_VERSION && input.protocolVersion === LEGACY_RECEIPT_PROTOCOL_VERSION;
+  if (!currentVersion && !legacyVersion) {
     return { compatibility: "unavailable", reasonCode: "unknown-envelope" };
   }
   if (!("capabilityFlags" in input) || input.capabilityFlags === undefined) {
@@ -3897,16 +4121,19 @@ function isReceiptId2(value) {
 function parseEnvelope2(value) {
   if (!isRecord4(value))
     return;
-  if (value.schemaVersion !== RECEIPT_SCHEMA_VERSION || value.protocolVersion !== RECEIPT_PROTOCOL_VERSION || value.compatibility !== "compatible" || !isDigest2(value.registrationDigest) || !isBoundedCapabilityList(value.capabilityFlags) || !isRecord4(value.canonical)) {
+  const currentVersion = value.schemaVersion === RECEIPT_SCHEMA_VERSION && value.protocolVersion === RECEIPT_PROTOCOL_VERSION;
+  const legacyVersion = value.schemaVersion === LEGACY_RECEIPT_SCHEMA_VERSION && value.protocolVersion === LEGACY_RECEIPT_PROTOCOL_VERSION;
+  if (!currentVersion && !legacyVersion || value.compatibility !== "compatible" || !isDigest2(value.registrationDigest) || !isBoundedCapabilityList(value.capabilityFlags) || !isRecord4(value.canonical)) {
     return;
   }
   const canonical = value.canonical;
-  if (!isReceiptId2(canonical.receiptId) || !isDigest2(canonical.registrationDigest) || !isDigest2(canonical.callDigest) || !isDigest2(canonical.epochDigest) || !isDigest2(canonical.unitDigest) || !isDigest2(canonical.workspaceDigest) || canonical.repositoryDigest !== undefined && !isDigest2(canonical.repositoryDigest) || canonical.worktreeDigest !== undefined && !isDigest2(canonical.worktreeDigest) || canonical.resourceDigest !== undefined && !isDigest2(canonical.resourceDigest) || !isOperation2(canonical.operation) || canonical.result !== "success" || canonical.source !== "runtime-verified" || canonical.consumption !== "available" && canonical.consumption !== "consumed" || typeof canonical.timestamp !== "number" || !Number.isFinite(canonical.timestamp)) {
+  const operation = isOperation2(canonical.operation) ? canonical.operation : undefined;
+  if (!isReceiptId2(canonical.receiptId) || !isDigest2(canonical.registrationDigest) || !isDigest2(canonical.callDigest) || !isDigest2(canonical.epochDigest) || !isDigest2(canonical.unitDigest) || !isDigest2(canonical.workspaceDigest) || canonical.repositoryDigest !== undefined && !isDigest2(canonical.repositoryDigest) || canonical.worktreeDigest !== undefined && !isDigest2(canonical.worktreeDigest) || canonical.operationTargetIdentity !== undefined && !isDigest2(canonical.operationTargetIdentity) || operation === undefined || currentVersion && isLocalOperation(operation) && !isDigest2(canonical.operationTargetIdentity) || currentVersion && !isLocalOperation(operation) && Object.hasOwn(canonical, "operationTargetIdentity") || canonical.resourceDigest !== undefined && !isDigest2(canonical.resourceDigest) || canonical.result !== "success" || canonical.source !== "runtime-verified" || canonical.consumption !== "available" && canonical.consumption !== "consumed" || typeof canonical.timestamp !== "number" || !Number.isFinite(canonical.timestamp)) {
     return;
   }
   return {
-    schemaVersion: RECEIPT_SCHEMA_VERSION,
-    protocolVersion: RECEIPT_PROTOCOL_VERSION,
+    schemaVersion: currentVersion ? RECEIPT_SCHEMA_VERSION : LEGACY_RECEIPT_SCHEMA_VERSION,
+    protocolVersion: currentVersion ? RECEIPT_PROTOCOL_VERSION : LEGACY_RECEIPT_PROTOCOL_VERSION,
     registrationDigest: value.registrationDigest,
     capabilityFlags: [...value.capabilityFlags],
     compatibility: "compatible",
@@ -3919,8 +4146,9 @@ function parseEnvelope2(value) {
       workspaceDigest: canonical.workspaceDigest,
       repositoryDigest: canonical.repositoryDigest,
       worktreeDigest: canonical.worktreeDigest,
+      ...isLocalOperation(operation) ? { operationTargetIdentity: canonical.operationTargetIdentity } : {},
       resourceDigest: canonical.resourceDigest,
-      operation: canonical.operation,
+      operation,
       result: "success",
       source: "runtime-verified",
       consumption: canonical.consumption,
@@ -3974,13 +4202,14 @@ function createReceiptLedger(options = {}) {
     }
     return digestReceiptIdentity(domain, normalized, sessionSaltBytes);
   }
-  function digestContext(context) {
+  function digestContext(context, operation) {
     return {
       epochDigest: digestIdentity("epoch", context.epochId),
       unitDigest: digestIdentity("unit", context.unitId),
       workspaceDigest: digestIdentity("workspace", context.workspaceIdentity),
       repositoryDigest: context.repositoryIdentity ? digestIdentity("repository", context.repositoryIdentity) : undefined,
       worktreeDigest: context.worktreeIdentity ? digestIdentity("worktree", context.worktreeIdentity) : undefined,
+      ...isLocalOperation(operation) ? { operationTargetIdentity: context.operationTargetIdentity } : {},
       resourceDigest: context.resourceIdentity ? digestIdentity("resource", context.resourceIdentity) : undefined
     };
   }
@@ -3994,7 +4223,7 @@ function createReceiptLedger(options = {}) {
     if (!parsed)
       return prepareInvalidObservationResult(input);
     const callDigest = digestIdentity("call", parsed.callId);
-    const digested = digestContext(parsed.context);
+    const digested = digestContext(parsed.context, parsed.operation);
     const existing = lifecycleByCall.get(callDigest);
     if (existing) {
       return resolveExistingPrepare(existing, parsed.operation, digested);
@@ -4013,10 +4242,10 @@ function createReceiptLedger(options = {}) {
     if (!parsed)
       return invalidObservationResult(input);
     const callDigest = digestIdentity("call", parsed.callId);
-    const actualContext = digestContext(parsed.context);
     const matchingEntry = lifecycleByCall.get(callDigest);
     if (!matchingEntry)
       return invalidObservationResult(input);
+    const actualContext = digestContext(parsed.context, matchingEntry.operation);
     const contextMismatch = compareDigestedContexts(matchingEntry.context, actualContext);
     if (contextMismatch) {
       sealEntry(matchingEntry);
@@ -4027,7 +4256,7 @@ function createReceiptLedger(options = {}) {
       sealEntry(matchingEntry);
       return { status: "rejected", reasonCode: entryRejection };
     }
-    const afterDigests = digestAfter(parsed.after);
+    const afterDigests = digestAfter(parsed.after, matchingEntry.operation);
     const noOpReason = getNoOpReason(matchingEntry, afterDigests);
     if (noOpReason) {
       sealEntry(matchingEntry);
@@ -4070,13 +4299,14 @@ function createReceiptLedger(options = {}) {
       return "successful-no-op";
     return;
   }
-  function digestAfter(after) {
+  function digestAfter(after, operation) {
     return {
       epochDigest: "",
       unitDigest: "",
       workspaceDigest: digestIdentity("workspace", after.workspaceIdentity),
       repositoryDigest: after.repositoryIdentity ? digestIdentity("repository", after.repositoryIdentity) : undefined,
       worktreeDigest: after.worktreeIdentity ? digestIdentity("worktree", after.worktreeIdentity) : undefined,
+      ...isLocalOperation(operation) ? { operationTargetIdentity: after.operationTargetIdentity } : {},
       resourceDigest: after.resourceIdentity ? digestIdentity("resource", after.resourceIdentity) : undefined
     };
   }
@@ -4102,6 +4332,10 @@ function createReceiptLedger(options = {}) {
     return !entry.context.resourceDigest || !after.resourceDigest || after.resourceDigest === entry.context.resourceDigest ? "no-op-resource" : undefined;
   }
   function mintReceipt(entry, callDigest, after) {
+    if (isLocalOperation(entry.operation) && !after.operationTargetIdentity) {
+      entry.status = "abandoned";
+      return { status: "rejected", reasonCode: "invalid-observation" };
+    }
     const receiptId = randomBytes2(16).toString("hex");
     const canonical = {
       receiptId,
@@ -4112,6 +4346,7 @@ function createReceiptLedger(options = {}) {
       workspaceDigest: entry.context.workspaceDigest,
       repositoryDigest: after.repositoryDigest,
       worktreeDigest: after.worktreeDigest,
+      ...isLocalOperation(entry.operation) ? { operationTargetIdentity: after.operationTargetIdentity } : {},
       resourceDigest: after.resourceDigest,
       operation: entry.operation,
       result: "success",
@@ -4136,6 +4371,7 @@ function createReceiptLedger(options = {}) {
         workspaceDigest: entry.context.workspaceDigest,
         repositoryDigest: after.repositoryDigest,
         worktreeDigest: after.worktreeDigest,
+        operationTargetIdentity: after.operationTargetIdentity,
         resourceDigest: after.resourceDigest
       }
     });
@@ -4149,10 +4385,10 @@ function createReceiptLedger(options = {}) {
     if (!callId || !context)
       return { status: "rejected", reasonCode: "invalid-observation" };
     const callDigest = digestIdentity("call", callId);
-    const digested = digestContext(context);
     const matchingEntry = lifecycleByCall.get(callDigest);
     if (!matchingEntry)
       return { status: "rejected", reasonCode: "unknown-receipt" };
+    const digested = digestContext(context, matchingEntry.operation);
     const contextMismatch = compareDigestedContexts(matchingEntry.context, digested);
     if (contextMismatch)
       return { status: "rejected", reasonCode: contextMismatch };
@@ -4171,7 +4407,7 @@ function createReceiptLedger(options = {}) {
     const stored = receipts.get(receiptId);
     if (!stored)
       return { status: "rejected", reasonCode: "unknown-receipt" };
-    const actual = digestContext(context);
+    const actual = digestContext(context, stored.envelope.canonical.operation);
     const contextMismatch = compareDigestedContexts(stored.context, actual);
     if (contextMismatch)
       return { status: "rejected", reasonCode: contextMismatch };
@@ -4181,13 +4417,19 @@ function createReceiptLedger(options = {}) {
     stored.envelope.canonical.consumption = "consumed";
     return { status: "consumed", receipt: cloneEnvelope2(stored.envelope) };
   }
-  function recoverReceipt(input) {
+  function recoverReceipt(input, operationTargetIdentity) {
     const markerResult2 = getMintMarker(input);
     if (markerResult2.status !== "valid")
       return markerResult2;
     const marker = markerResult2.marker;
     if (marker.sessionSalt !== sessionSalt)
       return { status: "rejected", category: "salt-mismatch" };
+    if (marker.envelope.schemaVersion === 1 && operationTargetIdentity !== undefined) {
+      return { status: "rejected", category: "identity-digest-mismatch" };
+    }
+    if (marker.envelope.schemaVersion === RECEIPT_SCHEMA_VERSION && operationTargetIdentity !== undefined && marker.envelope.canonical.operationTargetIdentity !== operationTargetIdentity) {
+      return { status: "rejected", category: "identity-digest-mismatch" };
+    }
     const envelopeValidation = validateEnvelope(marker.envelope);
     const envelopeFailure = recoveryEnvelopeCategory(envelopeValidation);
     if (envelopeFailure) {
@@ -4212,8 +4454,8 @@ function createReceiptLedger(options = {}) {
     receipts.set(receiptId, storedReceiptFromEnvelope(envelope));
     return { status: "recovered", receipt: cloneEnvelope2(envelope) };
   }
-  function recoverReadback(input) {
-    const folded = foldForLedgerRecovery(input, receiptReadbackExpectationFromMetadata(metadata2, sessionSaltBytes));
+  function recoverReadback(input, operationTargetIdentity) {
+    const folded = foldForLedgerRecovery(input, receiptReadbackExpectationFromMetadata(metadata2, sessionSaltBytes, operationTargetIdentity));
     if (folded.status !== "reconstructed") {
       return { status: "rejected", category: folded.category };
     }
@@ -7685,6 +7927,7 @@ function parseOperationContext(value) {
     "workspaceIdentity",
     "repositoryIdentity",
     "worktreeIdentity",
+    "operationTargetIdentity",
     "resourceIdentity",
     "resourceRevisionIdentity"
   ]))) {
@@ -7708,14 +7951,16 @@ function hasRequiredOperationIdentities(value) {
 function parseOperationStateFields(value) {
   const repositoryIdentity = parseOptionalDigestIdentity(value.repositoryIdentity);
   const worktreeIdentity = parseOptionalDigestIdentity(value.worktreeIdentity);
+  const operationTargetIdentity = parseOptionalDigestIdentity(value.operationTargetIdentity);
   const resourceIdentity = parseOptionalDigestIdentity(value.resourceIdentity);
   const resourceRevisionIdentity = parseOptionalDigestIdentity(value.resourceRevisionIdentity);
-  if (!validOptionalIdentity(value.repositoryIdentity, repositoryIdentity) || !validOptionalIdentity(value.worktreeIdentity, worktreeIdentity) || !validOptionalIdentity(value.resourceIdentity, resourceIdentity) || !validOptionalIdentity(value.resourceRevisionIdentity, resourceRevisionIdentity)) {
+  if (!validOptionalIdentity(value.repositoryIdentity, repositoryIdentity) || !validOptionalIdentity(value.worktreeIdentity, worktreeIdentity) || !validOptionalIdentity(value.operationTargetIdentity, operationTargetIdentity) || !validOptionalIdentity(value.resourceIdentity, resourceIdentity) || !validOptionalIdentity(value.resourceRevisionIdentity, resourceRevisionIdentity)) {
     return;
   }
   return {
     repositoryIdentity,
     worktreeIdentity,
+    operationTargetIdentity,
     resourceIdentity,
     resourceRevisionIdentity
   };
@@ -7759,6 +8004,7 @@ var OPERATION_AFTER_FIELDS = new Set([
   "workspaceIdentity",
   "repositoryIdentity",
   "worktreeIdentity",
+  "operationTargetIdentity",
   "resourceIdentity",
   "resourceRevisionIdentity",
   "pullRequest",
@@ -8293,6 +8539,7 @@ var RECOVERY_UNIT_KEYS = new Set([
   "family",
   "requiredOperations",
   "resourceScopes",
+  "pinnedOperationTargetIdentity",
   "transitionDigest"
 ]);
 var RECOVERY_STATE_KEYS = new Set([
@@ -8454,7 +8701,8 @@ function parseRecoveryUnit(value) {
     return;
   const requiredOperations = parseRecoveryOperations(value.requiredOperations);
   const resourceScopes = parseRecoveryResourceScopes(value.resourceScopes);
-  if (value.target !== "unit" || value.state !== "started" && value.state !== "completed" || !isRecoveryId(value.epochId) || !isRecoveryDigest(value.epochDigest) || !isRecoveryId(value.unitId) || !isRecoveryDigest(value.unitDigest) || !isFamily2(value.family) || !requiredOperations || !resourceScopes || !isRecoveryDigest(value.transitionDigest)) {
+  const pinnedOperationTargetIdentity = value.pinnedOperationTargetIdentity === undefined ? undefined : isRecoveryDigest(value.pinnedOperationTargetIdentity) ? value.pinnedOperationTargetIdentity : undefined;
+  if (value.target !== "unit" || value.state !== "started" && value.state !== "completed" || !isRecoveryId(value.epochId) || !isRecoveryDigest(value.epochDigest) || !isRecoveryId(value.unitId) || !isRecoveryDigest(value.unitDigest) || !isFamily2(value.family) || !requiredOperations || !resourceScopes || value.pinnedOperationTargetIdentity !== undefined && pinnedOperationTargetIdentity === undefined || !isRecoveryDigest(value.transitionDigest)) {
     return;
   }
   return {
@@ -8467,6 +8715,7 @@ function parseRecoveryUnit(value) {
     family: value.family,
     requiredOperations,
     resourceScopes,
+    ...pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity } : {},
     transitionDigest: value.transitionDigest
   };
 }
@@ -8518,7 +8767,8 @@ function cloneUnit(unit) {
     resourceScopes: Object.freeze([...unit.resourceScopes].map(([operation, resourceIdentity]) => ({
       operation,
       resourceIdentity
-    })))
+    }))),
+    ...unit.pinnedOperationTargetIdentity ? { pinnedOperationTargetIdentity: unit.pinnedOperationTargetIdentity } : {}
   });
 }
 function familyForSkill(skill) {
@@ -8606,6 +8856,7 @@ function parseReadback(input) {
     "workspaceIdentity",
     "repositoryIdentity",
     "worktreeIdentity",
+    "operationTargetIdentity",
     "resourceIdentity",
     "resourceRevisionIdentity",
     "pullRequest",
@@ -8618,6 +8869,7 @@ function parseReadback(input) {
     workspaceIdentity: input.workspaceIdentity,
     repositoryIdentity: input.repositoryIdentity,
     worktreeIdentity: input.worktreeIdentity,
+    operationTargetIdentity: input.operationTargetIdentity,
     resourceIdentity: input.resourceIdentity,
     resourceRevisionIdentity: input.resourceRevisionIdentity,
     pullRequest: input.pullRequest,
@@ -8631,6 +8883,7 @@ function parseReadback(input) {
     workspaceIdentity: after.workspaceIdentity,
     repositoryIdentity: after.repositoryIdentity,
     worktreeIdentity: after.worktreeIdentity,
+    operationTargetIdentity: after.operationTargetIdentity,
     resourceIdentity: after.resourceIdentity,
     resourceRevisionIdentity: after.resourceRevisionIdentity,
     pullRequest: after.pullRequest,
@@ -8644,9 +8897,10 @@ function parseLegacyReadbackAfter(input) {
   }
   const repositoryIdentity = parseOptionalReadbackIdentity(input.repositoryIdentity);
   const worktreeIdentity = parseOptionalReadbackIdentity(input.worktreeIdentity);
+  const operationTargetIdentity = parseOptionalReadbackIdentity(input.operationTargetIdentity);
   const resourceIdentity = parseOptionalReadbackIdentity(input.resourceIdentity);
   const resourceRevisionIdentity = parseOptionalReadbackIdentity(input.resourceRevisionIdentity);
-  if (!isOptionalReadbackIdentity(input.repositoryIdentity, repositoryIdentity) || !isOptionalReadbackIdentity(input.worktreeIdentity, worktreeIdentity) || !isOptionalReadbackIdentity(input.resourceIdentity, resourceIdentity) || !isOptionalReadbackIdentity(input.resourceRevisionIdentity, resourceRevisionIdentity)) {
+  if (!isOptionalReadbackIdentity(input.repositoryIdentity, repositoryIdentity) || !isOptionalReadbackIdentity(input.worktreeIdentity, worktreeIdentity) || !isOptionalReadbackIdentity(input.operationTargetIdentity, operationTargetIdentity) || !isOptionalReadbackIdentity(input.resourceIdentity, resourceIdentity) || !isOptionalReadbackIdentity(input.resourceRevisionIdentity, resourceRevisionIdentity)) {
     return;
   }
   const pullRequest = parseLegacyPullRequest(input.pullRequest);
@@ -8660,6 +8914,7 @@ function parseLegacyReadbackAfter(input) {
     workspaceIdentity: input.workspaceIdentity,
     ...repositoryIdentity ? { repositoryIdentity } : {},
     ...worktreeIdentity ? { worktreeIdentity } : {},
+    ...operationTargetIdentity ? { operationTargetIdentity } : {},
     ...resourceIdentity ? { resourceIdentity } : {},
     ...resourceRevisionIdentity ? { resourceRevisionIdentity } : {},
     ...pullRequest ? { pullRequest } : {},
@@ -8699,10 +8954,12 @@ function ledgerResourceIdentity(operation, resourceIdentity, resourceRevisionIde
 function toLedgerContext(operation, context) {
   const {
     resourceRevisionIdentity: _resourceRevisionIdentity,
+    operationTargetIdentity: _operationTargetIdentity,
     ...ledgerContext
   } = context;
   return {
     ...ledgerContext,
+    ...isLocalOperation(operation) ? { operationTargetIdentity: context.operationTargetIdentity } : {},
     resourceIdentity: ledgerResourceIdentity(operation, context.resourceIdentity, context.resourceRevisionIdentity)
   };
 }
@@ -8712,10 +8969,12 @@ function toLedgerAfter(operation, after) {
     pullRequest: _pullRequest,
     checkState: _checkState,
     reviewDecision: _reviewDecision,
+    operationTargetIdentity: _operationTargetIdentity,
     ...ledgerAfter
   } = after;
   return {
     ...ledgerAfter,
+    ...isLocalOperation(operation) ? { operationTargetIdentity: after.operationTargetIdentity } : {},
     resourceIdentity: ledgerResourceIdentity(operation, after.resourceIdentity, after.resourceRevisionIdentity)
   };
 }
@@ -8769,12 +9028,13 @@ function parseU4Readback(input) {
     "workspaceIdentity",
     "repositoryIdentity",
     "worktreeIdentity",
+    "operationTargetIdentity",
     "resourceIdentity",
     "resourceRevisionIdentity",
     "pullRequest",
     "checkState",
     "reviewDecision"
-  ])) || input.operation !== undefined && !isOperation4(input.operation)) {
+  ])) || input.operation !== undefined && !isOperation4(input.operation) || input.operation !== undefined && isOperation4(input.operation) && !isLocalOperation(input.operation) && Object.hasOwn(input, "operationTargetIdentity")) {
     return;
   }
   const { operation: _operation, ...afterInput } = input;
@@ -8786,6 +9046,7 @@ function parseU4Readback(input) {
     workspaceIdentity: after.workspaceIdentity,
     repositoryIdentity: after.repositoryIdentity,
     worktreeIdentity: after.worktreeIdentity,
+    operationTargetIdentity: after.operationTargetIdentity,
     resourceIdentity: after.resourceIdentity,
     resourceRevisionIdentity: after.resourceRevisionIdentity,
     pullRequest: after.pullRequest,
@@ -8936,11 +9197,21 @@ function createWorkflowGuard(options) {
       return "epoch-mismatch";
     if (input.context.unitId !== unit.unitId)
       return "unit-mismatch";
-    return currentIdentityReason(input.context) ?? resourceBeforeReason(input, unit);
+    return currentIdentityReason(input.context) ?? operationTargetReason(input, unit) ?? resourceBeforeReason(input, unit);
+  }
+  function operationTargetReason(input, unit) {
+    if (!isLocalOperation(input.operation))
+      return;
+    if (input.after && input.after.operationTargetIdentity !== input.context.operationTargetIdentity) {
+      return "operation-target-mismatch";
+    }
+    return unit.pinnedOperationTargetIdentity !== undefined && input.context.operationTargetIdentity !== unit.pinnedOperationTargetIdentity ? "operation-target-mismatch" : undefined;
   }
   function currentIdentityReason(context) {
     if (context.workspaceIdentity !== currentWorkspaceIdentity)
       return "workspace-mismatch";
+    if (context.operationTargetIdentity !== undefined)
+      return;
     if (context.repositoryIdentity !== currentRepositoryIdentity)
       return "receipt-mismatch";
     return context.worktreeIdentity !== currentWorktreeIdentity ? "receipt-mismatch" : undefined;
@@ -8971,7 +9242,7 @@ function createWorkflowGuard(options) {
     if (input.after.workspaceIdentity !== input.context.workspaceIdentity) {
       return "workspace-mismatch";
     }
-    return resourceAfterReason(input, unit);
+    return operationTargetReason(input, unit) ?? resourceAfterReason(input, unit);
   }
   function resourceAfterReason(input, unit) {
     if (!operationUsesResource(input.operation))
@@ -9243,6 +9514,9 @@ function createWorkflowGuard(options) {
     if (envelope.canonical.unitDigest !== options.ledger.digestIdentity("unit", unit.unitId)) {
       return "receipt-mismatch";
     }
+    if (isLocalOperation(envelope.canonical.operation) && unit.pinnedOperationTargetIdentity !== undefined && envelope.canonical.operationTargetIdentity !== unit.pinnedOperationTargetIdentity) {
+      return "operation-target-mismatch";
+    }
     const historicalImplementation = envelope.canonical.operation === "implementation" && unit.evidence.get("implementation")?.canonical.receiptId === envelope.canonical.receiptId;
     if (!historicalImplementation) {
       if (envelope.canonical.workspaceDigest !== options.ledger.digestIdentity("workspace", currentWorkspaceIdentity)) {
@@ -9353,7 +9627,7 @@ function createWorkflowGuard(options) {
     return { satisfied, missing };
   }
   function issueKind(reasonCode) {
-    return reasonCode === "incompatible-receipt" || reasonCode === "guard-unavailable" ? "unavailable" : "rejected";
+    return reasonCode === "incompatible-receipt" || reasonCode === "guard-unavailable" || reasonCode === "operation-target-mismatch" ? "unavailable" : "rejected";
   }
   function makeStatus(state, reasonCode, repair, satisfied = [], missing = []) {
     const epochSnapshot = epoch ? cloneEpoch(epoch) : null;
@@ -9487,6 +9761,7 @@ function createWorkflowGuard(options) {
       workspaceIdentity: currentWorkspaceIdentity,
       repositoryIdentity: currentRepositoryIdentity,
       worktreeIdentity: currentWorktreeIdentity,
+      operationTargetIdentity: envelope.canonical.operationTargetIdentity,
       resourceIdentity: ledgerResourceIdentity(operation, currentResource(unit, operation), currentResourceRevisionIdentities.get(operation))
     };
   }
@@ -9556,6 +9831,9 @@ function createWorkflowGuard(options) {
       return { status: "accepted", operation };
     }
     unit.evidence.set(operation, read.envelope);
+    if (isLocalOperation(operation) && unit.pinnedOperationTargetIdentity === undefined && read.envelope.canonical.operationTargetIdentity !== undefined) {
+      unit.pinnedOperationTargetIdentity = read.envelope.canonical.operationTargetIdentity;
+    }
     clearIssue(unit, operation);
     globalIssue = undefined;
     return { status: "accepted", operation };
@@ -9566,6 +9844,7 @@ function createWorkflowGuard(options) {
       workspaceIdentity: after.workspaceIdentity,
       repositoryIdentity: after.repositoryIdentity,
       worktreeIdentity: after.worktreeIdentity,
+      ...isLocalOperation(operation) ? { operationTargetIdentity: after.operationTargetIdentity } : {},
       resourceIdentity: after.resourceIdentity,
       resourceRevisionIdentity: after.resourceRevisionIdentity,
       pullRequest: after.pullRequest,
@@ -9887,6 +10166,7 @@ function createWorkflowGuard(options) {
       workspaceIdentity: parsed.after.workspaceIdentity,
       repositoryIdentity: parsed.after.repositoryIdentity,
       worktreeIdentity: parsed.after.worktreeIdentity,
+      operationTargetIdentity: parsed.after.operationTargetIdentity,
       resourceIdentity: parsed.after.resourceIdentity,
       resourceRevisionIdentity: parsed.after.resourceRevisionIdentity
     }));
@@ -9910,6 +10190,9 @@ function createWorkflowGuard(options) {
     if (!global?.repositoryIdentity || !global.worktreeIdentity) {
       return "invalid-receipt";
     }
+    if (unit.pinnedOperationTargetIdentity !== undefined && global.operationTargetIdentity !== unit.pinnedOperationTargetIdentity) {
+      return "operation-target-mismatch";
+    }
     const required = RESOURCE_FINAL_READBACK_OPERATIONS.filter((operation) => unit.evidence.has(operation));
     for (const operation of required) {
       const readback = readbacks.find((item) => item.operation === operation);
@@ -10029,6 +10312,16 @@ function createWorkflowGuard(options) {
     }
     return;
   }
+  function recoveryTargetPinReason(unit, matching) {
+    if (!unit)
+      return;
+    const localTargets = matching.filter((envelope) => isLocalOperation(envelope.canonical.operation)).map((envelope) => envelope.canonical.operationTargetIdentity);
+    if (unit.pinnedOperationTargetIdentity !== undefined) {
+      return localTargets.some((target) => target !== unit.pinnedOperationTargetIdentity) ? "operation-target-mismatch" : undefined;
+    }
+    const distinctTargets = new Set(localTargets.filter((target) => target !== undefined));
+    return distinctTargets.size > 1 ? "operation-target-mismatch" : undefined;
+  }
   function resourceScopeMatches(operation, persisted, trusted) {
     return persisted === trusted || persisted === options.ledger.digestIdentity("resource", trusted) || persisted === options.ledger.digestIdentity("resource", ledgerResourceIdentity(operation, trusted, currentResourceRevisionIdentities.get(operation)) ?? trusted);
   }
@@ -10058,6 +10351,7 @@ function createWorkflowGuard(options) {
       workspaceIdentity: currentWorkspaceIdentity,
       repositoryIdentity: currentRepositoryIdentity,
       worktreeIdentity: currentWorktreeIdentity,
+      operationTargetIdentity: envelope.canonical.operationTargetIdentity,
       resourceIdentity: resourceScopes.get(envelope.canonical.operation)
     };
   }
@@ -10151,6 +10445,9 @@ function createWorkflowGuard(options) {
     const boundaryFailure = receiptSet.matching.map(recoveryBoundaryReason).find((reason) => reason !== undefined);
     if (boundaryFailure)
       return { status: "rejected", reasonCode: boundaryFailure };
+    const targetPinFailure = recoveryTargetPinReason(state.progression.unit, receiptSet.matching);
+    if (targetPinFailure)
+      return { status: "rejected", reasonCode: targetPinFailure };
     const completionFailure = recoveryCompletionReason(state.progression, receiptSet.matching);
     if (completionFailure)
       return { status: "rejected", reasonCode: completionFailure };
@@ -10160,12 +10457,16 @@ function createWorkflowGuard(options) {
     const snapshot = progression.unit;
     if (!snapshot)
       return;
+    const inferredOperationTargetIdentity = snapshot.pinnedOperationTargetIdentity ?? matching.find((envelope) => isLocalOperation(envelope.canonical.operation))?.canonical.operationTargetIdentity;
     const unit = {
       unitId: snapshot.unitId,
       status: snapshot.state === "completed" ? "completed" : "active",
       requiredOperations: Object.freeze([...snapshot.requiredOperations]),
       declaredResourceOperations: Object.freeze(snapshot.resourceScopes.map((scope) => scope.operation)),
       resourceScopes: new Map(resourceScopes),
+      ...inferredOperationTargetIdentity ? {
+        pinnedOperationTargetIdentity: inferredOperationTargetIdentity
+      } : {},
       evidence: new Map,
       issues: new Map,
       staleReceiptIds: new Set,
@@ -10432,7 +10733,7 @@ function createWorkflowGuard(options) {
 // src/lib/opencode-workflow-guard.ts
 var MARKER_OPEN = "<SYSTEMATIC_WORKFLOW_GUARD>";
 var MARKER_CLOSE = "</SYSTEMATIC_WORKFLOW_GUARD>";
-var MARKER_PROTOCOL_VERSION = 1;
+var MARKER_PROTOCOL_VERSION = 2;
 var MAX_MARKER_LENGTH = 4096;
 var MAX_MARKER_SOURCES = 8;
 var MAX_CALL_ID_LENGTH = 256;
@@ -10494,6 +10795,7 @@ var REASON_CODES = new Set([
   "no-active-unit",
   "no-op-operation",
   "operation-not-required",
+  "operation-target-mismatch",
   "receipt-mismatch",
   "rejected-operation",
   "resource-mismatch",
@@ -10637,6 +10939,216 @@ function digestCall(ledger, callID) {
 function isLocalOperationTool(tool) {
   return tool === "write" || tool === "edit" || tool === "apply_patch" || tool === "bash";
 }
+function unavailableOperationTarget() {
+  return { status: "unavailable", reasonCode: "target-unavailable" };
+}
+function canonicalExistingPath(filePath, realPath) {
+  try {
+    return realPath(filePath);
+  } catch {
+    return;
+  }
+}
+function registeredWorktreeIdentity(validation) {
+  return validation.status === "ok" ? `${validation.gitDir}
+${validation.commonDir}` : undefined;
+}
+function canonicalFileTarget(filePath, realPath) {
+  const existing = canonicalExistingPath(filePath, realPath);
+  if (existing)
+    return existing;
+  const parent = canonicalExistingPath(path9.dirname(filePath), realPath);
+  const basename = path9.basename(filePath);
+  return parent && basename && basename !== "." && basename !== ".." ? path9.join(parent, basename) : undefined;
+}
+function pathWithinOrEqual(root, candidate) {
+  const relative = path9.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path9.sep}`) && !path9.isAbsolute(relative);
+}
+function targetIsGitAdminStorage(targetPath, validation) {
+  return pathWithinOrEqual(path9.join(validation.targetRoot, ".git"), targetPath) || pathWithinOrEqual(validation.gitDir, targetPath) || pathWithinOrEqual(validation.commonDir, targetPath);
+}
+function targetResultFromValidation(candidatePath, validation) {
+  if (validation.status === "error")
+    return unavailableOperationTarget();
+  if (!pathWithinOrEqual(validation.targetRoot, candidatePath)) {
+    return unavailableOperationTarget();
+  }
+  if (targetIsGitAdminStorage(candidatePath, validation)) {
+    return unavailableOperationTarget();
+  }
+  return { status: "available", targetRoot: validation.targetRoot };
+}
+function trustedParentTarget(parentTargetRoot, candidatePath) {
+  if (!pathWithinOrEqual(parentTargetRoot, candidatePath))
+    return;
+  if (pathWithinOrEqual(path9.join(parentTargetRoot, ".git"), candidatePath)) {
+    return unavailableOperationTarget();
+  }
+  return { status: "available", targetRoot: parentTargetRoot };
+}
+function validationForCandidate(candidatePath, options, targetPath = candidatePath) {
+  try {
+    return targetResultFromValidation(targetPath, options.validateRegisteredWorktree(candidatePath));
+  } catch {
+    return unavailableOperationTarget();
+  }
+}
+function deriveFileTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath, allowParentFastPath = true) {
+  const resolvedPath = path9.resolve(baseDirectory, rawPath);
+  const canonicalPath2 = canonicalFileTarget(resolvedPath, realPath);
+  if (!canonicalPath2)
+    return unavailableOperationTarget();
+  const parentResult = allowParentFastPath && !path9.isAbsolute(rawPath) ? trustedParentTarget(parentTargetRoot, canonicalPath2) : undefined;
+  if (parentResult)
+    return parentResult;
+  return validationForCandidate(path9.dirname(canonicalPath2), options, canonicalPath2);
+}
+function sharedTargetRoot(targets, extraRoots = []) {
+  const roots = [...extraRoots];
+  for (const target of targets) {
+    if (target.status === "unavailable")
+      return;
+    roots.push(target.targetRoot);
+  }
+  const targetRoot = roots[0];
+  return targetRoot && roots.every((root) => root === targetRoot) ? targetRoot : undefined;
+}
+function deriveDirectoryTarget(rawPath, baseDirectory, parentTargetRoot, options, realPath) {
+  const resolvedPath = canonicalExistingPath(path9.resolve(baseDirectory, rawPath), realPath);
+  if (!resolvedPath)
+    return { status: "unavailable" };
+  const parentResult = path9.isAbsolute(rawPath) ? undefined : trustedParentTarget(parentTargetRoot, resolvedPath);
+  if (parentResult?.status === "unavailable") {
+    return { status: "unavailable" };
+  }
+  if (parentResult) {
+    return {
+      status: "available",
+      target: { targetRoot: parentResult.targetRoot, resolvedPath }
+    };
+  }
+  const validated = validationForCandidate(resolvedPath, options);
+  return validated.status === "available" ? {
+    status: "available",
+    target: { targetRoot: validated.targetRoot, resolvedPath }
+  } : { status: "unavailable" };
+}
+var PATCH_FILE_PREFIXES = [
+  "*** Add File:",
+  "*** Delete File:",
+  "*** Update File:",
+  "*** Move to:"
+];
+function patchTextFileTargets(patchText) {
+  const paths = [];
+  for (const line of patchText.split(/\r?\n/)) {
+    const prefix = PATCH_FILE_PREFIXES.find((candidate) => line.startsWith(candidate));
+    if (!prefix)
+      continue;
+    const filePath = line.slice(prefix.length).trim();
+    if (!filePath)
+      return;
+    paths.push(filePath);
+  }
+  return paths;
+}
+function hunkFileTargets(value) {
+  if (!Array.isArray(value))
+    return;
+  const paths = [];
+  for (const hunk of value) {
+    if (!isRecord7(hunk) || typeof hunk.path !== "string" || !hunk.path) {
+      return;
+    }
+    paths.push(hunk.path);
+    if (hunk.move_path === undefined)
+      continue;
+    if (typeof hunk.move_path !== "string" || !hunk.move_path)
+      return;
+    paths.push(hunk.move_path);
+  }
+  return paths;
+}
+function patchFileTargets(args2) {
+  const patchValue = args2.patchText ?? args2.patch;
+  if (typeof patchValue === "string")
+    return patchTextFileTargets(patchValue);
+  if (patchValue !== undefined)
+    return;
+  return args2.hunks === undefined ? [] : hunkFileTargets(args2.hunks);
+}
+function fileTargetArguments(args2) {
+  const paths = [];
+  for (const key of ["filePath", "path"]) {
+    if (!(key in args2))
+      continue;
+    if (typeof args2[key] !== "string" || args2[key].length === 0) {
+      return;
+    }
+    paths.push(args2[key]);
+  }
+  return paths.length > 0 ? paths : undefined;
+}
+function deriveFileOperationTarget(args2, sessionLocation, parentTargetRoot, options, realPath) {
+  const paths = fileTargetArguments(args2);
+  if (!paths)
+    return unavailableOperationTarget();
+  const targets = paths.map((rawPath) => deriveFileTarget(rawPath, sessionLocation, parentTargetRoot, options, realPath));
+  const targetRoot = sharedTargetRoot(targets);
+  return targetRoot ? { status: "available", targetRoot } : unavailableOperationTarget();
+}
+function deriveApplyPatchTarget(args2, sessionLocation, parentTargetRoot, options, realPath) {
+  if (args2.workdir !== undefined && (typeof args2.workdir !== "string" || args2.workdir.length === 0)) {
+    return unavailableOperationTarget();
+  }
+  const patchPaths = patchFileTargets(args2);
+  if (!patchPaths)
+    return unavailableOperationTarget();
+  const workdir = args2.workdir === undefined ? {
+    status: "available",
+    target: {
+      targetRoot: parentTargetRoot,
+      resolvedPath: sessionLocation
+    }
+  } : deriveDirectoryTarget(args2.workdir, sessionLocation, parentTargetRoot, options, realPath);
+  if (workdir.status === "unavailable")
+    return unavailableOperationTarget();
+  const targets = patchPaths.map((rawPath) => deriveFileTarget(rawPath, workdir.target.resolvedPath, parentTargetRoot, options, realPath, args2.workdir === undefined));
+  const targetRoot = sharedTargetRoot(targets, [workdir.target.targetRoot]);
+  return targetRoot ? { status: "available", targetRoot } : unavailableOperationTarget();
+}
+function deriveBashTarget(args2, sessionLocation, parentTargetRoot, options, realPath) {
+  if (args2.workdir === undefined) {
+    return { status: "available", targetRoot: parentTargetRoot };
+  }
+  if (typeof args2.workdir !== "string" || args2.workdir.length === 0) {
+    return unavailableOperationTarget();
+  }
+  const candidatePath = canonicalExistingPath(path9.resolve(sessionLocation, args2.workdir), realPath);
+  if (!candidatePath)
+    return unavailableOperationTarget();
+  const parentResult = path9.isAbsolute(args2.workdir) ? undefined : trustedParentTarget(parentTargetRoot, candidatePath);
+  return parentResult ?? validationForCandidate(candidatePath, options);
+}
+function deriveOpencodeOperationTarget(tool, args2, options) {
+  const realPath = options.realPath ?? fs10.realpathSync;
+  const parentTargetRoot = canonicalExistingPath(options.parentTargetRoot, realPath);
+  if (!parentTargetRoot)
+    return unavailableOperationTarget();
+  if (!isRecord7(args2))
+    return unavailableOperationTarget();
+  const sessionLocation = canonicalExistingPath(options.sessionLocation ?? parentTargetRoot, realPath);
+  if (!sessionLocation)
+    return unavailableOperationTarget();
+  if (tool === "write" || tool === "edit") {
+    return deriveFileOperationTarget(args2, sessionLocation, parentTargetRoot, options, realPath);
+  }
+  if (tool === "apply_patch") {
+    return deriveApplyPatchTarget(args2, sessionLocation, parentTargetRoot, options, realPath);
+  }
+  return tool === "bash" ? deriveBashTarget(args2, sessionLocation, parentTargetRoot, options, realPath) : unavailableOperationTarget();
+}
 function serializeStableArray(value, depth, budget) {
   const entries = [];
   let remaining = budget;
@@ -10719,7 +11231,7 @@ function terminalForOutput(tool, output) {
   };
 }
 function localOperation(operation) {
-  return operation === "implementation" || operation === "verification" || operation === "commit";
+  return operation !== null && isLocalOperation(operation);
 }
 function remoteOperation(operation) {
   return operation === "push" || operation === "pr-creation" || operation === "check-readback" || operation === "review-readback";
@@ -10905,7 +11417,7 @@ function buildMarker(sources, malformed, current) {
   };
   return `${MARKER_OPEN}${JSON.stringify(document2)}${MARKER_CLOSE}`;
 }
-function createSessionRuntime(options) {
+function createSessionRuntime(options, operationObservers, recoveredOperationContexts) {
   let ledger;
   let guard;
   let initialized = false;
@@ -10928,6 +11440,74 @@ function createSessionRuntime(options) {
   const pendingQuestionChallenges = new Map;
   const blockedQuestionCalls = new Map;
   const consumedQuestionTargets = new Set;
+  function rememberOperationObserver(registration) {
+    const existing = operationObservers.get(registration.observer.targetDigest);
+    if (existing && existing.targetRoot !== registration.targetRoot)
+      return;
+    operationObservers.set(registration.observer.targetDigest, registration);
+  }
+  function parentObserverRegistration() {
+    if (!options.observer)
+      return;
+    const targetRoot = canonicalExistingPath(options.targetDirectory ?? process.cwd(), fs10.realpathSync);
+    if (!targetRoot)
+      return;
+    let validation;
+    try {
+      validation = options.observer.validateRegisteredWorktree(targetRoot);
+    } catch {
+      return;
+    }
+    const registeredIdentity = registeredWorktreeIdentity(validation);
+    if (validation.status !== "ok" || registeredIdentity === undefined || validation.targetRoot !== targetRoot) {
+      return;
+    }
+    const registration = {
+      targetRoot,
+      registeredWorktreeIdentity: registeredIdentity,
+      observer: options.observer
+    };
+    rememberOperationObserver(registration);
+    return registration;
+  }
+  function operationObserverRegistration(targetIdentity) {
+    const existing = operationObservers.get(targetIdentity);
+    if (existing)
+      return existing;
+    if (options.observer?.targetDigest !== targetIdentity)
+      return;
+    return parentObserverRegistration();
+  }
+  function effectiveOperationObserver() {
+    const parentObserver = options.observer;
+    if (!parentObserver)
+      return;
+    const pinnedTargetIdentity = guard.status().unit?.pinnedOperationTargetIdentity;
+    if (pinnedTargetIdentity === undefined || pinnedTargetIdentity === options.workspaceIdentity) {
+      return {
+        observer: parentObserver,
+        targetIdentity: options.workspaceIdentity,
+        pinned: false
+      };
+    }
+    const registration = operationObserverRegistration(pinnedTargetIdentity);
+    if (!registration)
+      return;
+    let validation;
+    try {
+      validation = parentObserver.validateRegisteredWorktree(registration.targetRoot);
+    } catch {
+      return;
+    }
+    if (validation.status !== "ok" || validation.targetRoot !== registration.targetRoot || registeredWorktreeIdentity(validation) !== registration.registeredWorktreeIdentity || registration.observer.targetDigest !== pinnedTargetIdentity) {
+      return;
+    }
+    return {
+      observer: registration.observer,
+      targetIdentity: pinnedTargetIdentity,
+      pinned: true
+    };
+  }
   function questionResource(target) {
     const status = guard.status();
     return `workflow/${target}/${status.unit?.unitId ?? status.epoch?.epochId ?? "unknown"}`;
@@ -11330,17 +11910,14 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    const current = await options.observer?.snapshot();
-    if (!current || current.status === "unavailable") {
-      markUnavailable();
-      return;
-    }
+    try {
+      await options.observer?.snapshot();
+    } catch {}
     const currentStatus = guard.status();
     if (!currentStatus.epoch || !currentStatus.unit)
       return;
     const expectedWorkspace = childLedger.digestIdentity("workspace", parentBefore.workspaceIdentity);
-    const expectedRepository = childLedger.digestIdentity("repository", current.snapshot.repositoryRevisionDigest);
-    const expectedWorktree = childLedger.digestIdentity("worktree", current.snapshot.worktreeRevisionDigest);
+    let batchTargetIdentity = currentStatus.unit.pinnedOperationTargetIdentity;
     const candidates = [];
     for (const childReceipt of recovered.receipts) {
       const operation = childReceipt.canonical.operation;
@@ -11350,15 +11927,66 @@ function createSessionRuntime(options) {
         markUnavailable();
         return;
       }
+      const targetIdentity = childReceipt.canonical.operationTargetIdentity;
+      if (!targetIdentity) {
+        markUnavailable();
+        return;
+      }
+      if (batchTargetIdentity !== undefined && targetIdentity !== batchTargetIdentity) {
+        markUnavailable();
+        return;
+      }
+      batchTargetIdentity = targetIdentity;
+      const registration = operationObserverRegistration(targetIdentity);
+      if (!registration || !options.observer) {
+        markUnavailable();
+        return;
+      }
+      let validation;
+      try {
+        validation = options.observer.validateRegisteredWorktree(registration.targetRoot);
+      } catch {
+        markUnavailable();
+        return;
+      }
+      if (validation.status === "error" || validation.targetRoot !== registration.targetRoot || registeredWorktreeIdentity(validation) !== registration.registeredWorktreeIdentity || registration.observer.targetDigest !== targetIdentity) {
+        markUnavailable();
+        return;
+      }
+      let targetResult;
+      try {
+        targetResult = await registration.observer.snapshot();
+      } catch {
+        markUnavailable();
+        return;
+      }
+      if (targetResult.status === "unavailable" || targetResult.snapshot.targetDigest !== targetIdentity) {
+        markUnavailable();
+        return;
+      }
+      const recoveredContext = recoveredOperationContexts.get(childReceipt.canonical.receiptId);
+      if (recoveredContext && recoveredContext.targetIdentity !== targetIdentity || targetIdentity !== options.observer.targetDigest && !recoveredContext) {
+        markUnavailable();
+        return;
+      }
+      const expectedRepository = childLedger.digestIdentity("repository", targetResult.snapshot.repositoryRevisionDigest);
+      const expectedWorktree = childLedger.digestIdentity("worktree", targetResult.snapshot.worktreeRevisionDigest);
       if (childReceipt.canonical.repositoryDigest !== expectedRepository || childReceipt.canonical.worktreeDigest !== expectedWorktree) {
         continue;
       }
-      candidates.push(childReceipt);
+      candidates.push({
+        receipt: childReceipt,
+        snapshot: targetResult.snapshot,
+        before: recoveredContext?.before
+      });
     }
     let minted = false;
-    for (const childReceipt of candidates) {
+    for (const candidate of candidates) {
+      const childReceipt = candidate.receipt;
+      const targetSnapshot = candidate.snapshot;
       const operation = childReceipt.canonical.operation;
       const parentContext = guard.currentOperationContext();
+      const beforeSnapshot = candidate.before;
       const callID = `task-${host.callID}-${childReceipt.canonical.receiptId}`;
       const observation = {
         callId: callID,
@@ -11368,13 +11996,15 @@ function createSessionRuntime(options) {
           epochId: currentStatus.epoch.epochId,
           unitId: currentStatus.unit.unitId,
           workspaceIdentity: parentContext.workspaceIdentity,
-          ...parentContext.repositoryIdentity ? { repositoryIdentity: parentContext.repositoryIdentity } : {},
-          ...parentContext.worktreeIdentity ? { worktreeIdentity: parentContext.worktreeIdentity } : {}
+          operationTargetIdentity: childReceipt.canonical.operationTargetIdentity,
+          repositoryIdentity: beforeSnapshot?.repositoryRevisionDigest ?? parentContext.repositoryIdentity ?? targetSnapshot.repositoryRevisionDigest,
+          worktreeIdentity: beforeSnapshot?.worktreeRevisionDigest ?? parentContext.worktreeIdentity ?? targetSnapshot.worktreeRevisionDigest
         },
         after: {
           workspaceIdentity: parentContext.workspaceIdentity,
-          repositoryIdentity: current.snapshot.repositoryRevisionDigest,
-          worktreeIdentity: current.snapshot.worktreeRevisionDigest
+          operationTargetIdentity: childReceipt.canonical.operationTargetIdentity,
+          repositoryIdentity: targetSnapshot.repositoryRevisionDigest,
+          worktreeIdentity: targetSnapshot.worktreeRevisionDigest
         },
         terminal: {
           status: "success",
@@ -11477,35 +12107,37 @@ function createSessionRuntime(options) {
     abandonPending();
     if (!options.observer)
       return;
-    let result;
-    try {
-      result = await options.observer.snapshot();
-    } catch {
+    const effective = effectiveOperationObserver();
+    if (!effective) {
       markUnavailable();
       return;
     }
-    if (result.status === "unavailable") {
+    let result;
+    try {
+      result = await effective.observer.snapshot();
+    } catch {
       markUnavailable();
       return;
     }
-    if (result.snapshot.targetDigest !== options.workspaceIdentity) {
+    if (result.status === "unavailable" || result.snapshot.targetDigest !== effective.targetIdentity) {
       markUnavailable();
       return;
     }
     const observed = guard.observeReadback({
       workspaceIdentity: options.workspaceIdentity,
       repositoryIdentity: result.snapshot.repositoryRevisionDigest,
-      worktreeIdentity: result.snapshot.worktreeRevisionDigest
+      worktreeIdentity: result.snapshot.worktreeRevisionDigest,
+      ...effective.pinned ? { operationTargetIdentity: effective.targetIdentity } : {}
     });
-    if (observed.status === "rejected" && observed.reasonCode === "workspace-mismatch" || !await refreshRemoteReadbacks(result.snapshot)) {
+    if (observed.status === "rejected" && observed.reasonCode === "workspace-mismatch" || !await refreshRemoteReadbacks(effective.observer, result.snapshot)) {
       markUnavailable();
     }
   }
-  async function refreshRemoteReadbacks(local) {
+  async function refreshRemoteReadbacks(observer, local) {
     const remoteOperations = guard.status().satisfiedOperations.filter(remoteOperation);
     if (remoteOperations.length === 0)
       return true;
-    const remoteSnapshot = options.observer?.remoteSnapshot;
+    const remoteSnapshot = observer.remoteSnapshot;
     if (!remoteSnapshot)
       return false;
     for (const operation of remoteOperations) {
@@ -11711,7 +12343,7 @@ function createSessionRuntime(options) {
     }
     blockedCompletes.set(callDigest, target);
   }
-  async function remoteIntentForOperation(host, args2) {
+  async function remoteIntentForOperation(host, args2, observer) {
     if (host.tool !== "bash" || !isRecord7(args2))
       return;
     const command = bashCommand(args2);
@@ -11720,7 +12352,7 @@ function createSessionRuntime(options) {
     const classification = await classifyCommandIntent(options.classifier, command);
     if (!classification || !remoteOperation(classification.category))
       return;
-    const remoteSnapshot = options.observer?.remoteSnapshot;
+    const remoteSnapshot = observer.remoteSnapshot;
     if (!remoteSnapshot)
       return { operation: classification.category };
     try {
@@ -11744,9 +12376,40 @@ function createSessionRuntime(options) {
     if (bindCall(callDigest, "operation", `${host.tool}:${fingerprint}`) !== "new") {
       return;
     }
+    const parentTargetRoot = options.targetDirectory ?? process.cwd();
+    const sessionLocation = options.sessionLocation ?? parentTargetRoot;
+    const target = deriveOpencodeOperationTarget(host.tool, args2, {
+      parentTargetRoot,
+      sessionLocation,
+      validateRegisteredWorktree: options.observer.validateRegisteredWorktree
+    });
+    if (target.status === "unavailable") {
+      markUnavailable();
+      return;
+    }
+    let registeredTarget;
+    try {
+      registeredTarget = options.observer.validateRegisteredWorktree(target.targetRoot);
+    } catch {
+      markUnavailable();
+      return;
+    }
+    const registeredIdentity = registeredWorktreeIdentity(registeredTarget);
+    if (registeredTarget.status !== "ok" || registeredIdentity === undefined || registeredTarget.targetRoot !== target.targetRoot) {
+      markUnavailable();
+      return;
+    }
+    const canonicalParentTargetRoot = canonicalExistingPath(parentTargetRoot, fs10.realpathSync);
+    if (!canonicalParentTargetRoot) {
+      markUnavailable();
+      return;
+    }
+    const operationObserver = target.targetRoot === canonicalParentTargetRoot ? options.observer : [...operationObservers.values()].find((registration) => registration.targetRoot === target.targetRoot)?.observer ?? createOpencodeOperationObserver({
+      targetDirectory: target.targetRoot
+    });
     let result;
     try {
-      result = await options.observer.snapshot();
+      result = await operationObserver.snapshot();
     } catch {
       markUnavailable();
       return;
@@ -11755,15 +12418,24 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    if (result.snapshot.targetDigest !== options.workspaceIdentity) {
+    if (result.snapshot.targetDigest !== operationObserver.targetDigest) {
       markUnavailable();
       return;
     }
-    const remote = await remoteIntentForOperation(host, args2);
+    rememberOperationObserver({
+      targetRoot: target.targetRoot,
+      registeredWorktreeIdentity: registeredIdentity,
+      observer: operationObserver
+    });
+    const remote = await remoteIntentForOperation(host, args2, operationObserver);
     pendingOperations.set(callDigest, {
       callID: host.callID,
       tool: host.tool,
       argsFingerprint: fingerprint,
+      targetRoot: target.targetRoot,
+      targetIdentity: operationObserver.targetDigest,
+      registeredWorktreeIdentity: registeredIdentity,
+      observer: operationObserver,
       before: result.snapshot,
       ...remote ? { remoteOperation: remote.operation, remoteBefore: remote.before } : {}
     });
@@ -12079,44 +12751,87 @@ function createSessionRuntime(options) {
   async function completionReadbacks() {
     if (!options.observer)
       return { status: "none" };
-    let result;
+    let parentResult;
     try {
-      result = await options.observer.snapshot();
+      parentResult = await options.observer.snapshot();
     } catch {
       return { status: "unavailable" };
     }
-    if (result.status === "unavailable" || result.snapshot.targetDigest !== options.workspaceIdentity) {
+    if (parentResult.status === "unavailable" || parentResult.snapshot.targetDigest !== options.workspaceIdentity) {
+      return { status: "unavailable" };
+    }
+    const effective = effectiveOperationObserver();
+    if (!effective)
       return { status: "unavailable" };
+    let effectiveSnapshot = parentResult.snapshot;
+    if (effective.pinned) {
+      let pinnedResult;
+      try {
+        pinnedResult = await effective.observer.snapshot();
+      } catch {
+        return { status: "unavailable" };
+      }
+      if (pinnedResult.status === "unavailable" || pinnedResult.snapshot.targetDigest !== effective.targetIdentity) {
+        return { status: "unavailable" };
+      }
+      effectiveSnapshot = pinnedResult.snapshot;
     }
-    const remoteReadbacks = await completionRemoteReadbacks();
+    const initialEffectiveSnapshot = effectiveSnapshot;
+    const remoteReadbacks = await completionRemoteReadbacks(effective.observer);
     if (!remoteReadbacks)
       return { status: "unavailable" };
-    let finalResult;
+    let finalParentResult;
     try {
-      finalResult = await options.observer.snapshot();
+      finalParentResult = await options.observer.snapshot();
     } catch {
       return { status: "unavailable" };
     }
-    if (finalResult.status === "unavailable" || finalResult.snapshot.targetDigest !== result.snapshot.targetDigest || finalResult.snapshot.repositoryRevisionDigest !== result.snapshot.repositoryRevisionDigest || finalResult.snapshot.worktreeRevisionDigest !== result.snapshot.worktreeRevisionDigest) {
+    if (finalParentResult.status === "unavailable" || finalParentResult.snapshot.targetDigest !== parentResult.snapshot.targetDigest || finalParentResult.snapshot.repositoryRevisionDigest !== parentResult.snapshot.repositoryRevisionDigest || finalParentResult.snapshot.worktreeRevisionDigest !== parentResult.snapshot.worktreeRevisionDigest) {
       return { status: "unavailable" };
     }
+    let finalEffective = effective;
+    if (effective.pinned) {
+      const revalidated = effectiveOperationObserver();
+      if (!revalidated)
+        return { status: "unavailable" };
+      finalEffective = revalidated;
+      if (finalEffective.observer !== effective.observer || finalEffective.targetIdentity !== effective.targetIdentity || !finalEffective.pinned) {
+        return { status: "unavailable" };
+      }
+      let pinnedResult;
+      try {
+        pinnedResult = await finalEffective.observer.snapshot();
+      } catch {
+        return { status: "unavailable" };
+      }
+      if (pinnedResult.status === "unavailable" || pinnedResult.snapshot.targetDigest !== finalEffective.targetIdentity) {
+        return { status: "unavailable" };
+      }
+      effectiveSnapshot = pinnedResult.snapshot;
+      if (effectiveSnapshot.repositoryRevisionDigest !== initialEffectiveSnapshot.repositoryRevisionDigest || effectiveSnapshot.worktreeRevisionDigest !== initialEffectiveSnapshot.worktreeRevisionDigest) {
+        return { status: "unavailable" };
+      }
+    } else {
+      effectiveSnapshot = finalParentResult.snapshot;
+    }
     return {
       status: "ready",
       readbacks: [
         {
           workspaceIdentity: options.workspaceIdentity,
-          repositoryIdentity: finalResult.snapshot.repositoryRevisionDigest,
-          worktreeIdentity: finalResult.snapshot.worktreeRevisionDigest
+          repositoryIdentity: effectiveSnapshot.repositoryRevisionDigest,
+          worktreeIdentity: effectiveSnapshot.worktreeRevisionDigest,
+          operationTargetIdentity: finalEffective.targetIdentity
         },
-        ...remoteReadbacks.map(({ operation, snapshot }) => remoteReadbackInput(operation, finalResult.snapshot, options.workspaceIdentity, snapshot))
+        ...remoteReadbacks.map(({ operation, snapshot }) => remoteReadbackInput(operation, effectiveSnapshot, options.workspaceIdentity, snapshot))
       ]
     };
   }
-  async function completionRemoteReadbacks() {
+  async function completionRemoteReadbacks(observer) {
     const remoteOperations = guard.status().satisfiedOperations.filter(remoteOperation);
     if (remoteOperations.length === 0)
       return [];
-    const remoteSnapshot = options.observer?.remoteSnapshot;
+    const remoteSnapshot = observer.remoteSnapshot;
     if (!remoteSnapshot)
       return;
     const readbacks = [];
@@ -12185,19 +12900,28 @@ function createSessionRuntime(options) {
     }
     return pending;
   }
-  async function captureAfterOperation() {
+  async function captureAfterOperation(pending) {
     if (!options.observer)
       return;
+    let validation;
+    try {
+      validation = options.observer.validateRegisteredWorktree(pending.targetRoot);
+    } catch {
+      return;
+    }
+    if (validation.status === "error" || validation.targetRoot !== pending.targetRoot || registeredWorktreeIdentity(validation) !== pending.registeredWorktreeIdentity) {
+      return;
+    }
     let result;
     try {
-      result = await options.observer.snapshot();
+      result = await pending.observer.snapshot();
     } catch {
       return;
     }
-    return result.status === "available" && result.snapshot.targetDigest === options.workspaceIdentity ? result.snapshot : undefined;
+    return result.status === "available" && result.snapshot.targetDigest === pending.targetIdentity ? result.snapshot : undefined;
   }
-  async function captureRemoteAfter(operation) {
-    const remoteSnapshot = options.observer?.remoteSnapshot;
+  async function captureRemoteAfter(operation, observer) {
+    const remoteSnapshot = observer.remoteSnapshot;
     if (!remoteSnapshot)
       return;
     let result;
@@ -12231,6 +12955,7 @@ function createSessionRuntime(options) {
         workspaceIdentity: options.workspaceIdentity,
         repositoryIdentity: pending.before.repositoryRevisionDigest,
         worktreeIdentity: pending.before.worktreeRevisionDigest,
+        ...localOperation(operation) ? { operationTargetIdentity: pending.targetIdentity } : {},
         ...pending.remoteBefore?.status === "available" ? {
           resourceIdentity: pending.remoteBefore.snapshot.resourceIdentity,
           resourceRevisionIdentity: pending.remoteBefore.snapshot.resourceRevisionIdentity
@@ -12240,6 +12965,7 @@ function createSessionRuntime(options) {
         workspaceIdentity: options.workspaceIdentity,
         repositoryIdentity: after2.repositoryRevisionDigest,
         worktreeIdentity: after2.worktreeRevisionDigest,
+        ...localOperation(operation) ? { operationTargetIdentity: pending.targetIdentity } : {},
         commitClosure: after2.commitClosure,
         ...remoteAfter ? {
           resourceIdentity: remoteAfter.resourceIdentity,
@@ -12292,7 +13018,7 @@ function createSessionRuntime(options) {
       sealOperation(callDigest, pending, true);
       return { status: "unavailable" };
     }
-    const afterSnapshot = await captureAfterOperation();
+    const afterSnapshot = await captureAfterOperation(pending);
     if (!afterSnapshot) {
       sealOperation(callDigest, pending, true);
       return { status: "unavailable" };
@@ -12309,7 +13035,7 @@ function createSessionRuntime(options) {
     }
     let finalObservation = classification.observation;
     if (remoteOperation(finalObservation.operation)) {
-      const remoteAfter = await captureRemoteAfter(finalObservation.operation);
+      const remoteAfter = await captureRemoteAfter(finalObservation.operation, pending.observer);
       if (!remoteAfter) {
         sealOperation(callDigest, pending, true);
         return { status: "unavailable" };
@@ -12346,7 +13072,11 @@ function createSessionRuntime(options) {
     }
     if (observed.status !== "accepted")
       return { status: "ignored" };
-    return { status: "accepted", operation: observed.operation };
+    return {
+      status: "accepted",
+      operation: observed.operation,
+      after: afterSnapshot
+    };
   }
   function receiptForOperation(callID, operation) {
     const callDigest = digestCall(ledger, callID);
@@ -12390,8 +13120,16 @@ function createSessionRuntime(options) {
     }
     if (result.status === "accepted") {
       const receipt = receiptForOperation(host.callID, result.operation);
-      if (receipt)
+      if (receipt) {
+        if (localOperation(result.operation)) {
+          recoveredOperationContexts.set(receipt.canonical.receiptId, {
+            targetIdentity: pending.targetIdentity,
+            before: pending.before,
+            after: result.after
+          });
+        }
         mergeReceiptMarker(output, receipt);
+      }
     }
   }
   async function after(input, output) {
@@ -12557,6 +13295,8 @@ function makeWorkflowTool(description, args2, getRuntime, execute) {
 }
 function createOpencodeWorkflowGuard(options) {
   const sessions = new Map;
+  const operationObservers = new Map;
+  const recoveredOperationContexts = new Map;
   function sessionRuntimeFor(sessionID) {
     const existing = sessions.get(sessionID);
     if (existing)
@@ -12565,7 +13305,7 @@ function createOpencodeWorkflowGuard(options) {
       ...options,
       registrationIdentity: options.registrationIdentity,
       sessionSalt: options.sessionSalt
-    });
+    }, operationObservers, recoveredOperationContexts);
     sessions.set(sessionID, runtime);
     return runtime;
   }
@@ -12694,8 +13434,8 @@ function createOpencodeWorkflowGuard(options) {
 }
 
 // src/lib/skill-resolver.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 function getAllSkills(options) {
   const { bundledSkillsDir, disabledSkills } = options;
@@ -12731,7 +13471,7 @@ function buildSkillToolParameterHint(options) {
 }
 function buildSkillContentOutput(matchedSkill) {
   const body2 = extractSkillBody(matchedSkill.wrappedTemplate);
-  const dir = path9.dirname(matchedSkill.skillFile);
+  const dir = path10.dirname(matchedSkill.skillFile);
   const base = pathToFileURL2(dir).href;
   const files = discoverSkillFiles(dir);
   const lines = [
@@ -12762,17 +13502,17 @@ function discoverSkillFiles(dir, limit = 10) {
   function handleEntry(entry, currentDir) {
     if (entry.isDirectory()) {
       if (!shouldSkipDirectory(entry.name)) {
-        recurse(path9.resolve(currentDir, entry.name));
+        recurse(path10.resolve(currentDir, entry.name));
       }
     } else if (shouldIncludeFile(entry.name)) {
-      files.push(path9.resolve(currentDir, entry.name));
+      files.push(path10.resolve(currentDir, entry.name));
     }
   }
   function recurse(currentDir) {
     if (files.length >= limit)
       return;
     try {
-      const entries = fs10.readdirSync(currentDir, { withFileTypes: true });
+      const entries = fs11.readdirSync(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= limit)
           break;
@@ -12829,19 +13569,19 @@ function createSkillTool(options) {
 }
 
 // src/index.ts
-var __dirname3 = path10.dirname(fileURLToPath3(import.meta.url));
-var packageRoot2 = path10.resolve(__dirname3, "..");
-var bundledSkillsDir = path10.join(packageRoot2, "skills");
-var bundledAgentsDir2 = path10.join(packageRoot2, "agents");
-var bundledCommandsDir = path10.join(packageRoot2, "commands");
-var packageJsonPath = path10.join(packageRoot2, "package.json");
-var canonicalPackageSource = pathToFileURL3(fs11.realpathSync(packageRoot2)).href;
+var __dirname3 = path11.dirname(fileURLToPath3(import.meta.url));
+var packageRoot2 = path11.resolve(__dirname3, "..");
+var bundledSkillsDir = path11.join(packageRoot2, "skills");
+var bundledAgentsDir2 = path11.join(packageRoot2, "agents");
+var bundledCommandsDir = path11.join(packageRoot2, "commands");
+var packageJsonPath = path11.join(packageRoot2, "package.json");
+var canonicalPackageSource = pathToFileURL3(fs12.realpathSync(packageRoot2)).href;
 var registrationSourceIdentity = createHash5("sha256").update(`systematic/opencode-registration-source/v1/${canonicalPackageSource}`).digest("hex");
 var getPackageVersion = () => {
   try {
-    if (!fs11.existsSync(packageJsonPath))
+    if (!fs12.existsSync(packageJsonPath))
       return "unknown";
-    const content = fs11.readFileSync(packageJsonPath, "utf8");
+    const content = fs12.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(content);
     return parsed.version ?? "unknown";
   } catch {
@@ -12889,6 +13629,8 @@ var initializePlugin = async ({
     repositoryIdentity: initialIdentities.repositoryRevisionDigest,
     worktreeIdentity: initialIdentities.worktreeRevisionDigest,
     registrationIdentity: registrationSourceIdentity,
+    targetDirectory: typeof worktree === "string" ? worktree : directory,
+    sessionLocation: directory,
     observer,
     classifier: createReceiptClassifier(),
     hostReadback: (() => {