mancode 0.6.4 → 0.6.6

package/dist/{chunk-7HPP3KYG.js → chunk-D5ABGAF4.js}

@@ -1,239 +1,40 @@
-// src/context/store.ts
-import { lstat as lstat4, readFile as readFile7, readdir as readdir4 } from "fs/promises";
-import path9 from "path";
-
-// src/runtime/entity-home-store.ts
-import path from "path";
-
-// src/context/ids.ts
-import { randomBytes } from "crypto";
-var CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ULID_PATTERN = /^[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}$/;
-var MAX_ULID_TIMESTAMP = 2 ** 48 - 1;
-function isUlid(value) {
-  return typeof value === "string" && ULID_PATTERN.test(value);
-}
-function assertUlid(value, label = "ULID") {
-  if (!isUlid(value)) {
-    throw new Error(`${label} must be a canonical ULID`);
-  }
-}
-function createUlid(now = Date.now(), entropy = randomBytes(10)) {
-  if (!Number.isSafeInteger(now) || now < 0 || now > MAX_ULID_TIMESTAMP) {
-    throw new Error("ULID timestamp must fit in 48 bits");
-  }
-  if (entropy.length !== 10) {
-    throw new Error("ULID entropy must contain exactly 10 bytes");
-  }
-  const timestamp = encodeBase32(BigInt(now), 10);
-  const random = encodeBase32(
-    BigInt(`0x${Buffer.from(entropy).toString("hex")}`),
-    16
-  );
-  return `${timestamp}${random}`;
-}
-function encodeBase32(value, length) {
-  let remaining = value;
-  let encoded = "";
-  for (let index = 0; index < length; index += 1) {
-    encoded = `${CROCKFORD_BASE32[Number(remaining & 31n)]}${encoded}`;
-    remaining >>= 5n;
-  }
-  if (remaining !== 0n) {
-    throw new Error("value does not fit in requested base32 length");
-  }
-  return encoded;
-}
-
-// src/context/validation.ts
-function isRecord(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function assertRecord(value, label) {
-  if (!isRecord(value)) {
-    throw new Error(`${label} must be an object`);
-  }
-}
-function assertKnownKeys(value, allowedKeys, label) {
-  const allowed = new Set(allowedKeys);
-  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
-  if (unknown.length > 0) {
-    throw new Error(
-      `${label} contains unknown field(s): ${unknown.join(", ")}`
-    );
-  }
-}
-
-// src/context/task-ref.ts
-var TASK_REF_PATTERN = /^(local|shared):([0-7][0-9A-HJKMNPQRSTVWXYZ]{25})$/;
-function formatTaskRef(taskRef) {
-  assertTaskRef(taskRef);
-  return `${taskRef.namespace}:${taskRef.taskId}`;
-}
-function parseTaskRef(input) {
-  if (typeof input !== "string") {
-    throw new Error("TaskRef must be a string in namespace:ULID form");
-  }
-  const match = TASK_REF_PATTERN.exec(input);
-  if (!match) {
-    throw new Error("TaskRef must use local:<ULID> or shared:<ULID>");
-  }
-  return {
-    namespace: match[1],
-    taskId: match[2]
-  };
-}
-function parseTaskRefValue(value) {
-  assertRecord(value, "TaskRef");
-  assertKnownKeys(value, ["namespace", "taskId"], "TaskRef");
-  if (value.namespace !== "local" && value.namespace !== "shared") {
-    throw new Error("TaskRef namespace must be local or shared");
-  }
-  assertUlid(value.taskId, "TaskRef taskId");
-  return {
-    namespace: value.namespace,
-    taskId: value.taskId
-  };
-}
-function assertTaskRef(value) {
-  parseTaskRefValue(value);
-}
-function sameTaskRef(left, right) {
-  return left.namespace === right.namespace && left.taskId === right.taskId;
-}
+import {
+  assertKnownKeys,
+  assertRecord,
+  assertUlid,
+  claimDirectory,
+  createUlid,
+  digestCanonicalJson,
+  handoffDirectory,
+  lockDirectory,
+  operationDirectory,
+  parseProjectConfig,
+  parseTaskRef,
+  parseTaskRefValue,
+  parseTeamPolicy,
+  readProjectRuntimeContext,
+  reservationDirectory,
+  resolveLocalEntityHomeStore,
+  sameTaskRef,
+  sortUtf8StringSet,
+  taskHeadDirectory
+} from "./chunk-WRBNOPFA.js";
+import {
+  DEFAULT_RULE_IDS,
+  RULESET_VERSION,
+  scanSensitiveText
+} from "./chunk-IRZQYMHD.js";
 
-// src/runtime/entity-home-store.ts
-function resolveTaskEntityHomeStore(context, taskRef) {
-  const normalized = normalizeContext(context);
-  const task = parseTaskRefValue(taskRef);
-  return task.namespace === "local" ? localTaskHomeStore(normalized) : coordinationEntityHomeStore(normalized);
-}
-function resolveLocalEntityHomeStore(context) {
-  return localTaskHomeStore(normalizeContext(context));
-}
-function resolveCoordinationEntityHomeStore(context) {
-  return coordinationEntityHomeStore(normalizeContext(context));
-}
-function operationDirectory(store) {
-  return path.join(store.root, "operations");
-}
-function reservationDirectory(store) {
-  return path.join(store.root, "reservations");
-}
-function lockDirectory(store) {
-  return path.join(store.root, "locks");
-}
-function claimDirectory(store) {
-  assertCoordinationStore(store, "claim");
-  return path.join(store.root, "claims");
-}
-function handoffDirectory(store) {
-  assertCoordinationStore(store, "handoff");
-  return path.join(store.root, "handoffs");
-}
-function taskHeadDirectory(store) {
-  assertCoordinationStore(store, "task head fence");
-  return path.join(store.root, "task-heads");
-}
-function normalizeContext(context) {
-  assertUlid(context.workspaceId, "entity home store workspaceId");
-  assertUlid(context.checkoutId, "entity home store checkoutId");
-  if (typeof context.projectRoot !== "string" || !context.projectRoot.trim()) {
-    throw new Error("entity home store projectRoot is required");
-  }
-  if (context.gitCommonDir === null) {
-    if (context.repositoryBindingId !== null) {
-      assertUlid(
-        context.repositoryBindingId,
-        "entity home store repositoryBindingId"
-      );
-    }
-    return {
-      ...context,
-      projectRoot: path.resolve(context.projectRoot),
-      gitCommonDir: null
-    };
-  }
-  if (typeof context.gitCommonDir !== "string" || !context.gitCommonDir.trim()) {
-    throw new Error("entity home store gitCommonDir must be a path or null");
-  }
-  if (context.repositoryBindingId === null) {
-    throw new Error(
-      "git coordination requires an entity home store repositoryBindingId"
-    );
-  }
-  assertUlid(
-    context.repositoryBindingId,
-    "entity home store repositoryBindingId"
-  );
-  return {
-    ...context,
-    projectRoot: path.resolve(context.projectRoot),
-    gitCommonDir: path.resolve(context.gitCommonDir)
-  };
-}
-function localTaskHomeStore(context) {
-  return {
-    kind: "checkout_local",
-    storeId: `checkout:${context.checkoutId}:${context.workspaceId}`,
-    root: path.join(context.projectRoot, ".mancode", "local", "runtime"),
-    workspaceId: context.workspaceId,
-    checkoutId: context.checkoutId,
-    repositoryBindingId: context.repositoryBindingId
-  };
-}
-function coordinationEntityHomeStore(context) {
-  if (context.gitCommonDir === null) {
-    return {
-      kind: "non_git_shared",
-      storeId: `non-git:${context.workspaceId}`,
-      root: path.join(
-        context.projectRoot,
-        ".mancode",
-        "runtime",
-        "non-git",
-        context.workspaceId
-      ),
-      workspaceId: context.workspaceId,
-      checkoutId: null,
-      repositoryBindingId: context.repositoryBindingId
-    };
-  }
-  if (context.repositoryBindingId === null) {
-    throw new Error("git coordination requires a repositoryBindingId");
-  }
-  return {
-    kind: "workspace_common_dir",
-    storeId: `workspace:${context.repositoryBindingId}:${context.workspaceId}`,
-    root: path.join(
-      context.gitCommonDir,
-      "mancode",
-      "workspaces",
-      context.workspaceId
-    ),
-    workspaceId: context.workspaceId,
-    checkoutId: null,
-    repositoryBindingId: context.repositoryBindingId
-  };
-}
-function assertCoordinationStore(store, entity) {
-  if (store.kind === "checkout_local") {
-    throw new Error(
-      `${entity} requires a shared coordination entity home store`
-    );
-  }
-}
+// src/context/store.ts
+import { lstat as lstat7, readFile as readFile10, readdir as readdir7 } from "fs/promises";
+import path12 from "path";
 
 // src/runtime/git-ref-workflow-repair-store.ts
 import { lstat, readFile, readdir } from "fs/promises";
-import path2 from "path";
+import path from "path";
 function gitRefWorkflowRepairJournalDirectory(projectRoot) {
-  return path2.join(
-    path2.resolve(projectRoot),
+  return path.join(
+    path.resolve(projectRoot),
     ".mancode",
     "local",
     "journals",
@@ -242,7 +43,7 @@ function gitRefWorkflowRepairJournalDirectory(projectRoot) {
 }
 function gitRefWorkflowRepairJournalPath(projectRoot, operationId) {
   assertUlid(operationId, "git-ref workflow repair operationId");
-  return path2.join(
+  return path.join(
     gitRefWorkflowRepairJournalDirectory(projectRoot),
     `${operationId}.json`
   );
@@ -253,7 +54,7 @@ async function listGitRefWorkflowRepairJournalSummaries(projectRoot, options = {
   const summaries = [];
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const journalPath = path2.join(directory, entry);
+    const journalPath = path.join(directory, entry);
     let summary;
     try {
       summary = parseSummary(
@@ -372,109 +173,8 @@ function isNotFound(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
-// src/context/canonical.ts
-import { createHash } from "crypto";
-function canonicalizeJson(value, options = {}) {
-  return canonicalizeValue(value, options.numberPolicy ?? "safe-integer");
-}
-function digestCanonicalJson(value, options = {}) {
-  const canonical = canonicalizeJson(value, options);
-  return `sha256:${createHash("sha256").update(canonical, "utf8").digest("hex")}`;
-}
-function sortUtf8StringSet(values) {
-  const unique = /* @__PURE__ */ new Set();
-  for (const value of values) {
-    assertCanonicalString(value, "set item");
-    unique.add(value);
-  }
-  return [...unique].sort(
-    (left, right) => Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"))
-  );
-}
-function canonicalizeValue(value, numberPolicy) {
-  if (value === null) return "null";
-  if (typeof value === "string") {
-    assertCanonicalString(value, "string");
-    return JSON.stringify(value);
-  }
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || Object.is(value, -0)) {
-      throw new Error(
-        "canonical JSON numbers must be finite and must not be negative zero"
-      );
-    }
-    if (numberPolicy === "safe-integer" && !Number.isSafeInteger(value)) {
-      throw new Error(
-        "canonical JSON numbers must be safe integers for this schema"
-      );
-    }
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    assertCanonicalArray(value);
-    return `[${value.map((item) => canonicalizeValue(item, numberPolicy)).join(",")}]`;
-  }
-  if (isPlainObject(value)) {
-    assertCanonicalObject(value);
-    const keys = Object.keys(value).sort();
-    return `{${keys.map((key) => {
-      assertCanonicalString(key, "object key");
-      return `${JSON.stringify(key)}:${canonicalizeValue(value[key], numberPolicy)}`;
-    }).join(",")}}`;
-  }
-  throw new Error("canonical JSON only accepts plain JSON values");
-}
-function assertCanonicalArray(value) {
-  for (let index = 0; index < value.length; index += 1) {
-    if (!Object.hasOwn(value, index)) {
-      throw new Error("canonical JSON arrays must not be sparse");
-    }
-  }
-  const ownKeys = Object.keys(value);
-  if (ownKeys.some((key) => !/^(0|[1-9]\d*)$/.test(key))) {
-    throw new Error("canonical JSON arrays must not have non-index properties");
-  }
-  if (Object.getOwnPropertyNames(value).some(
-    (key) => key !== "length" && !ownKeys.includes(key)
-  ) || Object.getOwnPropertySymbols(value).length > 0) {
-    throw new Error("canonical JSON arrays must not have hidden properties");
-  }
-}
-function assertCanonicalObject(value) {
-  const ownKeys = Object.keys(value);
-  if (Object.getOwnPropertyNames(value).some((key) => !ownKeys.includes(key)) || Object.getOwnPropertySymbols(value).length > 0) {
-    throw new Error("canonical JSON objects must not have hidden properties");
-  }
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function assertCanonicalString(value, label) {
-  if (value.includes("\0")) {
-    throw new Error(`canonical JSON ${label} must not contain NUL`);
-  }
-  for (let index = 0; index < value.length; index += 1) {
-    const codeUnit = value.charCodeAt(index);
-    if (codeUnit < 55296 || codeUnit > 57343) continue;
-    const next = value.charCodeAt(index + 1);
-    const isHigh = codeUnit <= 56319;
-    const isLowNext = next >= 56320 && next <= 57343;
-    if (!isHigh || !isLowNext) {
-      throw new Error(
-        `canonical JSON ${label} must not contain a lone surrogate`
-      );
-    }
-    index += 1;
-  }
-}
-
 // src/context/privacy.ts
-import path3 from "path";
+import path2 from "path";
 var FINDING_PATTERNS = [
   {
     kind: "private_key",
@@ -516,6 +216,28 @@ function scanSharedText(value) {
   }
   return removeNestedFindings(findings);
 }
+function redactSharedText(value) {
+  assertText(value, "shared text");
+  const findings = scanSharedText(value);
+  if (findings.length === 0) return { text: value, redactions: [] };
+  let redacted = "";
+  let cursor = 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    redacted += value.slice(cursor, finding.start);
+    redacted += `[REDACTED:${finding.kind}]`;
+    cursor = finding.end;
+    counts.set(finding.kind, (counts.get(finding.kind) ?? 0) + 1);
+  }
+  redacted += value.slice(cursor);
+  if (scanSharedText(redacted).length > 0) {
+    throw new Error("MANCODE_PRIVACY_BLOCKED");
+  }
+  return {
+    text: redacted,
+    redactions: [...counts.entries()].sort(([left], [right]) => left.localeCompare(right, "en")).map(([kind, count]) => ({ kind, count }))
+  };
+}
 function assertSharedTextSafe(value, label) {
   assertText(value, label);
   if (scanSharedText(value).length > 0) {
@@ -523,7 +245,7 @@ function assertSharedTextSafe(value, label) {
   }
 }
 function assertSafeSharedRelativePath(value) {
-  if (typeof value !== "string" || !value || value.includes("\0") || path3.isAbsolute(value) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) {
+  if (typeof value !== "string" || !value || value.includes("\0") || path2.isAbsolute(value) || /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) {
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   }
   const normalized = value.split(/[\\/]/);
@@ -1077,6 +799,7 @@ var OPERATION_TYPES = /* @__PURE__ */ new Set([
   "greenfield_initialize",
   "adapter_upgrade",
   "project_policy_upgrade",
+  "privacy_policy_update",
   "v3_activate"
 ]);
 var OPERATION_STATES = /* @__PURE__ */ new Set([
@@ -1275,14 +998,14 @@ function parseSecondaryReservations(value) {
 function parseExpectedRevisions(value) {
   assertRecord(value, "operation expectedRevisions");
   const parsed = {};
-  for (const [entityKey, revision] of Object.entries(value)) {
+  for (const [entityKey, revision2] of Object.entries(value)) {
     assertEntityKey(entityKey, "operation expected revision key");
-    if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 0) {
+    if (typeof revision2 !== "number" || !Number.isSafeInteger(revision2) || revision2 < 0) {
       throw new Error(
         "operation expected revisions must be non-negative integers"
       );
     }
-    parsed[entityKey] = revision;
+    parsed[entityKey] = revision2;
   }
   return parsed;
 }
@@ -1365,9 +1088,9 @@ function assertReframeCheckpointReplacement(previous, next, replacement) {
     throw new Error("MANCODE_REFRAME_CHECKPOINT_REPLACEMENT_INVALID");
   }
   const expectedRevisions = Object.fromEntries(
-    Object.entries(previous.expectedRevisions).map(([key, revision]) => [
+    Object.entries(previous.expectedRevisions).map(([key, revision2]) => [
       key === fromKey ? toKey : key,
-      revision
+      revision2
     ])
   );
   if (JSON.stringify(next.expectedRevisions) !== JSON.stringify(expectedRevisions)) {
@@ -1426,7 +1149,7 @@ function allowedOperationTransitions(from) {
 
 // src/runtime/operation-reservation.ts
 import { mkdir, readFile as readFile2, unlink, writeFile } from "fs/promises";
-import path4 from "path";
+import path3 from "path";
 var DIGEST_PATTERN3 = /^sha256:[a-f0-9]{64}$/;
 var ENTITY_KEY_PATTERN2 = /^[a-z][a-z0-9_-]*:[^\0/\\]+$/;
 function parseOperationReservation(value) {
@@ -1545,7 +1268,7 @@ async function removeOperationReservation(store, operationId, primaryStoreId) {
 }
 function reservationPath(store, operationId) {
   assertUlid(operationId, "operation reservation operationId");
-  return path4.join(reservationDirectory(store), `${operationId}.json`);
+  return path3.join(reservationDirectory(store), `${operationId}.json`);
 }
 function parseEntityKeySet2(value, label) {
   if (!Array.isArray(value) || value.length === 0) {
@@ -4143,16 +3866,16 @@ function parseImplementationScope(value) {
       "workflow metadata implementationScope modules"
     )
   };
-  const digest = parseDigest8(
+  const digest2 = parseDigest8(
     value.digest,
     "workflow metadata implementationScope digest"
   );
-  if (digest !== digestCanonicalJson(scope)) {
+  if (digest2 !== digestCanonicalJson(scope)) {
     throw new Error(
       "workflow metadata implementationScope digest does not match scope"
     );
   }
-  return { ...scope, digest };
+  return { ...scope, digest: digest2 };
 }
 function parseGovernance2(value) {
   assertRecord(value, "workflow metadata governance");
@@ -4455,9 +4178,55 @@ function parseTimestamp8(value, label) {
 function parseTimestampOrNull(value, label) {
   return value === null ? null : parseTimestamp8(value, label);
 }
+function isActiveSoloHandoff(metadata) {
+  return metadata.workflowMode === "man" && metadata.coordination === "single" && metadata.status === "planned" && metadata.governance.planDecision === "solo_handoff" && metadata.soloExecution?.state === "active" && metadata.soloExecution.planVersion === metadata.governance.planVersion;
+}
+function assertSoloHandoffSession(metadata, session) {
+  if (metadata.governance.planDecision !== "solo_handoff") return;
+  if (!isActiveSoloHandoff(metadata) || metadata.soloExecution?.assignedSessionId !== session.sessionId || metadata.ownerActorId !== session.actorId) {
+    throw new Error("MANCODE_SOLO_HANDOFF_NOT_ACTIVE");
+  }
+}
 
 // src/context/aggregate.ts
 var DIGEST_PATTERN9 = /^sha256:[a-f0-9]{64}$/;
+function assertDiagnosticCompletionGate(input, context) {
+  const { metadata, requirements, review, verification } = input;
+  if (metadata.governance.requirementsStatus !== "ready" || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
+    throw new Error("task completion requires ready confirmed requirements");
+  }
+  assertVerificationLedgerRequirements(verification, requirements);
+  assertVerificationLedgerAgainstContext(verification, {
+    requirementsDigest: requirements.contentDigest,
+    planVersion: metadata.governance.planVersion,
+    remediationRound: review.remediationRound
+  });
+  if (context.diagnosticOutcome === "manual_test_required") {
+    if (verification.status !== "manual_required") {
+      throw new Error(
+        "diagnostic completion requires current manual-required evidence"
+      );
+    }
+    for (const check of verification.checks.filter((item) => item.required)) {
+      for (const evidence of [check.automated, check.manual]) {
+        if (evidence === null) continue;
+        if (evidence.status !== "passed" && !(evidence.status === "manual_required" && evidence.summary?.trim())) {
+          throw new Error("diagnostic completion has unresolved verification");
+        }
+      }
+    }
+  } else {
+    if (context.diagnosticOutcome !== "fixed" && context.diagnosticOutcome !== "verified" && context.diagnosticOutcome !== "no_repro") {
+      throw new Error("MANCODE_MANBA_OUTCOME_REQUIRED");
+    }
+    if (verification.status !== "passed") {
+      throw new Error(
+        "task completion requires current required acceptance evidence"
+      );
+    }
+  }
+  assertTaskCompletionContext(metadata, context);
+}
 function buildTaskAggregateManifest(input) {
   assertTaskAggregateConsistency(input);
   const latestCheckpoint = input.latestCheckpoint;
@@ -4579,6 +4348,10 @@ function assertTaskCompletionGate(input, context) {
   if (metadata.transitionState !== "stable") {
     throw new Error("workflows with a pending operation cannot complete");
   }
+  if (metadata.workflowMode === "manba") {
+    assertDiagnosticCompletionGate(input, context);
+    return;
+  }
   if (metadata.governance.planDecision === null) {
     throw new Error("task completion requires a plan decision");
   }
@@ -4586,8 +4359,7 @@ function assertTaskCompletionGate(input, context) {
     assertExecutableImplementationScope(metadata.implementationScope);
   }
   if (metadata.governance.planDecision === "solo_handoff") {
-    assertSoloHandoffCompletionGate(input, context);
-    return;
+    assertSoloHandoffCompletionGate(input);
   }
   if (metadata.soloExecution?.state === "active") {
     throw new Error(
@@ -4619,15 +4391,11 @@ function assertTaskCompletionGate(input, context) {
   }
   assertTaskCompletionContext(metadata, context);
 }
-function assertSoloHandoffCompletionGate(input, context) {
-  const { metadata, requirements } = input;
+function assertSoloHandoffCompletionGate(input) {
+  const { metadata } = input;
   if (metadata.workflowMode !== "man" || metadata.coordination !== "single" || metadata.soloExecution?.state !== "completed" || metadata.soloExecution.planVersion !== metadata.governance.planVersion || input.planDigest === null) {
     throw new Error("task completion solo handoff assignment is invalid");
   }
-  if (metadata.governance.requirementsStatus !== "ready" || requirements.status !== "confirmed" || !requirementsAreReady(requirements)) {
-    throw new Error("task completion requires ready confirmed requirements");
-  }
-  assertTaskCompletionContext(metadata, context);
 }
 function assertRequirementsCache(metadata, requirements) {
   if (metadata.governance.requirementsDigest !== requirements.contentDigest) {
@@ -5590,228 +5358,2110 @@ function allowedHandoffTransitions(from) {
   }
 }
 
-// src/team/policy.ts
-var V3_LAYOUT_VERSION = 3;
-function parseProjectConfig(value) {
-  assertRecord(value, "project config");
-  assertKnownKeys(
-    value,
-    [
-      "schemaVersion",
-      "revision",
-      "workspaceId",
-      "transport",
-      "lastOperationId",
-      "updatedAt"
-    ],
-    "project config"
-  );
-  if (value.schemaVersion !== 1) {
-    throw new Error("project config schemaVersion must be 1");
+// src/context/confirmed-decision.ts
+import { lstat as lstat5, mkdir as mkdir4, readFile as readFile6, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
+import path8 from "path";
+
+// src/context/privacy-guard.ts
+import { lstat as lstat4, readdir as readdir4 } from "fs/promises";
+import path7 from "path";
+import { performance } from "perf_hooks";
+
+// src/runtime/local-lock.ts
+import { createHash, randomUUID } from "crypto";
+import {
+  link,
+  lstat as lstat2,
+  mkdir as mkdir2,
+  readFile as readFile3,
+  rename,
+  rm,
+  writeFile as writeFile2
+} from "fs/promises";
+import path4 from "path";
+var ENTITY_LOCK_KEY_PATTERN = /^[a-z][a-z0-9_-]*:[^\0/\\]+$/;
+var DEFAULT_LOCK_LEASE_MS = 3e4;
+var MINIMUM_LOCK_LEASE_MS = 1e3;
+var MAXIMUM_LOCK_LEASE_MS = 5 * 6e4;
+async function acquireLocalLock(store, input) {
+  const owner = createLockOwner(store, input);
+  const target = lockPath(store, owner.entityLockKey);
+  await mkdir2(lockDirectory(store), { recursive: true });
+  const temporary = temporaryOwnerPath(target);
+  try {
+    await writeOwnerFile(temporary, owner);
+    let acquired = false;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        await link(temporary, target);
+        acquired = true;
+        break;
+      } catch (error) {
+        if (!isAlreadyExists2(error)) throw error;
+        if (!await reclaimExpiredDeadLock(store, owner.entityLockKey, owner)) {
+          throw new Error("MANCODE_LOCK_HELD");
+        }
+      }
+    }
+    if (!acquired) throw new Error("MANCODE_LOCK_HELD");
+  } finally {
+    await rm(temporary, { force: true }).catch(() => void 0);
   }
-  assertUlid(value.workspaceId, "project config workspaceId");
+  let released = false;
+  let currentOwner = owner;
   return {
-    schemaVersion: 1,
-    revision: parsePositiveInteger12(value.revision, "project config revision"),
-    workspaceId: value.workspaceId,
-    transport: parseTransport2(value.transport),
-    lastOperationId: parseUlidOrNull8(
-      value.lastOperationId,
-      "project config lastOperationId"
-    ),
-    updatedAt: parseTimestamp12(value.updatedAt, "project config updatedAt")
+    storeId: store.storeId,
+    entityLockKey: owner.entityLockKey,
+    get owner() {
+      return currentOwner;
+    },
+    async renew(now = /* @__PURE__ */ new Date()) {
+      if (released) throw new Error("MANCODE_LOCK_OWNERSHIP_LOST");
+      const next = renewLockOwner(currentOwner, now);
+      const current = await readLocalLock(store, currentOwner.entityLockKey);
+      if (!sameLockOwner(current, currentOwner)) {
+        throw new Error("MANCODE_LOCK_OWNERSHIP_LOST");
+      }
+      await atomicWriteLockOwner(target, next);
+      currentOwner = next;
+    },
+    async release() {
+      if (released) return;
+      const current = await readLocalLock(store, currentOwner.entityLockKey);
+      if (!sameLockOwner(current, currentOwner)) {
+        throw new Error("MANCODE_LOCK_OWNERSHIP_LOST");
+      }
+      await rm(target, { recursive: true, force: false });
+      released = true;
+    }
   };
 }
-function parseTeamPolicy(value) {
-  assertRecord(value, "team policy");
+async function acquireEntityLocks(store, operationId, entityLockKeys, options = {}) {
+  assertUlid(operationId, "local lock operationId");
+  const orderedKeys = normalizeEntityLockKeys(entityLockKeys);
+  const locks = [];
+  try {
+    for (const entityLockKey of orderedKeys) {
+      locks.push(
+        await acquireLocalLock(store, {
+          operationId,
+          entityLockKey,
+          processId: options.processId,
+          now: options.now,
+          leaseMs: options.leaseMs
+        })
+      );
+    }
+    return locks;
+  } catch (error) {
+    await Promise.allSettled(
+      [...locks].reverse().map((lock) => lock.release())
+    );
+    throw error;
+  }
+}
+async function acquireOperationEntityLocks(operationId, targets, options = {}) {
+  assertUlid(operationId, "operation lock operationId");
+  if (!Array.isArray(targets) || targets.length === 0) {
+    throw new Error("operation lock targets must not be empty");
+  }
+  const byStoreId = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const normalizedKeys = normalizeEntityLockKeys(target.entityLockKeys);
+    const existing = byStoreId.get(target.store.storeId);
+    if (existing !== void 0) {
+      throw new Error("operation lock targets must not repeat a store");
+    }
+    byStoreId.set(target.store.storeId, {
+      store: target.store,
+      entityLockKeys: normalizedKeys
+    });
+  }
+  const locks = [];
+  try {
+    for (const target of [...byStoreId.values()].sort(
+      (left, right) => compareUtf82(left.store.storeId, right.store.storeId)
+    )) {
+      locks.push(
+        ...await acquireEntityLocks(
+          target.store,
+          operationId,
+          target.entityLockKeys,
+          options
+        )
+      );
+    }
+    return locks;
+  } catch (error) {
+    await Promise.allSettled(
+      [...locks].reverse().map((lock) => lock.release())
+    );
+    throw error;
+  }
+}
+async function readLocalLock(store, entityLockKey) {
+  assertEntityLockKey(entityLockKey);
+  try {
+    const target = lockPath(store, entityLockKey);
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const entry = await lstat2(target);
+      if (!entry.isFile() && !entry.isDirectory()) {
+        throw new Error("MANCODE_LOCK_CORRUPT");
+      }
+      let raw;
+      try {
+        raw = await readFile3(
+          entry.isDirectory() ? path4.join(target, "owner.json") : target,
+          "utf8"
+        );
+      } catch (error) {
+        const current = await lstat2(target);
+        if (entry.isDirectory() !== current.isDirectory()) continue;
+        throw error;
+      }
+      const owner = parseLocalLockOwner(JSON.parse(raw));
+      if (owner.storeId !== store.storeId || owner.entityLockKey !== entityLockKey) {
+        throw new Error("MANCODE_LOCK_CORRUPT");
+      }
+      return owner;
+    }
+    throw new Error("MANCODE_LOCK_HELD");
+  } catch (error) {
+    if (isNotFound3(error)) return null;
+    if (error instanceof SyntaxError) throw new Error("MANCODE_LOCK_CORRUPT");
+    throw error;
+  }
+}
+function parseLocalLockOwner(value) {
+  assertRecord(value, "local lock owner");
   assertKnownKeys(
     value,
     [
       "schemaVersion",
-      "revision",
-      "workspaceId",
-      "policy",
-      "recentDays",
-      "defaultVisibility",
-      "shareConfirmedDecisions",
-      "retention",
-      "lastOperationId",
-      "updatedAt"
+      "operationId",
+      "processId",
+      "storeId",
+      "entityLockKey",
+      "acquiredAt",
+      "leaseExpiresAt"
     ],
-    "team policy"
+    "local lock owner"
   );
   if (value.schemaVersion !== 1) {
-    throw new Error("team policy schemaVersion must be 1");
+    throw new Error("local lock owner schemaVersion must be 1");
   }
-  assertUlid(value.workspaceId, "team policy workspaceId");
-  if (value.policy !== "on" && value.policy !== "off" && value.policy !== "auto") {
-    throw new Error("team policy policy is invalid");
+  assertUlid(value.operationId, "local lock operationId");
+  assertEntityLockKey(value.entityLockKey);
+  if (typeof value.processId !== "number" || !Number.isSafeInteger(value.processId) || value.processId < 1) {
+    throw new Error("local lock processId must be a positive integer");
   }
-  if (value.defaultVisibility !== "local" && value.defaultVisibility !== "shared") {
-    throw new Error("team policy defaultVisibility is invalid");
-  }
-  if (typeof value.shareConfirmedDecisions !== "boolean") {
-    throw new Error("team policy shareConfirmedDecisions must be boolean");
+  if (typeof value.storeId !== "string" || !value.storeId.trim()) {
+    throw new Error("local lock storeId is required");
   }
   return {
     schemaVersion: 1,
-    revision: parsePositiveInteger12(value.revision, "team policy revision"),
-    workspaceId: value.workspaceId,
-    policy: value.policy,
-    recentDays: parseNonNegativeInteger9(
-      value.recentDays,
-      "team policy recentDays"
-    ),
-    defaultVisibility: value.defaultVisibility,
-    shareConfirmedDecisions: value.shareConfirmedDecisions,
-    retention: parseRetention(value.retention),
-    lastOperationId: parseUlidOrNull8(
-      value.lastOperationId,
-      "team policy lastOperationId"
-    ),
-    updatedAt: parseTimestamp12(value.updatedAt, "team policy updatedAt")
+    operationId: value.operationId,
+    processId: value.processId,
+    storeId: value.storeId,
+    entityLockKey: value.entityLockKey,
+    acquiredAt: parseTimestamp12(value.acquiredAt, "local lock acquiredAt"),
+    leaseExpiresAt: value.leaseExpiresAt === void 0 ? null : value.leaseExpiresAt === null ? null : parseTimestamp12(value.leaseExpiresAt, "local lock leaseExpiresAt")
   };
 }
-function projectConfigIdentityDigest(config) {
-  return digestCanonicalJson({
-    workspaceId: config.workspaceId,
-    configSchemaVersion: config.schemaVersion,
-    layoutVersion: V3_LAYOUT_VERSION
-  });
-}
-function projectConfigDigest(config) {
-  return digestCanonicalJson(parseProjectConfig(config));
-}
-function assertConfigPolicyConsistency(config, policy) {
-  if (config.workspaceId !== policy.workspaceId) {
-    throw new Error("project config and team policy workspaceId must match");
+function normalizeEntityLockKeys(entityLockKeys) {
+  if (!Array.isArray(entityLockKeys) || entityLockKeys.length === 0) {
+    throw new Error("entity lock keys must be a non-empty array");
   }
+  const keys = /* @__PURE__ */ new Set();
+  for (const key of entityLockKeys) {
+    assertEntityLockKey(key);
+    if (keys.has(key)) throw new Error("entity lock keys must not repeat");
+    keys.add(key);
+  }
+  return [...keys].sort(compareUtf82);
+}
+function createLockOwner(store, input) {
+  assertUlid(input.operationId, "local lock operationId");
+  assertEntityLockKey(input.entityLockKey);
+  const processId = input.processId ?? process.pid;
+  if (!Number.isSafeInteger(processId) || processId < 1) {
+    throw new Error("local lock processId must be a positive integer");
+  }
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const leaseMs = parseLeaseMs(input.leaseMs);
+  return {
+    schemaVersion: 1,
+    operationId: input.operationId,
+    processId,
+    storeId: store.storeId,
+    entityLockKey: input.entityLockKey,
+    acquiredAt: now.toISOString(),
+    leaseExpiresAt: new Date(now.getTime() + leaseMs).toISOString()
+  };
 }
-function assertProjectConfigTransition(previous, next, kind) {
-  assertConfigIdentityStable(previous, next);
-  assertRevisionIncrease(
-    previous.revision,
-    next.revision,
-    "project config revision"
-  );
-  const transportChanged = previous.transport.mode !== next.transport.mode || previous.transport.remote !== next.transport.remote || previous.transport.epoch !== next.transport.epoch;
-  if (transportChanged && kind === "ordinary") {
-    throw new Error(
-      "project config transport may only change through transport_set or transport_migrate"
-    );
+function renewLockOwner(owner, now) {
+  if (owner.leaseExpiresAt === null) {
+    throw new Error("MANCODE_LOCK_LEASE_UNAVAILABLE");
   }
-  if (!transportChanged && kind !== "ordinary") {
-    throw new Error(
-      "transport mutation requires a changed project config transport"
-    );
+  return {
+    ...owner,
+    leaseExpiresAt: new Date(now.getTime() + lockLeaseMs(owner)).toISOString()
+  };
+}
+async function reclaimExpiredDeadLock(store, entityLockKey, contender) {
+  const existing = await readLocalLock(store, entityLockKey);
+  if (existing === null || existing.leaseExpiresAt === null || Date.parse(existing.leaseExpiresAt) >= Date.parse(contender.acquiredAt) || processIsAlive(existing.processId)) {
+    return false;
   }
-  if (kind !== "ordinary" && next.transport.epoch !== previous.transport.epoch + 1) {
-    throw new Error(
-      "transport mutation must increase the authority epoch exactly once"
-    );
+  const directory = lockPath(store, entityLockKey);
+  const staleDirectory = `${directory}.stale.${process.pid}.${Date.now()}`;
+  try {
+    await rename(directory, staleDirectory);
+  } catch (error) {
+    if (isNotFound3(error) || isAlreadyExists2(error)) return true;
+    throw error;
   }
+  await rm(staleDirectory, { recursive: true, force: true });
+  return true;
 }
-function assertTeamPolicyTransition(previous, next) {
-  if (previous.schemaVersion !== next.schemaVersion || previous.workspaceId !== next.workspaceId) {
-    throw new Error("team policy schemaVersion and workspaceId are immutable");
-  }
-  assertRevisionIncrease(
-    previous.revision,
-    next.revision,
-    "team policy revision"
+function processIsAlive(processId) {
+  if (processId === process.pid) return true;
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch (error) {
+    return !(typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH");
+  }
+}
+async function atomicWriteLockOwner(target, owner) {
+  const temporary = temporaryOwnerPath(target);
+  try {
+    await writeOwnerFile(temporary, owner);
+    await rename(temporary, target);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+}
+function temporaryOwnerPath(target) {
+  return `${target}.pending.${process.pid}.${randomUUID()}`;
+}
+async function writeOwnerFile(target, owner) {
+  await writeFile2(target, `${JSON.stringify(owner, null, 2)}
+`, {
+    encoding: "utf8",
+    flag: "wx"
+  });
+}
+function parseLeaseMs(value) {
+  if (value === void 0) return DEFAULT_LOCK_LEASE_MS;
+  if (!Number.isSafeInteger(value) || value < MINIMUM_LOCK_LEASE_MS || value > MAXIMUM_LOCK_LEASE_MS) {
+    throw new Error("local lock leaseMs is invalid");
+  }
+  return value;
+}
+function lockLeaseMs(owner) {
+  if (owner.leaseExpiresAt === null) return DEFAULT_LOCK_LEASE_MS;
+  const duration = Date.parse(owner.leaseExpiresAt) - Date.parse(owner.acquiredAt);
+  return duration >= MINIMUM_LOCK_LEASE_MS && duration <= MAXIMUM_LOCK_LEASE_MS ? duration : DEFAULT_LOCK_LEASE_MS;
+}
+function lockPath(store, entityLockKey) {
+  assertEntityLockKey(entityLockKey);
+  const fileName = createHash("sha256").update(entityLockKey, "utf8").digest("hex");
+  return path4.join(lockDirectory(store), `${fileName}.lock`);
+}
+function assertEntityLockKey(value) {
+  if (typeof value !== "string" || !ENTITY_LOCK_KEY_PATTERN.test(value) || value.includes("..")) {
+    throw new Error("entity lock key is invalid");
+  }
+}
+function sameLockOwner(current, expected) {
+  return current !== null && current.operationId === expected.operationId && current.processId === expected.processId && current.storeId === expected.storeId && current.entityLockKey === expected.entityLockKey && current.acquiredAt === expected.acquiredAt && current.leaseExpiresAt === expected.leaseExpiresAt;
+}
+function compareUtf82(left, right) {
+  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
+}
+function parseTimestamp12(value, label) {
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(`${label} must be an ISO timestamp`);
+  }
+  return value;
+}
+function isAlreadyExists2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isNotFound3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/runtime/operation-store.ts
+import { mkdir as mkdir3, readFile as readFile4, readdir as readdir2, writeFile as writeFile3 } from "fs/promises";
+import path5 from "path";
+
+// src/runtime/atomic-file.ts
+import { rename as rename2 } from "fs/promises";
+var RETRIABLE_WINDOWS_RENAME_CODES = /* @__PURE__ */ new Set(["EACCES", "EBUSY", "EPERM"]);
+async function replaceFileAtomically(temporary, target, options = {}) {
+  const maxAttempts = options.maxAttempts ?? 12;
+  const retryDelayMs = options.retryDelayMs ?? 25;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("MANCODE_ATOMIC_REPLACE_ATTEMPTS_INVALID");
+  }
+  if (!Number.isSafeInteger(retryDelayMs) || retryDelayMs < 0) {
+    throw new Error("MANCODE_ATOMIC_REPLACE_DELAY_INVALID");
+  }
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      await rename2(temporary, target);
+      return;
+    } catch (error) {
+      if (process.platform !== "win32" || !isRetriableWindowsRenameError(error) || attempt === maxAttempts) {
+        throw error;
+      }
+      await delay(retryDelayMs * attempt);
+    }
+  }
+}
+function isRetriableWindowsRenameError(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" && RETRIABLE_WINDOWS_RENAME_CODES.has(
+    error.code ?? ""
+  );
+}
+async function delay(milliseconds) {
+  await new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+
+// src/runtime/operation-definition.ts
+var OPERATION_AUTHORIZATION_ACTIONS = {
+  workflow_create: ["local_workflow_mutation", "shared_create_publish_promote"],
+  workflow_update: ["local_workflow_mutation", "shared_metadata_plan_mutation"],
+  requirements_draft: [
+    "local_workflow_mutation",
+    "shared_metadata_plan_mutation"
+  ],
+  requirements_finalize: [
+    "local_workflow_mutation",
+    "shared_metadata_plan_mutation"
+  ],
+  plan_revision: ["local_workflow_mutation", "shared_metadata_plan_mutation"],
+  review_remediation: [
+    "local_workflow_mutation",
+    "shared_ledger_evidence",
+    "review_skip_or_waiver"
+  ],
+  verification_record: ["local_workflow_mutation", "shared_ledger_evidence"],
+  task_complete: [
+    "local_workflow_mutation",
+    "task_complete_scope_change_child_merge"
+  ],
+  publish_promote: ["shared_create_publish_promote"],
+  handoff_transition: ["handoff_offer_cancel", "handoff_accept_reject"],
+  handoff_accept: ["handoff_accept_reject"],
+  scope_change_reclaim: ["task_complete_scope_change_child_merge"],
+  claim_create: ["claim_create"],
+  claim_renew_release: ["claim_renew_release_transfer"],
+  claim_transfer: ["claim_renew_release_transfer"],
+  claim_reclaim: ["claim_reclaim"],
+  claim_revalidation: ["claim_renew_release_transfer"],
+  checkpoint_create: [
+    "local_workflow_mutation",
+    "shared_metadata_plan_mutation"
+  ],
+  solo_handoff: ["local_workflow_mutation"],
+  reframe: ["local_workflow_mutation", "shared_metadata_plan_mutation"],
+  child_result_merge: [
+    "local_workflow_mutation",
+    "task_complete_scope_change_child_merge"
+  ],
+  task_head_reconcile: ["task_head_reconcile"],
+  transport_migrate: ["team_policy_config_transport"],
+  greenfield_initialize: ["team_policy_config_transport"],
+  adapter_upgrade: ["project_maintenance"],
+  project_policy_upgrade: ["project_maintenance"],
+  privacy_policy_update: ["project_maintenance"],
+  v3_activate: ["team_policy_config_transport"]
+};
+var prepare = (id, expectedRevisionPrefixes = [], requiredLockPrefixes = [], optional = {}) => ({
+  id,
+  visibility: "preparation",
+  expectedRevisionPrefixes,
+  requiredLockPrefixes,
+  optionalExpectedRevisionPrefixes: optional.expectedRevisionPrefixes ?? [],
+  optionalRequiredLockPrefixes: optional.requiredLockPrefixes ?? [],
+  crashRecovery: "safe_abort"
+});
+var write = (id, expectedRevisionPrefixes, requiredLockPrefixes, optional = {}) => ({
+  id,
+  visibility: "business_write",
+  expectedRevisionPrefixes,
+  requiredLockPrefixes,
+  optionalExpectedRevisionPrefixes: optional.expectedRevisionPrefixes ?? [],
+  optionalRequiredLockPrefixes: optional.requiredLockPrefixes ?? [],
+  crashRecovery: "forward_repair"
+});
+var commit = (id, expectedRevisionPrefixes, requiredLockPrefixes, optional = {}) => ({
+  id,
+  visibility: "commit",
+  expectedRevisionPrefixes,
+  requiredLockPrefixes,
+  optionalExpectedRevisionPrefixes: optional.expectedRevisionPrefixes ?? [],
+  optionalRequiredLockPrefixes: optional.requiredLockPrefixes ?? [],
+  crashRecovery: "forward_repair"
+});
+var OPERATION_DEFINITIONS = {
+  workflow_create: definition(
+    "workflow_create",
+    "publish-locator",
+    false,
+    false,
+    [
+      prepare("validate"),
+      // The staging directory is private to this operation and has no task
+      // locator/fence visibility. A crash here is compensable by deleting
+      // verified staging, rather than forcing a fictitious forward repair.
+      prepare("write-staging-aggregate", ["task:"], ["task:"]),
+      prepare("validate-aggregate", ["task:"], ["task:"]),
+      write("publish-task-directory", ["task:"], ["task:"]),
+      write("publish-locator", ["locator:"], ["task:", "locator:"]),
+      commit("commit", ["task:", "locator:"], ["task:", "locator:"])
+    ]
+  ),
+  workflow_update: definition(
+    "workflow_update",
+    "write-metadata",
+    true,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("write-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  requirements_draft: definition(
+    "requirements_draft",
+    "update-metadata",
+    true,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("write-requirements", ["requirements:", "task:"], ["task:"]),
+      write(
+        "mark-review-verification-stale",
+        ["review:", "verification:", "task:"],
+        ["task:"]
+      ),
+      write("update-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  requirements_finalize: definition(
+    "requirements_finalize",
+    "update-metadata",
+    true,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("write-requirements", ["requirements:", "task:"], ["task:"]),
+      write(
+        "mark-review-verification-stale",
+        ["review:", "verification:", "task:"],
+        ["task:"]
+      ),
+      write("update-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  plan_revision: definition("plan_revision", "update-metadata", true, false, [
+    prepare("validate", ["task:"], ["task:"]),
+    write("write-plan", ["plan:", "task:"], ["task:"]),
+    write("update-metadata", ["task:"], ["task:"]),
+    write(
+      "mark-review-verification-stale",
+      ["review:", "verification:", "task:"],
+      ["task:"]
+    ),
+    write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+    commit("commit", ["task_head:", "task:"], ["task:"])
+  ]),
+  review_remediation: definition(
+    "review_remediation",
+    "update-metadata",
+    true,
+    false,
+    [
+      prepare("validate", ["task:", "review:"], ["task:"]),
+      write("write-review-ledger", ["review:", "task:"], ["task:"]),
+      write("mark-verification-stale", ["verification:", "task:"], ["task:"]),
+      write("update-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  verification_record: definition(
+    "verification_record",
+    "update-metadata",
+    true,
+    false,
+    [
+      prepare("validate", ["task:", "verification:"], ["task:"]),
+      write("write-verification-ledger", ["verification:", "task:"], ["task:"]),
+      write("update-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  task_complete: definition(
+    "task_complete",
+    "write-completed-metadata",
+    true,
+    false,
+    [
+      prepare("validate-completion-gate", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"]
+      }),
+      write("mark-operation-pending", ["task:"], ["task:"]),
+      write("release-or-transfer-claims", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }),
+      write("write-completed-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  publish_promote: definition(
+    "publish_promote",
+    "publish-destination",
+    true,
+    true,
+    [
+      prepare("validate-privacy-and-paths", ["task:"], ["task:"]),
+      // The destination staging directory remains private until its atomic
+      // rename, so it is safely compensable just like workflow creation.
+      prepare("stage-destination", ["task:"], ["task:"]),
+      write("mark-source-operation-pending", ["task:"], ["task:"]),
+      write(
+        "publish-destination",
+        ["task:", "locator:"],
+        ["task:", "locator:"]
+      ),
+      write("write-source-successor", ["task:"], ["task:"]),
+      write("publish-destination-locator", ["locator:"], ["locator:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  handoff_transition: definition(
+    "handoff_transition",
+    "write-handoff",
+    false,
+    false,
+    [
+      prepare("validate", ["task:", "handoff:"], ["task:", "handoff:"]),
+      write("write-handoff", ["task:", "handoff:"], ["task:", "handoff:"]),
+      commit("commit", ["task:", "handoff:"], ["task:", "handoff:"])
+    ]
+  ),
+  handoff_accept: definition("handoff_accept", "accept-handoff", true, false, [
+    prepare(
+      "validate",
+      ["task:", "handoff:", "checkpoint:"],
+      ["task:", "handoff:", "checkpoint:"],
+      {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }
+    ),
+    write("mark-task-operation-pending", ["task:"], ["task:"]),
+    write("create-pending-successor-claims", ["task:"], ["task:"], {
+      expectedRevisionPrefixes: ["claim:"],
+      requiredLockPrefixes: ["claim:"]
+    }),
+    write("transfer-old-claims", ["task:"], ["task:"], {
+      expectedRevisionPrefixes: ["claim:"],
+      requiredLockPrefixes: ["claim:"]
+    }),
+    write("update-owner-and-checkpoint", ["task:", "checkpoint:"], ["task:"]),
+    write("activate-successor-claims", ["task:"], ["task:"], {
+      expectedRevisionPrefixes: ["claim:"],
+      requiredLockPrefixes: ["claim:"]
+    }),
+    write("accept-handoff", ["handoff:", "task:"], ["task:", "handoff:"]),
+    write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+    commit("commit", ["task_head:", "task:"], ["task:"])
+  ]),
+  scope_change_reclaim: definition(
+    "scope_change_reclaim",
+    "activate-successor-claims",
+    true,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }),
+      write("mark-task-operation-pending", ["task:"], ["task:"]),
+      write(
+        "write-scope-changed-checkpoint",
+        ["checkpoint:", "task:"],
+        ["task:"]
+      ),
+      write("create-pending-successor-claims", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }),
+      write("terminate-old-claims", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }),
+      write(
+        "mark-review-verification-stale",
+        ["review:", "verification:", "task:"],
+        ["task:"]
+      ),
+      write("update-metadata-scope", ["task:"], ["task:"]),
+      write("activate-successor-claims", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  claim_create: definition(
+    "claim_create",
+    "create-active-claim",
+    false,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("create-active-claim", ["claim:", "task:"], ["task:", "claim:"]),
+      commit("commit", ["claim:", "task:"], ["task:", "claim:"])
+    ]
+  ),
+  claim_renew_release: definition(
+    "claim_renew_release",
+    "update-claim",
+    false,
+    false,
+    [
+      prepare("validate", ["task:", "claim:"], ["task:", "claim:"]),
+      write("update-claim", ["task:", "claim:"], ["task:", "claim:"]),
+      commit("commit", ["task:", "claim:"], ["task:", "claim:"])
+    ]
+  ),
+  claim_transfer: definition(
+    "claim_transfer",
+    "activate-successor-claim",
+    false,
+    false,
+    [
+      prepare("validate", ["task:", "claim:"], ["task:", "claim:"]),
+      write(
+        "create-pending-successor-claim",
+        ["task:", "claim:"],
+        ["task:", "claim:"]
+      ),
+      write(
+        "transfer-predecessor-claim",
+        ["task:", "claim:"],
+        ["task:", "claim:"]
+      ),
+      write(
+        "activate-successor-claim",
+        ["task:", "claim:"],
+        ["task:", "claim:"]
+      ),
+      commit("commit", ["task:", "claim:"], ["task:", "claim:"])
+    ]
+  ),
+  claim_reclaim: definition("claim_reclaim", "expire-claim", false, false, [
+    prepare("validate", ["task:", "claim:"], ["task:", "claim:"]),
+    write("expire-claim", ["task:", "claim:"], ["task:", "claim:"]),
+    commit("commit", ["task:", "claim:"], ["task:", "claim:"])
+  ]),
+  claim_revalidation: definition(
+    "claim_revalidation",
+    "update-claim-validation",
+    true,
+    false,
+    [
+      prepare("validate", ["task:", "claim:"], ["task:", "claim:"]),
+      write("mark-task-operation-pending", ["task:"], ["task:"]),
+      write("write-base-changed-checkpoint", ["task:"], ["task:"], {
+        expectedRevisionPrefixes: ["checkpoint:"]
+      }),
+      write(
+        "update-claim-validation",
+        ["claim:", "task:"],
+        ["task:", "claim:"]
+      ),
+      write("complete-task-validation", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  checkpoint_create: definition(
+    "checkpoint_create",
+    "update-metadata-checkpoint-ref",
+    true,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("mark-task-operation-pending", ["task:"], ["task:"]),
+      write("write-checkpoint", ["checkpoint:", "task:"], ["task:"]),
+      write("update-metadata-checkpoint-ref", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  solo_handoff: definition(
+    "solo_handoff",
+    "write-workflow-assignment",
+    false,
+    false,
+    [
+      prepare("validate", ["task:"], ["task:"]),
+      write("write-workflow-assignment", ["task:"], ["task:"]),
+      // The session pointer is a compensable local projection, rather than
+      // journaled workflow authority.  It is intentionally not part of the
+      // operation CAS/lock set: a failed or later-replaced pointer must never
+      // block repair of the durable solo assignment.
+      write("update-session-pointer", ["task:"], ["task:"]),
+      commit("commit", ["task:"], ["task:"])
+    ]
+  ),
+  reframe: definition("reframe", "commit-reframed-metadata", true, false, [
+    prepare(
+      "validate",
+      [
+        "task:",
+        "requirements:",
+        "plan:",
+        "review:",
+        "verification:",
+        "archive:",
+        "checkpoint:"
+      ],
+      ["task:", "archive:", "checkpoint:"],
+      {
+        expectedRevisionPrefixes: ["claim:"],
+        requiredLockPrefixes: ["claim:"]
+      }
+    ),
+    write("mark-task-operation-pending", ["task:"], ["task:"]),
+    write(
+      "archive-requirements-plan",
+      ["archive:", "requirements:", "plan:", "task:"],
+      ["archive:", "task:"]
+    ),
+    write("release-active-claims", ["task:"], ["task:"], {
+      expectedRevisionPrefixes: ["claim:"],
+      requiredLockPrefixes: ["claim:"]
+    }),
+    write("write-requirements-draft", ["requirements:", "task:"], ["task:"]),
+    write(
+      "mark-review-verification-stale",
+      ["review:", "verification:", "task:"],
+      ["task:"]
+    ),
+    write(
+      "write-reframe-checkpoint",
+      ["checkpoint:", "task:"],
+      ["checkpoint:", "task:"]
+    ),
+    write("commit-reframed-metadata", ["task:"], ["task:"]),
+    write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+    commit("commit", ["task_head:", "task:"], ["task:"])
+  ]),
+  child_result_merge: definition(
+    "child_result_merge",
+    "update-parent-metadata",
+    true,
+    false,
+    [
+      prepare("validate-parent-snapshot", ["task:", "checkpoint:"], ["task:"]),
+      write("mark-parent-operation-pending", ["task:"], ["task:"]),
+      write("write-merge-checkpoint", ["checkpoint:", "task:"], ["task:"]),
+      write("update-parent-metadata", ["task:"], ["task:"]),
+      write("update-task-head-fence", ["task_head:", "task:"], ["task:"]),
+      commit("commit", ["task_head:", "task:"], ["task:"])
+    ]
+  ),
+  task_head_reconcile: definition(
+    "task_head_reconcile",
+    "adopt-task-head-fence",
+    true,
+    false,
+    [
+      prepare(
+        "validate-clean-store-and-git-reachability",
+        ["task:", "task_head:"],
+        ["task:", "task_head:"]
+      ),
+      prepare(
+        "confirm-adoption",
+        ["task:", "task_head:"],
+        ["task:", "task_head:"]
+      ),
+      write(
+        "adopt-task-head-fence",
+        ["task_head:", "task:"],
+        ["task:", "task_head:"]
+      ),
+      commit("commit", ["task_head:", "task:"], ["task:", "task_head:"])
+    ]
+  ),
+  transport_migrate: definition(
+    "transport_migrate",
+    "switch-config-authority",
+    true,
+    true,
+    [
+      prepare(
+        "freeze-shared-coordination-writes",
+        ["config:", "task_head:"],
+        ["config:"]
+      ),
+      prepare(
+        "validate-old-authority",
+        ["config:", "task_head:", "claim:", "handoff:"],
+        ["config:"]
+      ),
+      write(
+        "stage-new-authority",
+        ["config:", "task_head:", "claim:", "handoff:"],
+        ["config:"]
+      ),
+      write(
+        "establish-new-epoch",
+        ["config:", "task_head:", "claim:", "handoff:"],
+        ["config:"]
+      ),
+      write("switch-config-authority", ["config:"], ["config:"]),
+      commit("commit", ["config:"], ["config:"])
+    ]
+  ),
+  greenfield_initialize: definition(
+    "greenfield_initialize",
+    "publish-v3-root",
+    false,
+    false,
+    [
+      prepare("verify-no-legacy-authority"),
+      // The named staging root is still private and can be verified then
+      // deleted before the atomic .mancode publication boundary.
+      prepare(
+        "write-initializing-staging-root",
+        ["schema:", "config:"],
+        ["schema:"]
+      ),
+      prepare(
+        "write-v3-config-policy-adapters",
+        ["schema:", "config:"],
+        ["schema:"]
+      ),
+      write("publish-v3-root", ["schema:", "config:"], ["schema:"]),
+      write("register-workspace-binding", ["binding:"], ["binding:"]),
+      write("publish-managed-adapters", ["adapter:"], ["adapter:"]),
+      write("activate-v3-manifest", ["schema:"], ["schema:"]),
+      commit("commit", ["schema:"], ["schema:"])
+    ]
+  ),
+  adapter_upgrade: definition(
+    "adapter_upgrade",
+    "replace-managed-adapters",
+    false,
+    false,
+    [
+      prepare("validate", ["adapter:"], ["adapter:"], {
+        expectedRevisionPrefixes: ["schema:"],
+        requiredLockPrefixes: ["schema:"]
+      }),
+      write("replace-managed-adapters", ["adapter:"], ["adapter:"]),
+      write("update-adapter-inventory", [], [], {
+        expectedRevisionPrefixes: ["schema:"],
+        requiredLockPrefixes: ["schema:"]
+      }),
+      commit("verify", ["adapter:"], ["adapter:"], {
+        expectedRevisionPrefixes: ["schema:"],
+        requiredLockPrefixes: ["schema:"]
+      }),
+      commit("commit", ["adapter:"], ["adapter:"], {
+        expectedRevisionPrefixes: ["schema:"],
+        requiredLockPrefixes: ["schema:"]
+      })
+    ]
+  ),
+  project_policy_upgrade: definition(
+    "project_policy_upgrade",
+    "write-manifest",
+    false,
+    false,
+    [
+      prepare("validate", ["schema:"], ["schema:"]),
+      write("write-manifest", ["schema:"], ["schema:"]),
+      write("verify-manifest", ["schema:"], ["schema:"]),
+      commit("commit", ["schema:"], ["schema:"])
+    ]
+  ),
+  privacy_policy_update: definition(
+    "privacy_policy_update",
+    "write-manifest",
+    false,
+    false,
+    [
+      prepare("validate", ["schema:"], ["schema:"]),
+      write("write-remote-policy", ["schema:"], ["schema:"]),
+      write("write-exclusions", ["schema:"], ["schema:"]),
+      write("write-policy", ["schema:"], ["schema:"]),
+      write("write-manifest", ["schema:"], ["schema:"]),
+      commit("commit", ["schema:"], ["schema:"])
+    ]
+  ),
+  v3_activate: definition("v3_activate", "activate-manifest", true, true, [
+    prepare(
+      "validate-staged-migration",
+      ["schema:", "config:", "stage:"],
+      ["schema:", "config:", "stage:"],
+      {
+        expectedRevisionPrefixes: ["task:", "task_head:", "adapter:"],
+        requiredLockPrefixes: ["task:", "task_head:", "adapter:"]
+      }
+    ),
+    write(
+      "mark-manifest-activating",
+      ["schema:", "stage:"],
+      ["schema:", "stage:"]
+    ),
+    write("replace-managed-adapters", ["adapter:"], ["adapter:"]),
+    write("promote-staged-tasks", [], [], {
+      expectedRevisionPrefixes: ["task:", "task_head:"],
+      requiredLockPrefixes: ["task:", "task_head:"]
+    }),
+    write(
+      "record-adapter-inventory-and-baseline",
+      ["schema:", "config:"],
+      ["schema:", "config:"]
+    ),
+    write("activate-manifest", ["schema:", "stage:"], ["schema:", "stage:"]),
+    commit("commit", ["schema:", "stage:"], ["schema:", "stage:"])
+  ])
+};
+var OPERATION_CRASH_FIXTURES = Object.fromEntries(
+  Object.values(OPERATION_DEFINITIONS).map((definition2) => [
+    definition2.type,
+    [
+      {
+        operationType: definition2.type,
+        crashAfter: "prepared",
+        expectedRecovery: "safe_abort"
+      },
+      ...definition2.steps.map((step) => ({
+        operationType: definition2.type,
+        crashAfter: step.id,
+        expectedRecovery: step.crashRecovery
+      }))
+    ]
+  ])
+);
+function getOperationDefinition(operationType) {
+  return OPERATION_DEFINITIONS[operationType];
+}
+function assertOperationJournalMatchesDefinition(journal) {
+  const definition2 = getOperationDefinition(journal.type);
+  assertOperationAuthorizationAction(journal);
+  const actualSteps = journal.steps.map((step) => step.id);
+  const expectedSteps = definition2.steps.map((step) => step.id);
+  if (actualSteps.length !== expectedSteps.length || actualSteps.some((step, index) => step !== expectedSteps[index])) {
+    throw new Error(
+      `operation ${journal.type} steps do not match its machine-readable definition`
+    );
+  }
+  const expectedRevisionPrefixes = new Set(
+    definition2.steps.flatMap((step) => step.expectedRevisionPrefixes)
+  );
+  const lockPrefixes = new Set(
+    definition2.steps.flatMap((step) => step.requiredLockPrefixes)
+  );
+  const optionalExpectedRevisionPrefixes = new Set(
+    definition2.steps.flatMap((step) => step.optionalExpectedRevisionPrefixes)
+  );
+  const optionalLockPrefixes = new Set(
+    definition2.steps.flatMap((step) => step.optionalRequiredLockPrefixes)
+  );
+  const sharedTask = journal.entityLocks.some(
+    (key) => key.startsWith("task:shared:")
+  );
+  if (!sharedTask) {
+    expectedRevisionPrefixes.delete("task_head:");
+  }
+  assertPrefixCoverage(
+    Object.keys(journal.expectedRevisions),
+    expectedRevisionPrefixes,
+    "expected revisions"
+  );
+  assertPrefixCoverage(journal.entityLocks, lockPrefixes, "entity locks");
+  assertOptionalPrefixPairs(
+    Object.keys(journal.expectedRevisions),
+    journal.entityLocks,
+    optionalExpectedRevisionPrefixes,
+    optionalLockPrefixes
+  );
+  if (definition2.requiresSharedTaskHeadFence && sharedTask) {
+    assertPrefixCoverage(
+      Object.keys(journal.expectedRevisions),
+      /* @__PURE__ */ new Set(["task_head:"]),
+      "expected revisions"
+    );
+    assertPrefixCoverage(
+      journal.entityLocks,
+      /* @__PURE__ */ new Set(["task_head:"]),
+      "entity locks"
+    );
+  }
+}
+function assertOperationAuthorizationAction(journal) {
+  const definition2 = getOperationDefinition(journal.type);
+  if (!definition2.authorizationActions.includes(journal.authorizationBasis.action)) {
+    throw new Error("MANCODE_OPERATION_AUTHORIZATION_ACTION_MISMATCH");
+  }
+}
+function definition(type, primaryCommitStep, requiresSharedTaskHeadFence, allowsSecondaryReservations, steps) {
+  if (!steps.some((step) => step.id === primaryCommitStep)) {
+    throw new Error(`operation ${type} has no primary commit step`);
+  }
+  for (const step of steps) {
+    for (const prefix of step.optionalExpectedRevisionPrefixes) {
+      if (step.expectedRevisionPrefixes.includes(prefix)) {
+        throw new Error(
+          `operation ${type} repeats optional expected revision prefix ${prefix}`
+        );
+      }
+    }
+    for (const prefix of step.optionalRequiredLockPrefixes) {
+      if (step.requiredLockPrefixes.includes(prefix)) {
+        throw new Error(
+          `operation ${type} repeats optional lock prefix ${prefix}`
+        );
+      }
+    }
+  }
+  return {
+    schemaVersion: 1,
+    type,
+    authorizationActions: OPERATION_AUTHORIZATION_ACTIONS[type],
+    primaryCommitStep,
+    requiresSharedTaskHeadFence,
+    allowsSecondaryReservations,
+    steps
+  };
+}
+function assertPrefixCoverage(values, prefixes, label) {
+  for (const prefix of prefixes) {
+    if (!values.some((value) => value.startsWith(prefix))) {
+      throw new Error(`operation journal ${label} are missing ${prefix}`);
+    }
+  }
+}
+function assertOptionalPrefixPairs(expectedRevisions, entityLocks, optionalExpectedRevisionPrefixes, optionalLockPrefixes) {
+  for (const prefix of optionalExpectedRevisionPrefixes) {
+    if (expectedRevisions.some((value) => value.startsWith(prefix)) && !entityLocks.some((value) => value.startsWith(prefix))) {
+      throw new Error(
+        `operation journal entity locks are missing optional ${prefix}`
+      );
+    }
+  }
+  for (const prefix of optionalLockPrefixes) {
+    if (entityLocks.some((value) => value.startsWith(prefix)) && !expectedRevisions.some((value) => value.startsWith(prefix))) {
+      throw new Error(
+        `operation journal expected revisions are missing optional ${prefix}`
+      );
+    }
+  }
+}
+
+// src/runtime/operation-store.ts
+async function createPreparedOperationJournal(store, journal) {
+  assertOperationAuthorizationAction(journal);
+  if (journal.state !== "prepared") {
+    throw new Error("only a prepared operation journal may be created");
+  }
+  if (journal.primaryStoreId !== store.storeId) {
+    throw new Error(
+      "operation journal primaryStoreId does not match its home store"
+    );
+  }
+  assertOperationReservationTopology(journal);
+  if (journal.type !== "transport_migrate" && store.kind !== "checkout_local") {
+    const migrationInProgress = (await listUnfinishedOperationJournals(store)).some((candidate) => candidate.type === "transport_migrate");
+    if (migrationInProgress) {
+      throw new Error("MANCODE_TRANSPORT_MIGRATION_FROZEN");
+    }
+  }
+  const directory = operationDirectory(store);
+  const target = operationJournalPath(store, journal.operationId);
+  await mkdir3(directory, { recursive: true });
+  try {
+    await writeFile3(target, serialize2(journal), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return journal;
+  } catch (error) {
+    if (!isAlreadyExists3(error)) throw error;
+    const existing = await readOperationJournal(store, journal.operationId);
+    if (existing !== null && operationJournalDigest(existing) === operationJournalDigest(journal)) {
+      return existing;
+    }
+    throw new Error("MANCODE_OPERATION_JOURNAL_CONFLICT");
+  }
+}
+async function prepareOperationStores(input) {
+  const { primaryStore, journal } = input;
+  validateSecondaryStores(primaryStore, journal, input.secondaryStores);
+  await createPreparedOperationJournal(primaryStore, journal);
+  const createdAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const reservations = [];
+  for (const secondaryStore of input.secondaryStores) {
+    const reservation = createOperationReservation(
+      journal,
+      secondaryStore.storeId,
+      createdAt
+    );
+    reservations.push(
+      await writeOperationReservation(secondaryStore, reservation)
+    );
+  }
+  return reservations;
+}
+async function readOperationJournal(store, operationId) {
+  try {
+    assertUlid(operationId, "operation journal operationId");
+    const raw = await readFile4(
+      operationJournalPath(store, operationId),
+      "utf8"
+    );
+    return parseOperationJournal(JSON.parse(raw));
+  } catch (error) {
+    if (isNotFound4(error)) return null;
+    if (error instanceof SyntaxError) {
+      throw new Error("MANCODE_OPERATION_JOURNAL_CORRUPT");
+    }
+    throw error;
+  }
+}
+async function updateOperationJournal(store, next, options) {
+  const previous = await readOperationJournal(store, next.operationId);
+  if (previous === null) throw new Error("MANCODE_OPERATION_JOURNAL_NOT_FOUND");
+  if (previous.primaryStoreId !== store.storeId || next.primaryStoreId !== store.storeId) {
+    throw new Error(
+      "operation journal must be updated in its primary home store"
+    );
+  }
+  assertOperationJournalTransition(previous, next, options);
+  await atomicWriteOperationJournal(store, next);
+  return next;
+}
+async function listUnfinishedOperationJournals(store) {
+  let entries;
+  try {
+    entries = await readdir2(operationDirectory(store));
+  } catch (error) {
+    if (isNotFound4(error)) return [];
+    throw error;
+  }
+  const journals = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const operationId = entry.slice(0, -".json".length);
+    try {
+      assertUlid(operationId, "operation journal filename");
+    } catch {
+      throw new Error("MANCODE_OPERATION_JOURNAL_CORRUPT");
+    }
+    const journal = await readOperationJournal(store, operationId);
+    if (journal !== null && journal.state !== "committed" && journal.state !== "aborted") {
+      journals.push(journal);
+    }
+  }
+  return journals.sort(
+    (left, right) => Buffer.from(left.operationId, "utf8").compare(
+      Buffer.from(right.operationId, "utf8")
+    )
+  );
+}
+function operationJournalPath(store, operationId) {
+  assertUlid(operationId, "operation journal operationId");
+  return path5.join(operationDirectory(store), `${operationId}.json`);
+}
+async function atomicWriteOperationJournal(store, journal) {
+  const target = operationJournalPath(store, journal.operationId);
+  const temporary = path5.join(
+    operationDirectory(store),
+    `.${journal.operationId}.${process.pid}.${Date.now()}.tmp`
+  );
+  await writeFile3(temporary, serialize2(journal), {
+    encoding: "utf8",
+    flag: "wx"
+  });
+  await replaceFileAtomically(temporary, target);
+}
+function validateSecondaryStores(primaryStore, journal, secondaryStores) {
+  if (journal.primaryStoreId !== primaryStore.storeId) {
+    throw new Error(
+      "operation journal primaryStoreId does not match primaryStore"
+    );
+  }
+  const expectedStoreIds = new Set(
+    journal.secondaryReservations.map((reservation) => reservation.storeId)
+  );
+  const suppliedStoreIds = /* @__PURE__ */ new Set();
+  for (const store of secondaryStores) {
+    if (store.storeId === primaryStore.storeId || suppliedStoreIds.has(store.storeId)) {
+      throw new Error(
+        "operation secondary stores must be unique and exclude primaryStore"
+      );
+    }
+    suppliedStoreIds.add(store.storeId);
+  }
+  if (expectedStoreIds.size !== suppliedStoreIds.size || [...expectedStoreIds].some((storeId) => !suppliedStoreIds.has(storeId))) {
+    throw new Error(
+      "operation secondary stores do not match the journal reservations"
+    );
+  }
+}
+function serialize2(journal) {
+  return `${JSON.stringify(journal, null, 2)}
+`;
+}
+function isAlreadyExists3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isNotFound4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/runtime/project-write-barrier.ts
+var PROJECT_SCHEMA_LOCK = "schema:project";
+async function acquireProjectWriteBarrier(runtime, operationId, now) {
+  const localStore = resolveLocalEntityHomeStore(
+    runtime.entityHomeStoreContext
+  );
+  const [lock] = await acquireEntityLocks(
+    localStore,
+    operationId,
+    [PROJECT_SCHEMA_LOCK],
+    { now }
+  );
+  if (lock === void 0) {
+    throw new Error("MANCODE_LOCK_HELD");
+  }
+  try {
+    const unfinished = await listUnfinishedOperationJournals(localStore);
+    if (unfinished.some(
+      (journal) => journal.entityLocks.includes(PROJECT_SCHEMA_LOCK)
+    )) {
+      throw new Error("MANCODE_OPERATION_REPAIR_REQUIRED");
+    }
+    return lock;
+  } catch (error) {
+    await lock.release().catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/context/privacy-policy.ts
+import { lstat as lstat3, readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import path6 from "path";
+
+// src/context/manifest.ts
+var ACTIVATION_STATES = /* @__PURE__ */ new Set([
+  "initializing",
+  "dual_read",
+  "activating",
+  "v3_active",
+  "repair_required"
+]);
+var MANAGED_ADAPTERS = [
+  "claude-code",
+  "codex",
+  "cursor",
+  "copilot",
+  "zcode",
+  "kimi-code",
+  "qoder",
+  "dsh"
+];
+var VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+var DIGEST_PATTERN13 = /^sha256:[a-f0-9]{64}$/;
+function parseSchemaManifest(value) {
+  assertRecord(value, "schema manifest");
+  if (value.manifestVersion !== 1 && value.manifestVersion !== 2 && value.manifestVersion !== 3) {
+    throw new Error(
+      `MANCODE_MANIFEST_VERSION_UNSUPPORTED: observed=${String(value.manifestVersion)} supported=1,2,3 requiredWriter=0.6.5`
+    );
+  }
+  const manifestVersion = value.manifestVersion;
+  assertKnownKeys(
+    value,
+    [
+      "manifestVersion",
+      "layoutVersion",
+      "epoch",
+      "activationState",
+      "minReaderVersion",
+      "minWriterVersion",
+      "activatedAt",
+      "legacyBaseline",
+      "managedAdapters",
+      "lastOperationId",
+      ...manifestVersion >= 2 ? ["workflowPolicyDefaults"] : [],
+      ...manifestVersion === 3 ? ["privacyPolicy"] : []
+    ],
+    "schema manifest"
+  );
+  if (value.layoutVersion !== 3) {
+    throw new Error("schema manifest must use layoutVersion 3");
+  }
+  assertUlid(value.epoch, "schema manifest epoch");
+  if (typeof value.activationState !== "string" || !ACTIVATION_STATES.has(value.activationState)) {
+    throw new Error("schema manifest activationState is invalid");
+  }
+  const common = {
+    layoutVersion: 3,
+    epoch: value.epoch,
+    activationState: value.activationState,
+    minReaderVersion: parseVersion(value.minReaderVersion, "minReaderVersion"),
+    minWriterVersion: parseVersion(value.minWriterVersion, "minWriterVersion"),
+    activatedAt: parseTimestampOrNull3(value.activatedAt, "activatedAt"),
+    legacyBaseline: parseLegacyBaseline(value.legacyBaseline),
+    managedAdapters: parseManagedAdapters(value.managedAdapters),
+    lastOperationId: parseUlidOrNull8(value.lastOperationId, "lastOperationId")
+  };
+  const manifest = manifestVersion === 1 ? { manifestVersion: 1, ...common } : manifestVersion === 2 ? {
+    manifestVersion: 2,
+    ...common,
+    workflowPolicyDefaults: parseWorkflowPolicyDefaults(
+      value.workflowPolicyDefaults
+    )
+  } : {
+    manifestVersion: 3,
+    ...common,
+    workflowPolicyDefaults: parsePrivacyManifestPlanningDefaults(
+      value.workflowPolicyDefaults
+    ),
+    privacyPolicy: parsePrivacyPolicyReference(value.privacyPolicy)
+  };
+  assertManifestStateShape(manifest);
+  if (manifest.manifestVersion >= 2 && (compareVersions(manifest.minReaderVersion, "0.4.0") < 0 || compareVersions(manifest.minWriterVersion, "0.4.0") < 0)) {
+    throw new Error(
+      "schema manifest V2 requires minReaderVersion and minWriterVersion 0.4.0 or newer"
+    );
+  }
+  if (manifest.manifestVersion === 3 && (compareVersions(manifest.minReaderVersion, "0.6.5") < 0 || compareVersions(manifest.minWriterVersion, "0.6.5") < 0))
+    throw new Error(
+      "schema manifest V3 requires minReaderVersion and minWriterVersion 0.6.5 or newer"
+    );
+  return manifest;
+}
+function serializeSchemaManifest(value) {
+  return `${JSON.stringify(parseSchemaManifest(value), null, 2)}
+`;
+}
+function managedAdapterNames(inventory) {
+  return MANAGED_ADAPTERS.filter((adapter) => inventory[adapter] !== void 0);
+}
+function assertSchemaManifestTransition(previous, next) {
+  if (previous.manifestVersion !== next.manifestVersion || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || compareVersions(next.minReaderVersion, previous.minReaderVersion) < 0 || compareVersions(next.minWriterVersion, previous.minWriterVersion) < 0) {
+    throw new Error(
+      "schema manifest identity and legacy baseline are immutable"
+    );
+  }
+  if (previous.manifestVersion === 3 && next.manifestVersion === 3 && (previous.privacyPolicy.revision !== next.privacyPolicy.revision || previous.privacyPolicy.digest !== next.privacyPolicy.digest || previous.workflowPolicyDefaults.planning !== next.workflowPolicyDefaults.planning))
+    throw new Error("MANCODE_PRIVACY_MANIFEST_TRANSITION_REQUIRED");
+  if (previous.activationState === next.activationState) return;
+  if (!allowedManifestTransitions(previous.activationState).has(
+    next.activationState
+  )) {
+    throw new Error(
+      `invalid schema manifest transition: ${previous.activationState} -> ${next.activationState}`
+    );
+  }
+}
+function assertSchemaManifestPrivacyTransition(previous, next) {
+  if (next.manifestVersion !== 3 || previous.epoch !== next.epoch || previous.layoutVersion !== next.layoutVersion || previous.activationState !== "v3_active" || next.activationState !== "v3_active" || previous.activatedAt !== next.activatedAt || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || !managedAdapterInventoriesMatch(
+    previous.managedAdapters,
+    next.managedAdapters
+  ) || compareVersions(next.minReaderVersion, previous.minReaderVersion) < 0 || compareVersions(next.minWriterVersion, previous.minWriterVersion) < 0 || next.lastOperationId === null || next.lastOperationId === previous.lastOperationId || next.privacyPolicy.revision !== (previous.manifestVersion === 3 ? previous.privacyPolicy.revision : 0) + 1 || next.workflowPolicyDefaults.planning !== (previous.manifestVersion === 1 ? 1 : previous.workflowPolicyDefaults.planning))
+    throw new Error("MANCODE_PRIVACY_MANIFEST_TRANSITION_INVALID");
+}
+function parsePrivacyManifestPlanningDefaults(value) {
+  assertRecord(value, "workflow policy defaults");
+  assertKnownKeys(value, ["planning"], "workflow policy defaults");
+  if (value.planning !== 1 && value.planning !== 2)
+    throw new Error("schema manifest planning policy must be 1 or 2");
+  return { planning: value.planning };
+}
+function parsePrivacyPolicyReference(value) {
+  assertRecord(value, "privacy policy reference");
+  assertKnownKeys(value, ["revision", "digest"], "privacy policy reference");
+  if (!Number.isSafeInteger(value.revision) || value.revision < 1 || typeof value.digest !== "string" || !DIGEST_PATTERN13.test(value.digest))
+    throw new Error("MANCODE_PRIVACY_POLICY_REFERENCE_INVALID");
+  return { revision: value.revision, digest: value.digest };
+}
+function assertSchemaManifestPolicyUpgrade(previous, next) {
+  const legacyUpgrade = previous.manifestVersion === 1 && next.manifestVersion === 2;
+  const privacyUpgrade = previous.manifestVersion === 3 && next.manifestVersion === 3 && previous.workflowPolicyDefaults.planning === 1 && previous.privacyPolicy.revision === next.privacyPolicy.revision && previous.privacyPolicy.digest === next.privacyPolicy.digest;
+  if (!legacyUpgrade && !privacyUpgrade || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || previous.activationState !== "v3_active" || next.activationState !== "v3_active" || previous.activatedAt !== next.activatedAt || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || !managedAdapterInventoriesMatch(
+    previous.managedAdapters,
+    next.managedAdapters
+  ) || compareVersions(next.minReaderVersion, previous.minReaderVersion) < 0 || compareVersions(next.minWriterVersion, previous.minWriterVersion) < 0 || next.workflowPolicyDefaults.planning !== 2 || next.lastOperationId === null || next.lastOperationId === previous.lastOperationId) {
+    throw new Error("invalid schema manifest Policy 2 upgrade");
+  }
+}
+function assertActivationRollbackManifestTransition(previous, next) {
+  if (previous.manifestVersion !== next.manifestVersion || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || previous.activationState !== "v3_active" || next.activationState !== "dual_read" || previous.activatedAt === null || next.activatedAt !== null) {
+    throw new Error("invalid activation rollback manifest transition");
+  }
+}
+function parseWorkflowPolicyDefaults(value) {
+  assertRecord(value, "schema manifest workflowPolicyDefaults");
+  assertKnownKeys(
+    value,
+    ["planning"],
+    "schema manifest workflowPolicyDefaults"
   );
+  if (value.planning !== 2) {
+    throw new Error(
+      `MANCODE_POLICY_VERSION_UNSUPPORTED: component=planning observed=${String(value.planning)} supported=2 requiredWriter=0.4.0`
+    );
+  }
+  return { planning: 2 };
+}
+function parseVersion(value, label) {
+  if (typeof value !== "string" || !VERSION_PATTERN.test(value)) {
+    throw new Error(`schema manifest ${label} must be a semantic version`);
+  }
+  return value;
+}
+function parseTimestampOrNull3(value, label) {
+  if (value === null) return null;
+  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+    throw new Error(
+      `schema manifest ${label} must be an ISO timestamp or null`
+    );
+  }
+  return value;
 }
-function parseTransport2(value) {
-  assertRecord(value, "project config transport");
+function parseLegacyBaseline(value) {
+  if (value === null) return null;
+  assertRecord(value, "schema manifest legacyBaseline");
   assertKnownKeys(
     value,
-    ["mode", "remote", "epoch"],
-    "project config transport"
+    ["stateDigest", "workflowIndexDigest"],
+    "schema manifest legacyBaseline"
   );
-  if (value.mode !== "local" && value.mode !== "git-ref") {
-    throw new Error("project config transport mode is invalid");
+  if (typeof value.stateDigest !== "string" || !DIGEST_PATTERN13.test(value.stateDigest) || typeof value.workflowIndexDigest !== "string" || !DIGEST_PATTERN13.test(value.workflowIndexDigest)) {
+    throw new Error(
+      "schema manifest legacyBaseline must contain sha256 digests"
+    );
+  }
+  return {
+    stateDigest: value.stateDigest,
+    workflowIndexDigest: value.workflowIndexDigest
+  };
+}
+function parseManagedAdapters(value) {
+  assertRecord(value, "schema manifest managedAdapters");
+  assertKnownKeys(value, MANAGED_ADAPTERS, "schema manifest managedAdapters");
+  const adapters = {};
+  for (const adapter of MANAGED_ADAPTERS) {
+    const version = value[adapter];
+    if (version === void 0) continue;
+    if (typeof version !== "string" || !version.trim()) {
+      throw new Error(
+        `schema manifest managedAdapters.${adapter} must be a non-empty version`
+      );
+    }
+    adapters[adapter] = version;
+  }
+  return adapters;
+}
+function parseUlidOrNull8(value, label) {
+  if (value === null) return null;
+  assertUlid(value, `schema manifest ${label}`);
+  return value;
+}
+function assertManifestStateShape(manifest) {
+  if (manifest.activationState === "initializing" && manifest.legacyBaseline !== null) {
+    throw new Error(
+      "greenfield initializing manifests must not have a legacy baseline"
+    );
+  }
+  if ((manifest.activationState === "dual_read" || manifest.activationState === "activating") && manifest.legacyBaseline === null) {
+    throw new Error(
+      `${manifest.activationState} manifests require a legacy baseline`
+    );
+  }
+  if (manifest.activationState === "v3_active" && manifest.activatedAt === null) {
+    throw new Error("v3_active manifests require activatedAt");
+  }
+  if ((manifest.activationState === "initializing" || manifest.activationState === "dual_read" || manifest.activationState === "activating") && manifest.activatedAt !== null) {
+    throw new Error(
+      `${manifest.activationState} manifests must not have activatedAt`
+    );
+  }
+}
+function managedAdapterInventoriesMatch(left, right) {
+  const leftKeys = managedAdapterNames(left);
+  const rightKeys = managedAdapterNames(right);
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (adapter, index) => adapter === rightKeys[index] && left[adapter] === right[adapter]
+  );
+}
+function compareVersions(left, right) {
+  const [leftCore = "", leftPrerelease] = left.split("-", 2);
+  const [rightCore = "", rightPrerelease] = right.split("-", 2);
+  const leftParts = leftCore.split(".").map(Number);
+  const rightParts = rightCore.split(".").map(Number);
+  for (let index = 0; index < 3; index += 1) {
+    const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (delta !== 0) return delta;
+  }
+  if (leftPrerelease === rightPrerelease) return 0;
+  if (leftPrerelease === void 0) return 1;
+  if (rightPrerelease === void 0) return -1;
+  return comparePrerelease(leftPrerelease, rightPrerelease);
+}
+function comparePrerelease(left, right) {
+  const leftParts = left.split(".");
+  const rightParts = right.split(".");
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index];
+    const rightPart = rightParts[index];
+    if (leftPart === void 0) return -1;
+    if (rightPart === void 0) return 1;
+    if (leftPart === rightPart) continue;
+    const leftNumeric = /^\d+$/.test(leftPart);
+    const rightNumeric = /^\d+$/.test(rightPart);
+    if (leftNumeric && rightNumeric)
+      return Number(leftPart) - Number(rightPart);
+    if (leftNumeric) return -1;
+    if (rightNumeric) return 1;
+    return leftPart.localeCompare(rightPart, "en");
+  }
+  return 0;
+}
+function sameLegacyBaseline(left, right) {
+  return left === right || left !== null && right !== null && left.stateDigest === right.stateDigest && left.workflowIndexDigest === right.workflowIndexDigest;
+}
+function allowedManifestTransitions(from) {
+  switch (from) {
+    case "initializing":
+      return /* @__PURE__ */ new Set(["v3_active", "repair_required"]);
+    case "dual_read":
+      return /* @__PURE__ */ new Set(["activating", "repair_required"]);
+    case "activating":
+      return /* @__PURE__ */ new Set(["v3_active", "repair_required"]);
+    case "repair_required":
+      return /* @__PURE__ */ new Set(["v3_active"]);
+    case "v3_active":
+      return /* @__PURE__ */ new Set(["repair_required"]);
   }
-  const remote = parseNonEmptyStringOrNull5(
-    value.remote,
-    "project config transport remote"
+}
+
+// src/context/privacy-policy.ts
+var PRIVACY_MIN_VERSION = "0.6.5";
+var PRIVACY_POLICY_FILE = "shared/context/privacy-policy.json";
+var PRIVACY_EXCLUSIONS_FILE = "shared/context/privacy-exclusions.json";
+function parsePrivacyPolicyCandidate(value) {
+  assertRecord(value, "privacy policy candidate");
+  assertKnownKeys(
+    value,
+    ["schemaVersion", "enabled", "rulesetVersion", "enabledRuleIds"],
+    "privacy policy candidate"
+  );
+  if (value.schemaVersion !== 1 || typeof value.enabled !== "boolean")
+    throw new Error("MANCODE_PRIVACY_POLICY_INVALID");
+  if (value.rulesetVersion !== RULESET_VERSION)
+    throw new Error("MANCODE_PRIVACY_RULESET_UNSUPPORTED");
+  if (!Array.isArray(value.enabledRuleIds) || value.enabledRuleIds.some(
+    (id) => typeof id !== "string" || !DEFAULT_RULE_IDS.includes(id)
+  ) || new Set(value.enabledRuleIds).size !== value.enabledRuleIds.length)
+    throw new Error("MANCODE_PRIVACY_RULE_UNSUPPORTED");
+  if (value.enabled && value.enabledRuleIds.length === 0)
+    throw new Error("MANCODE_PRIVACY_EMPTY_RULESET");
+  return {
+    schemaVersion: 1,
+    enabled: value.enabled,
+    rulesetVersion: value.rulesetVersion,
+    enabledRuleIds: [...value.enabledRuleIds].sort()
+  };
+}
+function parsePrivacyPolicy(value) {
+  assertRecord(value, "privacy policy");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "revision",
+      "workspaceId",
+      "enabled",
+      "rulesetVersion",
+      "enabledRuleIds",
+      "targets",
+      "exclusions",
+      "lastOperationId",
+      "updatedAt"
+    ],
+    "privacy policy"
+  );
+  const candidate = parsePrivacyPolicyCandidate({
+    schemaVersion: value.schemaVersion,
+    enabled: value.enabled,
+    rulesetVersion: value.rulesetVersion,
+    enabledRuleIds: value.enabledRuleIds
+  });
+  assertUlid(value.workspaceId, "privacy workspaceId");
+  assertUlid(value.lastOperationId, "privacy lastOperationId");
+  if (!Array.isArray(value.targets) || value.targets.length !== 2 || value.targets[0] !== "shared_write" || value.targets[1] !== "context_output")
+    throw new Error("MANCODE_PRIVACY_POLICY_INVALID");
+  assertRecord(value.exclusions, "privacy exclusions reference");
+  assertKnownKeys(
+    value.exclusions,
+    ["revision", "digest"],
+    "privacy exclusions reference"
+  );
+  return {
+    ...candidate,
+    revision: revision(value.revision),
+    workspaceId: value.workspaceId,
+    targets: ["shared_write", "context_output"],
+    exclusions: {
+      revision: revision(value.exclusions.revision),
+      digest: digest(value.exclusions.digest)
+    },
+    lastOperationId: value.lastOperationId,
+    updatedAt: timestamp(value.updatedAt)
+  };
+}
+function parsePrivacyExclusions(value) {
+  assertRecord(value, "privacy exclusions");
+  assertKnownKeys(
+    value,
+    [
+      "schemaVersion",
+      "revision",
+      "workspaceId",
+      "entries",
+      "lastOperationId",
+      "updatedAt"
+    ],
+    "privacy exclusions"
+  );
+  if (value.schemaVersion !== 1 || !Array.isArray(value.entries))
+    throw new Error("MANCODE_PRIVACY_EXCLUSIONS_INVALID");
+  assertUlid(value.workspaceId, "privacy exclusions workspaceId");
+  assertUlid(value.lastOperationId, "privacy exclusions operationId");
+  const entries = value.entries.map((entry) => {
+    assertRecord(entry, "privacy exclusion");
+    assertKnownKeys(
+      entry,
+      ["kind", "relativePath", "entityDigest"],
+      "privacy exclusion"
+    );
+    const ulid = "[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}";
+    const pattern = entry.kind === "confirmed_decision" ? new RegExp(`^shared/memory/decisions/${ulid}\\.json$`) : entry.kind === "checkpoint" ? new RegExp(`^shared/workflows/${ulid}/checkpoints/${ulid}\\.json$`) : null;
+    if (pattern === null || typeof entry.relativePath !== "string" || !pattern.test(entry.relativePath))
+      throw new Error("MANCODE_PRIVACY_EXCLUSION_PATH_INVALID");
+    return {
+      kind: entry.kind,
+      relativePath: entry.relativePath,
+      entityDigest: digest(entry.entityDigest)
+    };
+  });
+  if (new Set(entries.map((entry) => entry.relativePath)).size !== entries.length)
+    throw new Error("MANCODE_PRIVACY_EXCLUSIONS_DUPLICATE");
+  return {
+    schemaVersion: 1,
+    revision: revision(value.revision),
+    workspaceId: value.workspaceId,
+    entries: entries.sort(
+      (a, b) => a.relativePath.localeCompare(b.relativePath, "en")
+    ),
+    lastOperationId: value.lastOperationId,
+    updatedAt: timestamp(value.updatedAt)
+  };
+}
+function createInitialPrivacyPolicy(input) {
+  const exclusions = parsePrivacyExclusions({
+    schemaVersion: 1,
+    revision: 1,
+    workspaceId: input.workspaceId,
+    entries: [],
+    lastOperationId: input.operationId,
+    updatedAt: input.now
+  });
+  const policy = parsePrivacyPolicy({
+    schemaVersion: 1,
+    revision: 1,
+    workspaceId: input.workspaceId,
+    enabled: input.enabled ?? true,
+    rulesetVersion: RULESET_VERSION,
+    enabledRuleIds: [...DEFAULT_RULE_IDS],
+    targets: ["shared_write", "context_output"],
+    exclusions: { revision: 1, digest: digestCanonicalJson(exclusions) },
+    lastOperationId: input.operationId,
+    updatedAt: input.now
+  });
+  return { policy, exclusions, digest: digestCanonicalJson(policy) };
+}
+function assertPrivacyPolicyTransition(previous, next) {
+  if (next.revision !== (previous?.revision ?? 0) + 1 || previous !== null && (previous.workspaceId !== next.workspaceId || previous.lastOperationId === next.lastOperationId))
+    throw new Error("MANCODE_PRIVACY_POLICY_REVISION_CONFLICT");
+}
+function assertPrivacyExclusionsTransition(previous, next) {
+  if (next.revision !== (previous?.revision ?? 0) + 1 || previous !== null && previous.workspaceId !== next.workspaceId)
+    throw new Error("MANCODE_PRIVACY_POLICY_REVISION_CONFLICT");
+  if (previous?.entries.some(
+    (entry) => !next.entries.some(
+      (nextEntry) => nextEntry.relativePath === entry.relativePath && nextEntry.entityDigest === entry.entityDigest
+    )
+  ))
+    throw new Error("MANCODE_PRIVACY_EXCLUSION_REMOVAL_FORBIDDEN");
+}
+async function readPrivacyPolicySnapshot(root, manifest) {
+  await assertNoPendingPrivacyPolicyOperation(root);
+  const current = manifest ?? parseSchemaManifest(
+    JSON.parse(await readPrivacyAuthorityFile(root, "schema.json"))
   );
-  if (value.mode === "local" && remote !== null) {
-    throw new Error("local project config transport must not set a remote");
+  if (current.manifestVersion !== 3) return null;
+  const [policy, exclusions, config] = await Promise.all([
+    readPrivacyAuthorityFile(root, PRIVACY_POLICY_FILE).then(
+      (content) => parsePrivacyPolicy(JSON.parse(content))
+    ),
+    readPrivacyAuthorityFile(root, PRIVACY_EXCLUSIONS_FILE).then(
+      (content) => parsePrivacyExclusions(JSON.parse(content))
+    ),
+    readPrivacyAuthorityFile(root, "shared/config.json").then(
+      (content) => parseProjectConfig(JSON.parse(content))
+    )
+  ]);
+  const policyDigest = digestCanonicalJson(policy);
+  if (policy.workspaceId !== config.workspaceId)
+    throw new Error("MANCODE_PRIVACY_POLICY_WORKSPACE_MISMATCH");
+  if (current.privacyPolicy.revision !== policy.revision || current.privacyPolicy.digest !== policyDigest || policy.workspaceId !== exclusions.workspaceId || policy.exclusions.revision !== exclusions.revision || policy.exclusions.digest !== digestCanonicalJson(exclusions))
+    throw new Error("MANCODE_PRIVACY_POLICY_DIGEST_MISMATCH");
+  return { policy, exclusions, digest: policyDigest };
+}
+async function assertNoPendingPrivacyPolicyOperation(root) {
+  const relative = "local/runtime/operations";
+  let entries;
+  try {
+    const directory = path6.join(root, ".mancode", relative);
+    const stat2 = await lstat3(directory);
+    if (!stat2.isDirectory() || stat2.isSymbolicLink())
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    entries = await readdir3(directory);
+  } catch (error) {
+    if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (!/^[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}\.json$/.test(entry)) continue;
+    const journal = JSON.parse(
+      await readPrivacyAuthorityFile(root, `${relative}/${entry}`)
+    );
+    if (journal.type === "privacy_policy_update" && journal.state !== "committed" && journal.state !== "aborted")
+      throw new Error("MANCODE_PRIVACY_POLICY_REPAIR_REQUIRED");
+  }
+}
+async function readPrivacyPolicyStatus(root) {
+  try {
+    const snapshot = await readPrivacyPolicySnapshot(root);
+    return {
+      schemaVersion: 1,
+      state: snapshot === null ? "unconfigured" : snapshot.policy.enabled ? "enabled" : "disabled",
+      enabled: snapshot?.policy.enabled ?? false,
+      revision: snapshot?.policy.revision ?? 0,
+      digest: snapshot?.digest ?? null,
+      rulesetVersion: snapshot?.policy.rulesetVersion ?? RULESET_VERSION,
+      excludedEntities: snapshot?.exclusions.entries.length ?? 0,
+      scope: "project",
+      error: null
+    };
+  } catch {
+    return {
+      schemaVersion: 1,
+      state: "error",
+      enabled: null,
+      revision: null,
+      digest: null,
+      rulesetVersion: null,
+      excludedEntities: null,
+      scope: "project",
+      error: "MANCODE_PRIVACY_POLICY_UNAVAILABLE"
+    };
+  }
+}
+async function readPrivacyAuthorityFile(root, relative) {
+  let current = path6.join(path6.resolve(root), ".mancode");
+  for (const part of relative.split("/")) {
+    const parent = await lstat3(current);
+    if (!parent.isDirectory() || parent.isSymbolicLink())
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    current = path6.join(current, part);
   }
-  if (value.mode === "git-ref" && remote === null) {
-    throw new Error("git-ref project config transport requires a remote");
+  const stat2 = await lstat3(current);
+  if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.size > 8 * 1024 * 1024)
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  return readFile5(current, "utf8");
+}
+function revision(value) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    throw new Error("MANCODE_PRIVACY_POLICY_INVALID");
+  return value;
+}
+function digest(value) {
+  if (typeof value !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value))
+    throw new Error("MANCODE_PRIVACY_POLICY_INVALID");
+  return value;
+}
+function timestamp(value) {
+  if (typeof value !== "string" || !Number.isFinite(Date.parse(value)))
+    throw new Error("MANCODE_PRIVACY_POLICY_INVALID");
+  return value;
+}
+
+// src/context/privacy-guard.ts
+function containsEnhancedSensitiveText(value, ruleIds) {
+  const stack = [[value]];
+  let visited = 0;
+  while (stack.length > 0) {
+    if (++visited > 1e5) throw new Error("MANCODE_PRIVACY_SCAN_INCOMPLETE");
+    const [item, key] = stack.pop();
+    if (typeof item === "string") {
+      const scan = scanSensitiveText(
+        key === void 0 || item.length === 0 ? item : `${key}: ${item}`,
+        ruleIds
+      );
+      if (scan.status !== "complete")
+        throw new Error("MANCODE_PRIVACY_SCAN_INCOMPLETE");
+      if (scan.findings.length > 0) return true;
+    } else if (Array.isArray(item)) {
+      stack.push(...item.map((content) => [content, key]));
+    } else if (item !== null && typeof item === "object") {
+      for (const [key2, content] of Object.entries(item))
+        stack.push([key2], [content, key2]);
+    }
   }
-  const epoch = value.epoch === void 0 ? 1 : parsePositiveInteger12(value.epoch, "project config transport epoch");
-  return { mode: value.mode, remote, epoch };
+  return false;
 }
-function parseRetention(value) {
-  assertRecord(value, "team policy retention");
-  assertKnownKeys(
-    value,
-    ["localRawArtifactDays", "localCacheDays", "completedSessionDays"],
-    "team policy retention"
+function isPrivacyExcluded(snapshot, value) {
+  if (snapshot === null || snapshot === void 0 || snapshot.exclusions.entries.length === 0)
+    return false;
+  const entityDigest = digestCanonicalJson(value);
+  return snapshot.exclusions.entries.some(
+    (entry) => entry.entityDigest === entityDigest
   );
-  return {
-    localRawArtifactDays: parseNonNegativeInteger9(
-      value.localRawArtifactDays,
-      "team policy retention localRawArtifactDays"
-    ),
-    localCacheDays: parseNonNegativeInteger9(
-      value.localCacheDays,
-      "team policy retention localCacheDays"
-    ),
-    completedSessionDays: parseNonNegativeInteger9(
-      value.completedSessionDays,
-      "team policy retention completedSessionDays"
-    )
-  };
 }
-function assertConfigIdentityStable(previous, next) {
-  if (previous.schemaVersion !== next.schemaVersion || previous.workspaceId !== next.workspaceId) {
-    throw new Error(
-      "project config schemaVersion and workspaceId are immutable"
-    );
+function assertPrivacyValueAllowed(snapshot, value) {
+  if (isPrivacyExcluded(snapshot, value))
+    throw new Error("MANCODE_PRIVACY_ENTITY_EXCLUDED");
+  if (snapshot?.policy.enabled && containsEnhancedSensitiveText(value, snapshot.policy.enabledRuleIds))
+    throw new Error("MANCODE_PRIVACY_BLOCKED");
+}
+async function assertSharedPrivacyValue(root, value) {
+  assertPrivacyValueAllowed(await readSharedPrivacySnapshot(root), value);
+}
+async function readSharedPrivacySnapshot(root) {
+  if (!await hasProjectAuthority(root)) return null;
+  return readPrivacyPolicySnapshot(root);
+}
+async function acquireSharedPrivacyWriteBarrier(root, operationId) {
+  if (!await hasProjectAuthority(root)) return null;
+  const runtime = await readProjectRuntimeContext(root);
+  const deadline = performance.now() + 5e3;
+  for (; ; ) {
+    try {
+      return await acquireProjectWriteBarrier(runtime, operationId, /* @__PURE__ */ new Date());
+    } catch (error) {
+      if (!(error instanceof Error) || error.message !== "MANCODE_LOCK_HELD" || performance.now() >= deadline)
+        throw error;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
   }
 }
-function assertRevisionIncrease(previous, next, label) {
-  if (next !== previous + 1) {
-    throw new Error(`${label} must increase exactly once per mutation`);
+async function withSharedPrivacyWrite(root, operationId, value, write2) {
+  await assertSharedPrivacyValue(root, value);
+  const barrier = await acquireSharedPrivacyWriteBarrier(root, operationId);
+  try {
+    await assertSharedPrivacyValue(root, value);
+    return await write2();
+  } finally {
+    await barrier?.release();
   }
 }
-function parsePositiveInteger12(value, label) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1) {
-    throw new Error(`${label} must be a positive integer`);
+async function assertSharedTaskWriteAtRoot(taskRoot, fileName, content) {
+  const workflows = path7.dirname(taskRoot);
+  const shared = path7.dirname(workflows);
+  const authority = path7.dirname(shared);
+  if (path7.basename(workflows) !== "workflows" || path7.basename(shared) !== "shared" || path7.basename(authority) !== ".mancode")
+    return;
+  await assertSharedPrivacyValue(
+    path7.dirname(authority),
+    privacyContentValue(fileName, content)
+  );
+}
+function assertPrivacyRecoveryActionsAllowed(snapshot, actions) {
+  for (const action of actions) {
+    switch (action.kind) {
+      case "task_authority_file":
+        if (action.taskRef.namespace === "shared")
+          assertPrivacyValueAllowed(
+            snapshot,
+            privacyContentValue(action.fileName, action.targetContent)
+          );
+        break;
+      case "workflow_task_directory":
+      case "migration_task_directory":
+        if (action.taskRef.namespace === "shared") {
+          for (const file of action.files)
+            assertPrivacyValueAllowed(
+              snapshot,
+              privacyContentValue(file.fileName, file.content)
+            );
+          if (action.kind === "migration_task_directory")
+            for (const report of action.reports)
+              assertPrivacyValueAllowed(snapshot, report.content);
+        }
+        break;
+      case "task_archive":
+        if (action.taskRef.namespace === "shared") {
+          assertPrivacyValueAllowed(
+            snapshot,
+            privacyContentValue(
+              "requirements.json",
+              action.requirementsContent
+            )
+          );
+          if (action.planContent !== null)
+            assertPrivacyValueAllowed(snapshot, action.planContent);
+        }
+        break;
+      case "checkpoint":
+        if (action.checkpoint.taskRef.namespace === "shared")
+          assertPrivacyValueAllowed(snapshot, action.checkpoint);
+        break;
+      case "claim":
+        if (action.claim.taskRef.namespace === "shared")
+          assertPrivacyValueAllowed(snapshot, action.claim);
+        break;
+      case "handoff":
+        if (action.handoff.taskRef.namespace === "shared")
+          assertPrivacyValueAllowed(snapshot, action.handoff);
+        break;
+      default:
+        break;
+    }
   }
-  return value;
 }
-function parseNonNegativeInteger9(value, label) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative integer`);
+async function hasProjectAuthority(root) {
+  try {
+    const stat2 = await lstat4(path7.join(root, ".mancode", "schema.json"));
+    if (!stat2.isFile() || stat2.isSymbolicLink())
+      throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    return true;
+  } catch (error) {
+    if (error === null || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT")
+      throw error;
+    try {
+      await lstat4(path7.join(root, ".mancode", "shared", "config.json"));
+    } catch (configError) {
+      if (configError !== null && typeof configError === "object" && "code" in configError && configError.code === "ENOENT")
+        return false;
+      throw configError;
+    }
+    throw new Error("MANCODE_PRIVACY_POLICY_UNAVAILABLE");
   }
-  return value;
 }
-function parseUlidOrNull8(value, label) {
-  if (value === null) return null;
-  assertUlid(value, label);
-  return value;
+function privacyContentValue(fileName, content) {
+  if (!fileName.endsWith(".json")) return content;
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error("MANCODE_PRIVACY_SHARED_JSON_INVALID");
+  }
 }
-function parseNonEmptyStringOrNull5(value, label) {
-  if (value === null) return null;
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${label} must be a non-empty string or null`);
+async function scanPrivacyActivation(root, ruleIds) {
+  const files = await collectSharedFiles(root, "shared");
+  const digests = [];
+  const blockers = [];
+  const exclusions = [];
+  let scannedFiles = 0;
+  for (const relative of files) {
+    if (relative === PRIVACY_POLICY_FILE || relative === PRIVACY_EXCLUSIONS_FILE)
+      continue;
+    const content = await readPrivacyAuthorityFile(root, relative);
+    digests.push({ path: relative, digest: digestCanonicalJson(content) });
+    const fileIndex = scannedFiles++;
+    let value;
+    try {
+      value = privacyContentValue(relative, content);
+    } catch {
+      blockers.push({ fileIndex, reason: "invalid_json" });
+      continue;
+    }
+    if (!containsEnhancedSensitiveText(value, ruleIds)) continue;
+    const ulid = "[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}";
+    const kind = new RegExp(`^shared/memory/decisions/${ulid}\\.json$`).test(
+      relative
+    ) ? "confirmed_decision" : new RegExp(
+      `^shared/workflows/${ulid}/checkpoints/${ulid}\\.json$`
+    ).test(relative) ? "checkpoint" : null;
+    if (kind !== null)
+      exclusions.push({
+        kind,
+        relativePath: relative,
+        entityDigest: digestCanonicalJson(value)
+      });
+    else blockers.push({ fileIndex, reason: "sensitive_content" });
   }
-  return value;
+  return {
+    fingerprint: digestCanonicalJson(digests),
+    scannedFiles,
+    blockers,
+    exclusions
+  };
 }
-function parseTimestamp12(value, label) {
-  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
-    throw new Error(`${label} must be an ISO timestamp`);
+async function collectSharedFiles(root, relative) {
+  const target = path7.join(root, ".mancode", relative);
+  const stat2 = await lstat4(target);
+  if (!stat2.isDirectory() || stat2.isSymbolicLink())
+    throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+  const files = [];
+  for (const entry of (await readdir4(target, { withFileTypes: true })).sort(
+    (a, b) => a.name.localeCompare(b.name, "en")
+  )) {
+    if (entry.isSymbolicLink()) throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    const child = `${relative}/${entry.name}`;
+    if (entry.isDirectory())
+      files.push(...await collectSharedFiles(root, child));
+    else if (entry.isFile()) files.push(child);
+    else throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
+    if (files.length > 1e5)
+      throw new Error("MANCODE_PRIVACY_SCAN_INCOMPLETE");
   }
-  return value;
+  return files;
 }
 
 // src/context/confirmed-decision.ts
-import { lstat as lstat2, mkdir as mkdir2, readFile as readFile3, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
-import path5 from "path";
 var DECISION_FILENAME = /^[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}\.json$/;
 function createConfirmedDecision(input) {
   assertUlid(input.decisionId, "confirmed decision decisionId");
@@ -5891,8 +7541,8 @@ function confirmedDecisionDigest(decision) {
   return digestCanonicalJson(parseConfirmedDecision(decision));
 }
 function confirmedDecisionDirectory(projectRoot) {
-  return path5.join(
-    path5.resolve(projectRoot),
+  return path8.join(
+    path8.resolve(projectRoot),
     ".mancode",
     "shared",
     "memory",
@@ -5901,421 +7551,162 @@ function confirmedDecisionDirectory(projectRoot) {
 }
 function confirmedDecisionPath(projectRoot, decisionId) {
   assertUlid(decisionId, "confirmed decision decisionId");
-  return path5.join(
+  return path8.join(
     confirmedDecisionDirectory(projectRoot),
     `${decisionId}.json`
   );
 }
 async function publishConfirmedDecision(projectRoot, decision) {
+  const parsed = parseConfirmedDecision(decision);
+  return withSharedPrivacyWrite(
+    projectRoot,
+    parsed.operationId,
+    parsed,
+    () => publishConfirmedDecisionUnlocked(projectRoot, parsed)
+  );
+}
+async function publishConfirmedDecisionUnlocked(projectRoot, decision) {
   const parsed = parseConfirmedDecision(decision);
   const directory = confirmedDecisionDirectory(projectRoot);
   await ensureSafeDirectory(projectRoot, directory);
   const target = confirmedDecisionPath(projectRoot, parsed.decisionId);
   try {
-    await writeFile2(target, `${JSON.stringify(parsed, null, 2)}
+    await writeFile4(target, `${JSON.stringify(parsed, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
     return parsed;
   } catch (error) {
-    if (!isAlreadyExists2(error)) throw error;
-    const existing = await readConfirmedDecision(
-      projectRoot,
-      parsed.decisionId
-    );
-    if (existing !== null && confirmedDecisionDigest(existing) === confirmedDecisionDigest(parsed)) {
-      return existing;
-    }
-    throw new Error("MANCODE_CONFIRMED_DECISION_ID_CONFLICT");
-  }
-}
-async function readConfirmedDecision(projectRoot, decisionId) {
-  assertUlid(decisionId, "confirmed decision decisionId");
-  try {
-    return parseConfirmedDecision(
-      JSON.parse(
-        await readSafeText(
-          confirmedDecisionDirectory(projectRoot),
-          `${decisionId}.json`
-        )
-      )
-    );
-  } catch (error) {
-    if (isNotFound3(error)) return null;
-    if (error instanceof SyntaxError) {
-      throw new Error("MANCODE_CONFIRMED_DECISION_CORRUPT");
-    }
-    throw error;
-  }
-}
-async function listConfirmedDecisions(projectRoot) {
-  const directory = confirmedDecisionDirectory(projectRoot);
-  let entries;
-  try {
-    await assertSafeDirectory(directory);
-    entries = await readdir2(directory);
-  } catch (error) {
-    if (isNotFound3(error)) return [];
-    throw error;
-  }
-  const decisions = [];
-  for (const entry of entries.sort(compareUtf82)) {
-    if (!entry.endsWith(".json")) continue;
-    if (!DECISION_FILENAME.test(entry)) {
-      throw new Error("MANCODE_CONTEXT_COLLECTION_ENTRY_INVALID");
-    }
-    const decision = await readConfirmedDecision(
-      projectRoot,
-      entry.slice(0, -".json".length)
-    );
-    if (decision === null) {
-      throw new Error("MANCODE_CONTEXT_COLLECTION_CHANGED_DURING_READ");
-    }
-    decisions.push(decision);
-  }
-  return decisions.sort(
-    (left, right) => compareUtf82(left.decisionId, right.decisionId)
-  );
-}
-function parseDecisionText(value, label, maxLength) {
-  if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > maxLength) {
-    throw new Error(`${label} is invalid`);
-  }
-  assertSharedTextSafe(value, label);
-  return value;
-}
-function parseTimestamp13(value, label) {
-  if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
-    throw new Error(`${label} must be an ISO timestamp`);
-  }
-  return value;
-}
-async function ensureSafeDirectory(projectRoot, directory) {
-  const root = path5.resolve(projectRoot);
-  const target = path5.resolve(directory);
-  const relative = path5.relative(root, target);
-  if (!relative || path5.isAbsolute(relative) || relative.split(path5.sep).some((segment) => segment === "..")) {
-    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
-  }
-  await assertSafeDirectory(root);
-  let current = root;
-  for (const segment of relative.split(path5.sep)) {
-    current = path5.join(current, segment);
-    try {
-      await mkdir2(current);
-    } catch (error) {
-      if (!isAlreadyExists2(error)) throw error;
-    }
-    await assertSafeDirectory(current);
-  }
-}
-async function assertSafeDirectory(directory) {
-  const stat2 = await lstat2(directory);
-  if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
-    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
-  }
-}
-async function readSafeText(directory, filename) {
-  await assertSafeDirectory(directory);
-  const target = path5.join(directory, filename);
-  const before = await lstat2(target);
-  if (!before.isFile() || before.isSymbolicLink()) {
-    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
-  }
-  const content = await readFile3(target, "utf8");
-  await assertSafeDirectory(directory);
-  const after = await lstat2(target);
-  if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
-    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
-  }
-  return content;
-}
-function compareUtf82(left, right) {
-  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
-}
-function isAlreadyExists2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
-}
-function isNotFound3(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-
-// src/context/manifest.ts
-var ACTIVATION_STATES = /* @__PURE__ */ new Set([
-  "initializing",
-  "dual_read",
-  "activating",
-  "v3_active",
-  "repair_required"
-]);
-var MANAGED_ADAPTERS = [
-  "claude-code",
-  "codex",
-  "cursor",
-  "copilot",
-  "zcode",
-  "kimi-code",
-  "qoder",
-  "dsh"
-];
-var VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
-var DIGEST_PATTERN13 = /^sha256:[a-f0-9]{64}$/;
-function parseSchemaManifest(value) {
-  assertRecord(value, "schema manifest");
-  if (value.manifestVersion !== 1 && value.manifestVersion !== 2) {
-    throw new Error(
-      `MANCODE_MANIFEST_VERSION_UNSUPPORTED: observed=${String(value.manifestVersion)} supported=1,2 requiredWriter=0.4.0`
-    );
-  }
-  const manifestVersion = value.manifestVersion;
-  assertKnownKeys(
-    value,
-    [
-      "manifestVersion",
-      "layoutVersion",
-      "epoch",
-      "activationState",
-      "minReaderVersion",
-      "minWriterVersion",
-      "activatedAt",
-      "legacyBaseline",
-      "managedAdapters",
-      "lastOperationId",
-      ...manifestVersion === 2 ? ["workflowPolicyDefaults"] : []
-    ],
-    "schema manifest"
-  );
-  if (value.layoutVersion !== 3) {
-    throw new Error("schema manifest must use layoutVersion 3");
-  }
-  assertUlid(value.epoch, "schema manifest epoch");
-  if (typeof value.activationState !== "string" || !ACTIVATION_STATES.has(value.activationState)) {
-    throw new Error("schema manifest activationState is invalid");
-  }
-  const common = {
-    layoutVersion: 3,
-    epoch: value.epoch,
-    activationState: value.activationState,
-    minReaderVersion: parseVersion(value.minReaderVersion, "minReaderVersion"),
-    minWriterVersion: parseVersion(value.minWriterVersion, "minWriterVersion"),
-    activatedAt: parseTimestampOrNull3(value.activatedAt, "activatedAt"),
-    legacyBaseline: parseLegacyBaseline(value.legacyBaseline),
-    managedAdapters: parseManagedAdapters(value.managedAdapters),
-    lastOperationId: parseUlidOrNull9(value.lastOperationId, "lastOperationId")
-  };
-  const manifest = manifestVersion === 1 ? { manifestVersion: 1, ...common } : {
-    manifestVersion: 2,
-    ...common,
-    workflowPolicyDefaults: parseWorkflowPolicyDefaults(
-      value.workflowPolicyDefaults
-    )
-  };
-  assertManifestStateShape(manifest);
-  if (manifest.manifestVersion === 2 && (compareVersions(manifest.minReaderVersion, "0.4.0") < 0 || compareVersions(manifest.minWriterVersion, "0.4.0") < 0)) {
-    throw new Error(
-      "schema manifest V2 requires minReaderVersion and minWriterVersion 0.4.0 or newer"
-    );
-  }
-  return manifest;
-}
-function serializeSchemaManifest(value) {
-  return `${JSON.stringify(parseSchemaManifest(value), null, 2)}
-`;
-}
-function managedAdapterNames(inventory) {
-  return MANAGED_ADAPTERS.filter((adapter) => inventory[adapter] !== void 0);
-}
-function parseSchemaManifestV2(value) {
-  const manifest = parseSchemaManifest(value);
-  if (manifest.manifestVersion !== 2) {
-    throw new Error(
-      `MANCODE_MANIFEST_VERSION_UNSUPPORTED: observed=${manifest.manifestVersion} supported=2 requiredWriter=0.4.0`
+    if (!isAlreadyExists4(error)) throw error;
+    const existing = await readConfirmedDecision(
+      projectRoot,
+      parsed.decisionId
     );
+    if (existing !== null && confirmedDecisionDigest(existing) === confirmedDecisionDigest(parsed)) {
+      return existing;
+    }
+    throw new Error("MANCODE_CONFIRMED_DECISION_ID_CONFLICT");
   }
-  return manifest;
 }
-function assertSchemaManifestTransition(previous, next) {
-  if (previous.manifestVersion !== next.manifestVersion || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || compareVersions(next.minReaderVersion, previous.minReaderVersion) < 0 || compareVersions(next.minWriterVersion, previous.minWriterVersion) < 0) {
-    throw new Error(
-      "schema manifest identity and legacy baseline are immutable"
-    );
-  }
-  if (previous.activationState === next.activationState) return;
-  if (!allowedManifestTransitions(previous.activationState).has(
-    next.activationState
-  )) {
-    throw new Error(
-      `invalid schema manifest transition: ${previous.activationState} -> ${next.activationState}`
+async function readConfirmedDecision(projectRoot, decisionId) {
+  assertUlid(decisionId, "confirmed decision decisionId");
+  try {
+    return parseConfirmedDecision(
+      JSON.parse(
+        await readSafeText(
+          confirmedDecisionDirectory(projectRoot),
+          `${decisionId}.json`
+        )
+      )
     );
+  } catch (error) {
+    if (isNotFound5(error)) return null;
+    if (error instanceof SyntaxError) {
+      throw new Error("MANCODE_CONFIRMED_DECISION_CORRUPT");
+    }
+    throw error;
   }
 }
-function assertSchemaManifestPolicyUpgrade(previous, next) {
-  if (previous.manifestVersion !== 1 || next.manifestVersion !== 2 || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || previous.activationState !== "v3_active" || next.activationState !== "v3_active" || previous.activatedAt !== next.activatedAt || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || !managedAdapterInventoriesMatch(
-    previous.managedAdapters,
-    next.managedAdapters
-  ) || compareVersions(next.minReaderVersion, previous.minReaderVersion) < 0 || compareVersions(next.minWriterVersion, previous.minWriterVersion) < 0 || next.workflowPolicyDefaults.planning !== 2 || next.lastOperationId === null || next.lastOperationId === previous.lastOperationId) {
-    throw new Error("invalid schema manifest Policy 2 upgrade");
-  }
-}
-function assertActivationRollbackManifestTransition(previous, next) {
-  if (previous.manifestVersion !== next.manifestVersion || previous.layoutVersion !== next.layoutVersion || previous.epoch !== next.epoch || !sameLegacyBaseline(previous.legacyBaseline, next.legacyBaseline) || previous.activationState !== "v3_active" || next.activationState !== "dual_read" || previous.activatedAt === null || next.activatedAt !== null) {
-    throw new Error("invalid activation rollback manifest transition");
+async function listConfirmedDecisions(projectRoot) {
+  const directory = confirmedDecisionDirectory(projectRoot);
+  let entries;
+  try {
+    await assertSafeDirectory(directory);
+    entries = await readdir5(directory);
+  } catch (error) {
+    if (isNotFound5(error)) return [];
+    throw error;
   }
-}
-function parseWorkflowPolicyDefaults(value) {
-  assertRecord(value, "schema manifest workflowPolicyDefaults");
-  assertKnownKeys(
-    value,
-    ["planning"],
-    "schema manifest workflowPolicyDefaults"
-  );
-  if (value.planning !== 2) {
-    throw new Error(
-      `MANCODE_POLICY_VERSION_UNSUPPORTED: component=planning observed=${String(value.planning)} supported=2 requiredWriter=0.4.0`
+  const decisions = [];
+  for (const entry of entries.sort(compareUtf83)) {
+    if (!entry.endsWith(".json")) continue;
+    if (!DECISION_FILENAME.test(entry)) {
+      throw new Error("MANCODE_CONTEXT_COLLECTION_ENTRY_INVALID");
+    }
+    const decision = await readConfirmedDecision(
+      projectRoot,
+      entry.slice(0, -".json".length)
     );
+    if (decision === null) {
+      throw new Error("MANCODE_CONTEXT_COLLECTION_CHANGED_DURING_READ");
+    }
+    decisions.push(decision);
   }
-  return { planning: 2 };
+  return decisions.sort(
+    (left, right) => compareUtf83(left.decisionId, right.decisionId)
+  );
 }
-function parseVersion(value, label) {
-  if (typeof value !== "string" || !VERSION_PATTERN.test(value)) {
-    throw new Error(`schema manifest ${label} must be a semantic version`);
+function parseDecisionText(value, label, maxLength) {
+  if (typeof value !== "string" || !value.trim() || value.includes("\0") || value.length > maxLength) {
+    throw new Error(`${label} is invalid`);
   }
+  assertSharedTextSafe(value, label);
   return value;
 }
-function parseTimestampOrNull3(value, label) {
-  if (value === null) return null;
+function parseTimestamp13(value, label) {
   if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
-    throw new Error(
-      `schema manifest ${label} must be an ISO timestamp or null`
-    );
+    throw new Error(`${label} must be an ISO timestamp`);
   }
   return value;
 }
-function parseLegacyBaseline(value) {
-  if (value === null) return null;
-  assertRecord(value, "schema manifest legacyBaseline");
-  assertKnownKeys(
-    value,
-    ["stateDigest", "workflowIndexDigest"],
-    "schema manifest legacyBaseline"
-  );
-  if (typeof value.stateDigest !== "string" || !DIGEST_PATTERN13.test(value.stateDigest) || typeof value.workflowIndexDigest !== "string" || !DIGEST_PATTERN13.test(value.workflowIndexDigest)) {
-    throw new Error(
-      "schema manifest legacyBaseline must contain sha256 digests"
-    );
+async function ensureSafeDirectory(projectRoot, directory) {
+  const root = path8.resolve(projectRoot);
+  const target = path8.resolve(directory);
+  const relative = path8.relative(root, target);
+  if (!relative || path8.isAbsolute(relative) || relative.split(path8.sep).some((segment) => segment === "..")) {
+    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
-  return {
-    stateDigest: value.stateDigest,
-    workflowIndexDigest: value.workflowIndexDigest
-  };
-}
-function parseManagedAdapters(value) {
-  assertRecord(value, "schema manifest managedAdapters");
-  assertKnownKeys(value, MANAGED_ADAPTERS, "schema manifest managedAdapters");
-  const adapters = {};
-  for (const adapter of MANAGED_ADAPTERS) {
-    const version = value[adapter];
-    if (version === void 0) continue;
-    if (typeof version !== "string" || !version.trim()) {
-      throw new Error(
-        `schema manifest managedAdapters.${adapter} must be a non-empty version`
-      );
+  await assertSafeDirectory(root);
+  let current = root;
+  for (const segment of relative.split(path8.sep)) {
+    current = path8.join(current, segment);
+    try {
+      await mkdir4(current);
+    } catch (error) {
+      if (!isAlreadyExists4(error)) throw error;
     }
-    adapters[adapter] = version;
+    await assertSafeDirectory(current);
   }
-  return adapters;
-}
-function parseUlidOrNull9(value, label) {
-  if (value === null) return null;
-  assertUlid(value, `schema manifest ${label}`);
-  return value;
 }
-function assertManifestStateShape(manifest) {
-  if (manifest.activationState === "initializing" && manifest.legacyBaseline !== null) {
-    throw new Error(
-      "greenfield initializing manifests must not have a legacy baseline"
-    );
-  }
-  if ((manifest.activationState === "dual_read" || manifest.activationState === "activating") && manifest.legacyBaseline === null) {
-    throw new Error(
-      `${manifest.activationState} manifests require a legacy baseline`
-    );
-  }
-  if (manifest.activationState === "v3_active" && manifest.activatedAt === null) {
-    throw new Error("v3_active manifests require activatedAt");
-  }
-  if ((manifest.activationState === "initializing" || manifest.activationState === "dual_read" || manifest.activationState === "activating") && manifest.activatedAt !== null) {
-    throw new Error(
-      `${manifest.activationState} manifests must not have activatedAt`
-    );
+async function assertSafeDirectory(directory) {
+  const stat2 = await lstat5(directory);
+  if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
+    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
 }
-function managedAdapterInventoriesMatch(left, right) {
-  const leftKeys = managedAdapterNames(left);
-  const rightKeys = managedAdapterNames(right);
-  return leftKeys.length === rightKeys.length && leftKeys.every(
-    (adapter, index) => adapter === rightKeys[index] && left[adapter] === right[adapter]
-  );
-}
-function compareVersions(left, right) {
-  const [leftCore = "", leftPrerelease] = left.split("-", 2);
-  const [rightCore = "", rightPrerelease] = right.split("-", 2);
-  const leftParts = leftCore.split(".").map(Number);
-  const rightParts = rightCore.split(".").map(Number);
-  for (let index = 0; index < 3; index += 1) {
-    const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
-    if (delta !== 0) return delta;
+async function readSafeText(directory, filename) {
+  await assertSafeDirectory(directory);
+  const target = path8.join(directory, filename);
+  const before = await lstat5(target);
+  if (!before.isFile() || before.isSymbolicLink()) {
+    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
-  if (leftPrerelease === rightPrerelease) return 0;
-  if (leftPrerelease === void 0) return 1;
-  if (rightPrerelease === void 0) return -1;
-  return comparePrerelease(leftPrerelease, rightPrerelease);
-}
-function comparePrerelease(left, right) {
-  const leftParts = left.split(".");
-  const rightParts = right.split(".");
-  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
-    const leftPart = leftParts[index];
-    const rightPart = rightParts[index];
-    if (leftPart === void 0) return -1;
-    if (rightPart === void 0) return 1;
-    if (leftPart === rightPart) continue;
-    const leftNumeric = /^\d+$/.test(leftPart);
-    const rightNumeric = /^\d+$/.test(rightPart);
-    if (leftNumeric && rightNumeric)
-      return Number(leftPart) - Number(rightPart);
-    if (leftNumeric) return -1;
-    if (rightNumeric) return 1;
-    return leftPart.localeCompare(rightPart, "en");
+  const content = await readFile6(target, "utf8");
+  await assertSafeDirectory(directory);
+  const after = await lstat5(target);
+  if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
+    throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
-  return 0;
+  return content;
 }
-function sameLegacyBaseline(left, right) {
-  return left === right || left !== null && right !== null && left.stateDigest === right.stateDigest && left.workflowIndexDigest === right.workflowIndexDigest;
+function compareUtf83(left, right) {
+  return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
 }
-function allowedManifestTransitions(from) {
-  switch (from) {
-    case "initializing":
-      return /* @__PURE__ */ new Set(["v3_active", "repair_required"]);
-    case "dual_read":
-      return /* @__PURE__ */ new Set(["activating", "repair_required"]);
-    case "activating":
-      return /* @__PURE__ */ new Set(["v3_active", "repair_required"]);
-    case "repair_required":
-      return /* @__PURE__ */ new Set(["v3_active"]);
-    case "v3_active":
-      return /* @__PURE__ */ new Set(["repair_required"]);
-  }
+function isAlreadyExists4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isNotFound5(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
 // src/context/project-facts.ts
-import { mkdir as mkdir3, readFile as readFile5, rename, rm, writeFile as writeFile3 } from "fs/promises";
-import path7 from "path";
+import { mkdir as mkdir5, readFile as readFile8, rename as rename3, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import path10 from "path";
 
 // src/system/project-profile.ts
-import { readFile as readFile4, readdir as readdir3, stat } from "fs/promises";
-import path6 from "path";
+import { readFile as readFile7, readdir as readdir6, stat } from "fs/promises";
+import path9 from "path";
 var PROJECT_MANIFESTS = [
   "package.json",
   "pyproject.toml",
@@ -6373,29 +7764,29 @@ var PROJECT_SOURCE_ROOTS = [
 var PROJECT_MANIFEST_NAMES = new Set(PROJECT_MANIFESTS);
 var PROJECT_SOURCE_ROOT_NAMES = new Set(PROJECT_SOURCE_ROOTS);
 async function hasProjectEvidence(projectRoot) {
-  const entries = await readdir3(projectRoot, { withFileTypes: true }).catch(
+  const entries = await readdir6(projectRoot, { withFileTypes: true }).catch(
     () => []
   );
   return entries.some((entry) => {
     if (entry.isDirectory()) return PROJECT_SOURCE_ROOT_NAMES.has(entry.name);
     if (!entry.isFile()) return false;
-    return PROJECT_MANIFEST_NAMES.has(entry.name) || PROJECT_SOURCE_EXTENSIONS.has(path6.extname(entry.name).toLowerCase());
+    return PROJECT_MANIFEST_NAMES.has(entry.name) || PROJECT_SOURCE_EXTENSIONS.has(path9.extname(entry.name).toLowerCase());
   });
 }
 async function detectProjectProfile(projectRoot) {
-  const entries = await readdir3(projectRoot).catch(() => []);
+  const entries = await readdir6(projectRoot).catch(() => []);
   const manifests = PROJECT_MANIFESTS.filter((file) => entries.includes(file));
   const sourceRoots = await existingDirs(projectRoot, [
     ...PROJECT_SOURCE_ROOTS,
     "data",
     "notebooks"
   ]);
-  const packageJson = await readJson(path6.join(projectRoot, "package.json"));
+  const packageJson = await readJson(path9.join(projectRoot, "package.json"));
   const [pubspec, pythonManifests] = await Promise.all([
-    readText(path6.join(projectRoot, "pubspec.yaml")),
+    readText(path9.join(projectRoot, "pubspec.yaml")),
     Promise.all([
-      readText(path6.join(projectRoot, "pyproject.toml")),
-      readText(path6.join(projectRoot, "requirements.txt"))
+      readText(path9.join(projectRoot, "pyproject.toml")),
+      readText(path9.join(projectRoot, "requirements.txt"))
     ]).then((parts) => parts.filter(Boolean).join("\n"))
   ]);
   const deps = Object.keys({
@@ -6404,7 +7795,7 @@ async function detectProjectProfile(projectRoot) {
     ...packageJson?.peerDependencies
   });
   const flutter = isFlutterProject(pubspec);
-  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path6.join(projectRoot, "src", "components", "ui"));
+  const shadcn = entries.includes("components.json") || deps.some((dep) => dep.startsWith("@radix-ui/")) && await isDirectory(path9.join(projectRoot, "src", "components", "ui"));
   const languages = inferLanguages(manifests, entries);
   const frameworks = inferFrameworks(
     deps,
@@ -6447,7 +7838,7 @@ async function existingDirs(root, candidates) {
   const found = [];
   for (const candidate of candidates) {
     try {
-      if ((await stat(path6.join(root, candidate))).isDirectory())
+      if ((await stat(path9.join(root, candidate))).isDirectory())
         found.push(candidate);
     } catch {
     }
@@ -6463,14 +7854,14 @@ async function isDirectory(candidate) {
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await readFile4(file, "utf-8"));
+    return JSON.parse(await readFile7(file, "utf-8"));
   } catch {
     return null;
   }
 }
 async function readText(file) {
   try {
-    return await readFile4(file, "utf-8");
+    return await readFile7(file, "utf-8");
   } catch {
     return "";
   }
@@ -6693,8 +8084,8 @@ function parseProjectFacts(value) {
   if (value.schemaVersion !== 1) {
     throw new Error("project facts schemaVersion must be 1");
   }
-  const revision = value.revision;
-  if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 1) {
+  const revision2 = value.revision;
+  if (typeof revision2 !== "number" || !Number.isSafeInteger(revision2) || revision2 < 1) {
     throw new Error("project facts revision must be a positive integer");
   }
   if (value.trust !== "detected") {
@@ -6703,20 +8094,20 @@ function parseProjectFacts(value) {
   const uiLibrary = parseTextOrNull(value.uiLibrary, "project facts uiLibrary");
   return {
     schemaVersion: 1,
-    revision,
+    revision: revision2,
     trust: "detected",
     profile: parseProjectProfile(value.profile),
     uiLibrary,
     detectedAt: parseTimestamp14(value.detectedAt, "project facts detectedAt"),
-    lastOperationId: parseUlidOrNull10(
+    lastOperationId: parseUlidOrNull9(
       value.lastOperationId,
       "project facts lastOperationId"
     )
   };
 }
 function projectFactsPath(projectRoot) {
-  return path7.join(
-    path7.resolve(projectRoot),
+  return path10.join(
+    path10.resolve(projectRoot),
     ".mancode",
     "shared",
     "context",
@@ -6724,22 +8115,31 @@ function projectFactsPath(projectRoot) {
   );
 }
 async function writeProjectFacts(projectRoot, facts) {
+  const parsed = parseProjectFacts(facts);
+  return withSharedPrivacyWrite(
+    projectRoot,
+    parsed.lastOperationId ?? createUlid(),
+    parsed,
+    () => writeProjectFactsUnlocked(projectRoot, parsed)
+  );
+}
+async function writeProjectFactsUnlocked(projectRoot, facts) {
   const parsed = parseProjectFacts(facts);
   const target = projectFactsPath(projectRoot);
-  await mkdir3(path7.dirname(target), { recursive: true });
-  const temporary = path7.join(
-    path7.dirname(target),
-    `.${path7.basename(target)}.${process.pid}.${Date.now()}.tmp`
+  await mkdir5(path10.dirname(target), { recursive: true });
+  const temporary = path10.join(
+    path10.dirname(target),
+    `.${path10.basename(target)}.${process.pid}.${Date.now()}.tmp`
   );
   try {
-    await writeFile3(temporary, `${JSON.stringify(parsed, null, 2)}
+    await writeFile5(temporary, `${JSON.stringify(parsed, null, 2)}
 `, {
       encoding: "utf8",
       flag: "wx"
     });
-    await rename(temporary, target);
+    await rename3(temporary, target);
   } finally {
-    await rm(temporary, { force: true }).catch(() => void 0);
+    await rm2(temporary, { force: true }).catch(() => void 0);
   }
   return parsed;
 }
@@ -6812,7 +8212,7 @@ function parseTextArray(value, label) {
 }
 function parseSafeRelativePathArray(value, label) {
   return parseTextArray(value, label).map((item) => {
-    if (path7.isAbsolute(item) || item.includes("\\") || item.split("/").some((part) => !part || part === "." || part === "..")) {
+    if (path10.isAbsolute(item) || item.includes("\\") || item.split("/").some((part) => !part || part === "." || part === "..")) {
       throw new Error(`${label} must contain safe relative paths`);
     }
     return item;
@@ -6835,17 +8235,17 @@ function parseTimestamp14(value, label) {
   }
   return value;
 }
-function parseUlidOrNull10(value, label) {
+function parseUlidOrNull9(value, label) {
   if (value === null) return null;
   assertUlid(value, label);
   return value;
 }
 
 // src/context/task-locator.ts
-import { lstat as lstat3, readFile as readFile6, realpath } from "fs/promises";
-import path8 from "path";
+import { lstat as lstat6, readFile as readFile9, realpath } from "fs/promises";
+import path11 from "path";
 async function locateTask(projectRoot, requested) {
-  const root = path8.resolve(projectRoot);
+  const root = path11.resolve(projectRoot);
   if (typeof requested !== "string") {
     const taskRef = parseTaskRefValue(requested);
     return locateExplicitTask(root, taskRef);
@@ -6872,8 +8272,8 @@ async function locateTask(projectRoot, requested) {
 }
 function taskRootPath(projectRoot, taskRef) {
   const parsed = parseTaskRefValue(taskRef);
-  return path8.join(
-    path8.resolve(projectRoot),
+  return path11.join(
+    path11.resolve(projectRoot),
     ".mancode",
     parsed.namespace,
     "workflows",
@@ -6889,7 +8289,7 @@ async function locateExplicitTask(projectRoot, taskRef) {
 }
 async function isDirectoryWithoutSymlink(target) {
   try {
-    const entry = await lstat3(target);
+    const entry = await lstat6(target);
     return entry.isDirectory() && !entry.isSymbolicLink();
   } catch {
     return false;
@@ -6907,13 +8307,13 @@ var V3ContextStore = class {
     if (typeof projectRoot !== "string" || !projectRoot.trim()) {
       throw new Error("context store projectRoot is required");
     }
-    this.projectRoot = path9.resolve(projectRoot);
+    this.projectRoot = path12.resolve(projectRoot);
   }
   async locateTask(requested) {
     const location = await locateTask(this.projectRoot, requested);
     await assertSafeDirectoryWithin(
       this.projectRoot,
-      path9.relative(this.projectRoot, location.taskRoot)
+      path12.relative(this.projectRoot, location.taskRoot)
     );
     return location;
   }
@@ -6992,33 +8392,45 @@ var V3ContextStore = class {
       ),
       this.readRequiredJson(
         this.mancodeRoot(),
-        path9.join("shared", "config.json"),
+        path12.join("shared", "config.json"),
         parseProjectConfig
       ),
       this.readRequiredJson(
         this.mancodeRoot(),
-        path9.join("shared", "team", "policy.json"),
+        path12.join("shared", "team", "policy.json"),
         parseTeamPolicy
       ),
       readOptionalJsonWithin(
         this.mancodeRoot(),
-        path9.join("shared", "context", "project.json"),
+        path12.join("shared", "context", "project.json"),
         parseProjectFacts
       ),
       listConfirmedDecisions(this.projectRoot)
     ]);
+    const privacy = await readPrivacyPolicySnapshot(this.projectRoot, manifest);
+    if (privacy !== null && privacy.policy.workspaceId !== config.workspaceId)
+      throw new Error("MANCODE_PRIVACY_POLICY_WORKSPACE_MISMATCH");
+    const verifiedManifest = await this.readRequiredJson(
+      this.mancodeRoot(),
+      "schema.json",
+      parseSchemaManifest
+    );
+    if (digestCanonicalJson(manifest) !== digestCanonicalJson(verifiedManifest))
+      throw new Error("MANCODE_PROJECT_SNAPSHOT_CHANGED");
     return {
       manifest,
       config,
       policy,
       projectFacts,
       confirmedDecisions,
+      privacy,
       fingerprint: digestCanonicalJson({
         manifest,
         config,
         policy,
         projectFacts,
-        confirmedDecisions
+        confirmedDecisions,
+        ...privacy === null ? {} : { privacy }
       })
     };
   }
@@ -7028,7 +8440,7 @@ var V3ContextStore = class {
     const parentRoot = taskRootPath(this.projectRoot, parentRef);
     await assertSafeDirectoryWithin(
       this.projectRoot,
-      path9.relative(this.projectRoot, parentRoot)
+      path12.relative(this.projectRoot, parentRoot)
     );
     const metadata = await this.readRequiredJson(
       parentRoot,
@@ -7094,12 +8506,12 @@ var V3ContextStore = class {
   async listWorkflowMetadata() {
     const workflows = [];
     for (const namespace of ["local", "shared"]) {
-      const directory = path9.join(".mancode", namespace, "workflows");
+      const directory = path12.join(".mancode", namespace, "workflows");
       const entries = await readDirectoryEntriesWithin(
         this.projectRoot,
         directory
       );
-      for (const taskId of entries.sort(compareUtf83)) {
+      for (const taskId of entries.sort(compareUtf84)) {
         try {
           assertUlid(taskId, "workflow directory");
         } catch {
@@ -7109,7 +8521,7 @@ var V3ContextStore = class {
         const taskRoot = taskRootPath(this.projectRoot, taskRef);
         await assertSafeDirectoryWithin(
           this.projectRoot,
-          path9.relative(this.projectRoot, taskRoot)
+          path12.relative(this.projectRoot, taskRoot)
         );
         const metadata = await this.readRequiredJson(
           taskRoot,
@@ -7123,7 +8535,7 @@ var V3ContextStore = class {
       }
     }
     return workflows.sort(
-      (left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || compareUtf83(left.taskRef.namespace, right.taskRef.namespace) || compareUtf83(left.taskRef.taskId, right.taskRef.taskId)
+      (left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || compareUtf84(left.taskRef.namespace, right.taskRef.namespace) || compareUtf84(left.taskRef.taskId, right.taskRef.taskId)
     );
   }
   /**
@@ -7136,11 +8548,11 @@ var V3ContextStore = class {
     return (await this.listWorkflowMetadata()).filter(
       (metadata) => metadata.parent !== null && sameTaskRef(metadata.parent.taskRef, parent) && !isTerminalWorkflowStatus(metadata.status)
     ).map((metadata) => metadata.taskRef).sort(
-      (left, right) => compareUtf83(left.namespace, right.namespace) || compareUtf83(left.taskId, right.taskId)
+      (left, right) => compareUtf84(left.namespace, right.namespace) || compareUtf84(left.taskId, right.taskId)
     );
   }
   mancodeRoot() {
-    return path9.join(this.projectRoot, ".mancode");
+    return path12.join(this.projectRoot, ".mancode");
   }
   async readOptionalPlan(taskRef, taskRoot) {
     const content = await readOptionalTextWithin(taskRoot, "plan.md");
@@ -7160,7 +8572,7 @@ var V3ContextStore = class {
     }
     const checkpoint = await this.readRequiredJson(
       taskRoot,
-      path9.join("checkpoints", `${ref.artifactId}.json`),
+      path12.join("checkpoints", `${ref.artifactId}.json`),
       parseCheckpoint
     );
     if (!sameTaskRef(checkpoint.taskRef, metadata.taskRef)) {
@@ -7171,8 +8583,8 @@ var V3ContextStore = class {
   async readTaskHeadFence(homeStore, taskRef) {
     const value = await readOptionalJsonWithin(
       homeStore.root,
-      path9.join(
-        path9.relative(homeStore.root, taskHeadDirectory(homeStore)),
+      path12.join(
+        path12.relative(homeStore.root, taskHeadDirectory(homeStore)),
         `${taskRef.taskId}.json`
       ),
       parseTaskHeadFence
@@ -7184,16 +8596,16 @@ var V3ContextStore = class {
     return value;
   }
   async readClaims(homeStore, taskRef) {
-    const directory = path9.relative(homeStore.root, claimDirectory(homeStore));
+    const directory = path12.relative(homeStore.root, claimDirectory(homeStore));
     const claims = await readJsonCollectionWithin(
       homeStore.root,
       directory,
       parseClaim
     );
-    return claims.filter((claim) => sameTaskRef(claim.taskRef, taskRef)).sort((left, right) => compareUtf83(left.claimId, right.claimId));
+    return claims.filter((claim) => sameTaskRef(claim.taskRef, taskRef)).sort((left, right) => compareUtf84(left.claimId, right.claimId));
   }
   async readHandoffs(homeStore, taskRef) {
-    const directory = path9.relative(
+    const directory = path12.relative(
       homeStore.root,
       handoffDirectory(homeStore)
     );
@@ -7203,7 +8615,7 @@ var V3ContextStore = class {
       parseHandoff
     );
     return handoffs.filter((handoff) => sameTaskRef(handoff.taskRef, taskRef)).sort(
-      (left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || compareUtf83(left.handoffId, right.handoffId)
+      (left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || compareUtf84(left.handoffId, right.handoffId)
     );
   }
   async readPendingOperations(taskRef, homeStore) {
@@ -7211,12 +8623,12 @@ var V3ContextStore = class {
     const [journals, reservations, gitRefWorkflowRepairs] = await Promise.all([
       readJsonCollectionWithin(
         homeStore.root,
-        path9.relative(homeStore.root, operationDirectory(homeStore)),
+        path12.relative(homeStore.root, operationDirectory(homeStore)),
         parseOperationJournal
       ),
       readJsonCollectionWithin(
         homeStore.root,
-        path9.relative(homeStore.root, reservationDirectory(homeStore)),
+        path12.relative(homeStore.root, reservationDirectory(homeStore)),
         parseOperationReservation
       ),
       listUnfinishedGitRefWorkflowRepairs(this.projectRoot)
@@ -7242,14 +8654,14 @@ var V3ContextStore = class {
       entityKeys: [taskKey]
     }));
     return [...primary, ...secondary, ...gitRefWorkflow].sort(
-      (left, right) => compareUtf83(left.operationId, right.operationId) || left.source.localeCompare(right.source, "en")
+      (left, right) => compareUtf84(left.operationId, right.operationId) || left.source.localeCompare(right.source, "en")
     );
   }
   async readRequiredJson(root, relativePath, parser) {
     try {
       return parser(JSON.parse(await readTextWithin(root, relativePath)));
     } catch (error) {
-      if (isNotFound4(error)) {
+      if (isNotFound6(error)) {
         throw new Error(`MANCODE_CONTEXT_ENTITY_UNAVAILABLE: ${relativePath}`);
       }
       if (error instanceof SyntaxError) {
@@ -7284,7 +8696,7 @@ async function readOptionalJsonWithin(root, relativePath, parser) {
   try {
     return parser(JSON.parse(await readTextWithin(root, relativePath)));
   } catch (error) {
-    if (isNotFound4(error)) return null;
+    if (isNotFound6(error)) return null;
     if (error instanceof SyntaxError) {
       throw new Error(`MANCODE_CONTEXT_ENTITY_CORRUPT: ${relativePath}`);
     }
@@ -7295,14 +8707,14 @@ async function readJsonCollectionWithin(root, relativeDirectory, parser) {
   const entries = await readDirectoryEntriesWithin(root, relativeDirectory);
   const jsonEntries = entries.filter((entry) => entry.endsWith(JSON_SUFFIX));
   const values = [];
-  for (const entry of jsonEntries.sort(compareUtf83)) {
+  for (const entry of jsonEntries.sort(compareUtf84)) {
     const stem = entry.slice(0, -JSON_SUFFIX.length);
     if (!/^[0-7][0-9A-HJKMNPQRSTVWXYZ]{25}$/.test(stem)) {
       throw new Error("MANCODE_CONTEXT_COLLECTION_ENTRY_INVALID");
     }
     const value = await readOptionalJsonWithin(
       root,
-      path9.join(relativeDirectory, entry),
+      path12.join(relativeDirectory, entry),
       parser
     );
     if (value === null) {
@@ -7316,31 +8728,31 @@ async function readOptionalTextWithin(root, relativePath) {
   try {
     return await readTextWithin(root, relativePath);
   } catch (error) {
-    if (isNotFound4(error)) return null;
+    if (isNotFound6(error)) return null;
     throw error;
   }
 }
 async function readTextWithin(root, relativePath) {
-  const absoluteRoot = path9.resolve(root);
+  const absoluteRoot = path12.resolve(root);
   const segments = safeRelativeSegments(relativePath);
   await assertSafeDirectoryWithin(absoluteRoot, ".");
   const parentSegments = segments.slice(0, -1);
   let current = absoluteRoot;
   for (const segment of parentSegments) {
-    current = path9.join(current, segment);
+    current = path12.join(current, segment);
     await assertSafeDirectoryAt(current);
   }
-  const target = path9.join(absoluteRoot, ...segments);
-  const before = await lstat4(target);
+  const target = path12.join(absoluteRoot, ...segments);
+  const before = await lstat7(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
-  const content = await readFile7(target, "utf8");
+  const content = await readFile10(target, "utf8");
   await assertSafeDirectoryWithin(
     absoluteRoot,
-    parentSegments.length === 0 ? "." : path9.join(...parentSegments)
+    parentSegments.length === 0 ? "." : path12.join(...parentSegments)
   );
-  const after = await lstat4(target);
+  const after = await lstat7(target);
   if (!after.isFile() || after.isSymbolicLink() || before.dev !== after.dev || before.ino !== after.ino) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
@@ -7349,43 +8761,43 @@ async function readTextWithin(root, relativePath) {
 async function readDirectoryEntriesWithin(root, relativeDirectory) {
   try {
     const directory = await assertSafeDirectoryWithin(root, relativeDirectory);
-    return await readdir4(directory);
+    return await readdir7(directory);
   } catch (error) {
-    if (isNotFound4(error)) return [];
+    if (isNotFound6(error)) return [];
     throw error;
   }
 }
 async function assertSafeDirectoryWithin(root, relativeDirectory) {
-  const absoluteRoot = path9.resolve(root);
+  const absoluteRoot = path12.resolve(root);
   const segments = relativeDirectory === "." ? [] : safeRelativeSegments(relativeDirectory);
   await assertSafeDirectoryAt(absoluteRoot);
   let current = absoluteRoot;
   for (const segment of segments) {
-    current = path9.join(current, segment);
+    current = path12.join(current, segment);
     await assertSafeDirectoryAt(current);
   }
   return current;
 }
 async function assertSafeDirectoryAt(target) {
-  const stat2 = await lstat4(target);
+  const stat2 = await lstat7(target);
   if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
 }
 function safeRelativeSegments(relativePath) {
-  if (typeof relativePath !== "string" || !relativePath || relativePath.includes("\0") || path9.isAbsolute(relativePath)) {
+  if (typeof relativePath !== "string" || !relativePath || relativePath.includes("\0") || path12.isAbsolute(relativePath)) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
-  const segments = relativePath.split(path9.sep);
+  const segments = relativePath.split(path12.sep);
   if (segments.some((segment) => !segment || segment === "." || segment === "..")) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
   return segments;
 }
-function compareUtf83(left, right) {
+function compareUtf84(left, right) {
   return Buffer.from(left, "utf8").compare(Buffer.from(right, "utf8"));
 }
-function isNotFound4(error) {
+function isNotFound6(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isTerminalWorkflowStatus(status) {
@@ -7396,38 +8808,19 @@ function storedTaskAggregateDigest(snapshot) {
 }
 
 export {
-  isUlid,
-  assertUlid,
-  createUlid,
-  assertRecord,
-  assertKnownKeys,
   parseSchemaManifest,
   serializeSchemaManifest,
   managedAdapterNames,
-  parseSchemaManifestV2,
   assertSchemaManifestTransition,
+  assertSchemaManifestPrivacyTransition,
   assertSchemaManifestPolicyUpgrade,
   assertActivationRollbackManifestTransition,
   managedAdapterInventoriesMatch,
-  formatTaskRef,
-  parseTaskRef,
-  parseTaskRefValue,
-  sameTaskRef,
-  resolveTaskEntityHomeStore,
-  resolveLocalEntityHomeStore,
-  resolveCoordinationEntityHomeStore,
-  operationDirectory,
-  lockDirectory,
-  claimDirectory,
-  handoffDirectory,
-  taskHeadDirectory,
   gitRefWorkflowRepairJournalPath,
   listGitRefWorkflowRepairJournalSummaries,
   listUnfinishedGitRefWorkflowRepairs,
-  canonicalizeJson,
-  digestCanonicalJson,
-  sortUtf8StringSet,
   scanSharedText,
+  redactSharedText,
   assertSharedTextSafe,
   assertSafeSharedRelativePath,
   parseCapabilityLevel,
@@ -7436,14 +8829,10 @@ export {
   parseAuthorizationBasis,
   assertRepairUsesOriginalAuthorization,
   parseOperationJournal,
-  assertOperationJournalTransition,
-  operationJournalDigest,
   operationReservationJournalDigest,
   assertOperationReservationTopology,
   withOperationReservationDigests,
   parseOperationReservation,
-  createOperationReservation,
-  writeOperationReservation,
   readOperationReservation,
   removeOperationReservation,
   parseCheckpoint,
@@ -7478,6 +8867,8 @@ export {
   workflowMetadataDigest,
   assertWorkflowMetadataTransition,
   assertParentWorkflowRelation,
+  isActiveSoloHandoff,
+  assertSoloHandoffSession,
   buildTaskAggregateManifest,
   taskAggregateDigest,
   parseTaskAggregateManifest,
@@ -7490,13 +8881,41 @@ export {
   normalizeClaimScope,
   parseHandoff,
   assertHandoffTransition,
-  parseProjectConfig,
-  parseTeamPolicy,
-  projectConfigIdentityDigest,
-  projectConfigDigest,
-  assertConfigPolicyConsistency,
-  assertProjectConfigTransition,
-  assertTeamPolicyTransition,
+  acquireLocalLock,
+  acquireEntityLocks,
+  acquireOperationEntityLocks,
+  readLocalLock,
+  replaceFileAtomically,
+  getOperationDefinition,
+  assertOperationJournalMatchesDefinition,
+  createPreparedOperationJournal,
+  prepareOperationStores,
+  readOperationJournal,
+  updateOperationJournal,
+  listUnfinishedOperationJournals,
+  PROJECT_SCHEMA_LOCK,
+  acquireProjectWriteBarrier,
+  PRIVACY_MIN_VERSION,
+  PRIVACY_POLICY_FILE,
+  PRIVACY_EXCLUSIONS_FILE,
+  parsePrivacyPolicyCandidate,
+  parsePrivacyPolicy,
+  parsePrivacyExclusions,
+  createInitialPrivacyPolicy,
+  assertPrivacyPolicyTransition,
+  assertPrivacyExclusionsTransition,
+  readPrivacyPolicySnapshot,
+  readPrivacyPolicyStatus,
+  readPrivacyAuthorityFile,
+  containsEnhancedSensitiveText,
+  isPrivacyExcluded,
+  assertPrivacyValueAllowed,
+  assertSharedPrivacyValue,
+  acquireSharedPrivacyWriteBarrier,
+  withSharedPrivacyWrite,
+  assertSharedTaskWriteAtRoot,
+  assertPrivacyRecoveryActionsAllowed,
+  scanPrivacyActivation,
   createConfirmedDecision,
   publishConfirmedDecision,
   readConfirmedDecision,
@@ -7511,4 +8930,4 @@ export {
   V3ContextStore,
   storedTaskAggregateDigest
 };
-//# sourceMappingURL=chunk-7HPP3KYG.js.map
+//# sourceMappingURL=chunk-D5ABGAF4.js.map