mancode 0.6.5 → 0.6.6

package/dist/{chunk-E2K22WYH.js → chunk-D5ABGAF4.js}

@@ -26,7 +26,7 @@ import {
 } from "./chunk-IRZQYMHD.js";
 
 // src/context/store.ts
-import { lstat as lstat6, readFile as readFile10, readdir as readdir7 } from "fs/promises";
+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
@@ -216,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) {
@@ -4156,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;
@@ -4280,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");
   }
@@ -4287,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(
@@ -4320,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) {
@@ -5292,17 +5359,25 @@ function allowedHandoffTransitions(from) {
 }
 
 // src/context/confirmed-decision.ts
-import { lstat as lstat4, mkdir as mkdir4, readFile as readFile6, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
+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 lstat3, readdir as readdir4 } from "fs/promises";
+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 } from "crypto";
-import { mkdir as mkdir2, readFile as readFile3, rename, rm, writeFile as writeFile2 } from "fs/promises";
+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;
@@ -5310,32 +5385,27 @@ var MINIMUM_LOCK_LEASE_MS = 1e3;
 var MAXIMUM_LOCK_LEASE_MS = 5 * 6e4;
 async function acquireLocalLock(store, input) {
   const owner = createLockOwner(store, input);
-  const directory = lockPath(store, owner.entityLockKey);
+  const target = lockPath(store, owner.entityLockKey);
   await mkdir2(lockDirectory(store), { recursive: true });
-  let acquiredDirectory = false;
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      await mkdir2(directory);
-      acquiredDirectory = true;
-      break;
-    } catch (error) {
-      if (!isAlreadyExists2(error)) throw error;
-      if (!await reclaimExpiredDeadLock(store, owner.entityLockKey, owner)) {
-        throw new Error("MANCODE_LOCK_HELD");
+  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 (!acquiredDirectory) throw new Error("MANCODE_LOCK_HELD");
-  try {
-    await writeFile2(
-      path4.join(directory, "owner.json"),
-      `${JSON.stringify(owner, null, 2)}
-`,
-      { encoding: "utf8", flag: "wx" }
-    );
-  } catch (error) {
-    await rm(directory, { recursive: true, force: true });
-    throw error;
+    if (!acquired) throw new Error("MANCODE_LOCK_HELD");
+  } finally {
+    await rm(temporary, { force: true }).catch(() => void 0);
   }
   let released = false;
   let currentOwner = owner;
@@ -5352,7 +5422,7 @@ async function acquireLocalLock(store, input) {
       if (!sameLockOwner(current, currentOwner)) {
         throw new Error("MANCODE_LOCK_OWNERSHIP_LOST");
       }
-      await atomicWriteLockOwner(directory, next);
+      await atomicWriteLockOwner(target, next);
       currentOwner = next;
     },
     async release() {
@@ -5361,7 +5431,7 @@ async function acquireLocalLock(store, input) {
       if (!sameLockOwner(current, currentOwner)) {
         throw new Error("MANCODE_LOCK_OWNERSHIP_LOST");
       }
-      await rm(directory, { recursive: true, force: false });
+      await rm(target, { recursive: true, force: false });
       released = true;
     }
   };
@@ -5432,15 +5502,30 @@ async function acquireOperationEntityLocks(operationId, targets, options = {}) {
 async function readLocalLock(store, entityLockKey) {
   assertEntityLockKey(entityLockKey);
   try {
-    const raw = await readFile3(
-      path4.join(lockPath(store, entityLockKey), "owner.json"),
-      "utf8"
-    );
-    const owner = parseLocalLockOwner(JSON.parse(raw));
-    if (owner.storeId !== store.storeId || owner.entityLockKey !== entityLockKey) {
-      throw new Error("MANCODE_LOCK_CORRUPT");
+    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;
     }
-    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");
@@ -5548,18 +5633,24 @@ function processIsAlive(processId) {
     return !(typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH");
   }
 }
-async function atomicWriteLockOwner(directory, owner) {
-  const target = path4.join(directory, "owner.json");
-  const temporary = path4.join(
-    directory,
-    `.owner.${process.pid}.${Date.now()}.tmp`
-  );
-  await writeFile2(temporary, `${JSON.stringify(owner, null, 2)}
+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"
   });
-  await rename(temporary, target);
 }
 function parseLeaseMs(value) {
   if (value === void 0) return DEFAULT_LOCK_LEASE_MS;
@@ -6585,7 +6676,7 @@ async function acquireProjectWriteBarrier(runtime, operationId, now) {
 }
 
 // src/context/privacy-policy.ts
-import { lstat as lstat2, readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { lstat as lstat3, readFile as readFile5, readdir as readdir3 } from "fs/promises";
 import path6 from "path";
 
 // src/context/manifest.ts
@@ -7073,7 +7164,7 @@ async function assertNoPendingPrivacyPolicyOperation(root) {
   let entries;
   try {
     const directory = path6.join(root, ".mancode", relative);
-    const stat2 = await lstat2(directory);
+    const stat2 = await lstat3(directory);
     if (!stat2.isDirectory() || stat2.isSymbolicLink())
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     entries = await readdir3(directory);
@@ -7122,12 +7213,12 @@ async function readPrivacyPolicyStatus(root) {
 async function readPrivacyAuthorityFile(root, relative) {
   let current = path6.join(path6.resolve(root), ".mancode");
   for (const part of relative.split("/")) {
-    const parent = await lstat2(current);
+    const parent = await lstat3(current);
     if (!parent.isDirectory() || parent.isSymbolicLink())
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     current = path6.join(current, part);
   }
-  const stat2 = await lstat2(current);
+  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");
@@ -7283,7 +7374,7 @@ function assertPrivacyRecoveryActionsAllowed(snapshot, actions) {
 }
 async function hasProjectAuthority(root) {
   try {
-    const stat2 = await lstat3(path7.join(root, ".mancode", "schema.json"));
+    const stat2 = await lstat4(path7.join(root, ".mancode", "schema.json"));
     if (!stat2.isFile() || stat2.isSymbolicLink())
       throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
     return true;
@@ -7291,7 +7382,7 @@ async function hasProjectAuthority(root) {
     if (error === null || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT")
       throw error;
     try {
-      await lstat3(path7.join(root, ".mancode", "shared", "config.json"));
+      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;
@@ -7351,7 +7442,7 @@ async function scanPrivacyActivation(root, ruleIds) {
 }
 async function collectSharedFiles(root, relative) {
   const target = path7.join(root, ".mancode", relative);
-  const stat2 = await lstat3(target);
+  const stat2 = await lstat4(target);
   if (!stat2.isDirectory() || stat2.isSymbolicLink())
     throw new Error("MANCODE_ARTIFACT_PATH_UNSAFE");
   const files = [];
@@ -7579,7 +7670,7 @@ async function ensureSafeDirectory(projectRoot, directory) {
   }
 }
 async function assertSafeDirectory(directory) {
-  const stat2 = await lstat4(directory);
+  const stat2 = await lstat5(directory);
   if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
@@ -7587,13 +7678,13 @@ async function assertSafeDirectory(directory) {
 async function readSafeText(directory, filename) {
   await assertSafeDirectory(directory);
   const target = path8.join(directory, filename);
-  const before = await lstat4(target);
+  const before = await lstat5(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
   const content = await readFile6(target, "utf8");
   await assertSafeDirectory(directory);
-  const after = await lstat4(target);
+  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");
   }
@@ -8151,7 +8242,7 @@ function parseUlidOrNull9(value, label) {
 }
 
 // src/context/task-locator.ts
-import { lstat as lstat5, readFile as readFile9, realpath } from "fs/promises";
+import { lstat as lstat6, readFile as readFile9, realpath } from "fs/promises";
 import path11 from "path";
 async function locateTask(projectRoot, requested) {
   const root = path11.resolve(projectRoot);
@@ -8198,7 +8289,7 @@ async function locateExplicitTask(projectRoot, taskRef) {
 }
 async function isDirectoryWithoutSymlink(target) {
   try {
-    const entry = await lstat5(target);
+    const entry = await lstat6(target);
     return entry.isDirectory() && !entry.isSymbolicLink();
   } catch {
     return false;
@@ -8652,7 +8743,7 @@ async function readTextWithin(root, relativePath) {
     await assertSafeDirectoryAt(current);
   }
   const target = path12.join(absoluteRoot, ...segments);
-  const before = await lstat6(target);
+  const before = await lstat7(target);
   if (!before.isFile() || before.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
@@ -8661,7 +8752,7 @@ async function readTextWithin(root, relativePath) {
     absoluteRoot,
     parentSegments.length === 0 ? "." : path12.join(...parentSegments)
   );
-  const after = await lstat6(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");
   }
@@ -8688,7 +8779,7 @@ async function assertSafeDirectoryWithin(root, relativeDirectory) {
   return current;
 }
 async function assertSafeDirectoryAt(target) {
-  const stat2 = await lstat6(target);
+  const stat2 = await lstat7(target);
   if (!stat2.isDirectory() || stat2.isSymbolicLink()) {
     throw new Error("MANCODE_CONTEXT_PATH_UNSAFE");
   }
@@ -8729,6 +8820,7 @@ export {
   listGitRefWorkflowRepairJournalSummaries,
   listUnfinishedGitRefWorkflowRepairs,
   scanSharedText,
+  redactSharedText,
   assertSharedTextSafe,
   assertSafeSharedRelativePath,
   parseCapabilityLevel,
@@ -8775,6 +8867,8 @@ export {
   workflowMetadataDigest,
   assertWorkflowMetadataTransition,
   assertParentWorkflowRelation,
+  isActiveSoloHandoff,
+  assertSoloHandoffSession,
   buildTaskAggregateManifest,
   taskAggregateDigest,
   parseTaskAggregateManifest,
@@ -8836,4 +8930,4 @@ export {
   V3ContextStore,
   storedTaskAggregateDigest
 };
-//# sourceMappingURL=chunk-E2K22WYH.js.map
+//# sourceMappingURL=chunk-D5ABGAF4.js.map