harnery 0.44.0 → 0.45.1

package/src/core/workflow/workspaces/local-git.ts

@@ -9,6 +9,7 @@ import {
 } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
+import { beginWorkflowRecovery, validateWorkflowRecoveryAuthorization } from "../recovery-audit.ts";
 import { acquireWorkflowResumeLease } from "../run-state.ts";
 import { WorkspaceAttestationError } from "./attestation-error.ts";
 import { cleanupWorkspace } from "./cleanup.ts";
@@ -53,7 +54,7 @@ import {
   type WorkspaceReclaimPreview,
   type WorkspaceReclaimResult,
 } from "./reclaim.ts";
-import { readWorkflowLiveness } from "./recovery.ts";
+import { hasActiveWorkflowEvidence, readWorkflowLiveness } from "./recovery.ts";
 import {
   appendWorkspaceEvent,
   fileSha256,
@@ -820,6 +821,7 @@ function reclaimPreview(
     run_id: binding.run_id,
     mode,
     liveness: readWorkflowLiveness(coordRoot, binding.run_id),
+    evidence_sha256: reclaimEvidenceDigest(coordRoot, binding),
     ownership: "unproven",
     dirty_paths: null,
     lease_holder: reclaimLeaseHolders(coordRoot, binding),
@@ -839,14 +841,45 @@ function reclaimPreview(
   return preview;
 }
 
-function assertReclaimLiveness(coordRoot: string, binding: WorkspaceBinding): void {
+function reclaimEvidenceDigest(coordRoot: string, binding: WorkspaceBinding): string {
+  const evidence = (name: string): string | null => {
+    try {
+      return readFileSync(join(coordRoot, ".harnery", "workflows", binding.run_id, name), "utf8");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+      throw error;
+    }
+  };
+  return stableDigest({
+    binding,
+    proof: evidence("proof.json"),
+    transcript: evidence("transcript.jsonl"),
+  });
+}
+
+function assertReclaimLiveness(
+  coordRoot: string,
+  binding: WorkspaceBinding,
+  recovery?: WorkspaceReclaimOptions["unknownLiveness"],
+): void {
   const liveness = readWorkflowLiveness(coordRoot, binding.run_id);
+  if (liveness === "active" || (recovery && hasActiveWorkflowEvidence(coordRoot, binding.run_id))) {
+    throw new WorkflowReclaimError(
+      "workflow_reclaim_run_live",
+      `run ${binding.run_id} has active evidence; its workspace was left untouched`,
+    );
+  }
+  if (recovery && reclaimEvidenceDigest(coordRoot, binding) !== recovery.evidenceSha256) {
+    throw new WorkflowReclaimError(
+      "workflow_reclaim_recovery_mismatch",
+      "workflow reclaim requires the exact current preview evidence digest",
+    );
+  }
   if (liveness === "inactive") return;
+  if (liveness === "unknown" && recovery) return;
   throw new WorkflowReclaimError(
-    liveness === "active" ? "workflow_reclaim_run_live" : "workflow_reclaim_liveness_unknown",
-    liveness === "active"
-      ? `run ${binding.run_id} is active; its workspace was left untouched`
-      : `run ${binding.run_id} has missing, corrupt, or ambiguous liveness evidence; its workspace was left untouched`,
+    "workflow_reclaim_liveness_unknown",
+    `run ${binding.run_id} has missing, corrupt, or ambiguous liveness evidence; its workspace was left untouched`,
   );
 }
 
@@ -892,10 +925,11 @@ function reclaimAuthorityGuard(
   binding: WorkspaceBinding,
   claim: WorkspaceClaim,
   reservation: WorkspaceReclaimReservation,
+  recovery?: WorkspaceReclaimOptions["unknownLiveness"],
 ): void {
   try {
     reservation.assertCurrent();
-    assertReclaimLiveness(coordRoot, binding);
+    assertReclaimLiveness(coordRoot, binding, recovery);
     assertReclaimOwnership(coordRoot, binding);
     assertPeerWorkspaceAuthority(coordRoot, claim);
   } catch (error) {
@@ -914,10 +948,11 @@ async function reclaim(
     throw new Error("unsupported workspace reclaim mode");
   }
   if (!options.yes) return reclaimPreview(coordRoot, binding, options.mode);
+  if (options.unknownLiveness) validateWorkflowRecoveryAuthorization(options.unknownLiveness);
 
   // Liveness comes before terminal-proof cleanup helpers. A live run may not
   // have a proof yet, and a missing proof must never be discovered after reset.
-  assertReclaimLiveness(coordRoot, binding);
+  assertReclaimLiveness(coordRoot, binding, options.unknownLiveness);
   const claim = assertReclaimOwnership(coordRoot, binding);
   let reservation: WorkspaceReclaimReservation;
   try {
@@ -926,7 +961,7 @@ async function reclaim(
     throw new WorkflowReclaimError("workflow_reclaim_lease_held", (error as Error).message);
   }
   try {
-    reclaimAuthorityGuard(coordRoot, binding, claim, reservation);
+    reclaimAuthorityGuard(coordRoot, binding, claim, reservation, options.unknownLiveness);
     let releaseResume: () => void;
     try {
       releaseResume = acquireWorkflowResumeLease(coordRoot, binding.run_id);
@@ -953,9 +988,24 @@ async function reclaim(
           throw new WorkflowReclaimError("workflow_reclaim_lease_held", (error as Error).message);
         }
         try {
-          assertReclaimLiveness(coordRoot, binding);
+          assertReclaimLiveness(coordRoot, binding, options.unknownLiveness);
           assertReclaimOwnership(coordRoot, binding);
           const preview = reclaimPreview(coordRoot, binding, options.mode);
+          const audit = options.unknownLiveness
+            ? beginWorkflowRecovery(coordRoot, {
+                run_id: binding.run_id,
+                action: "reclaim_unknown_liveness",
+                actor: options.unknownLiveness.actor,
+                reason: options.unknownLiveness.reason,
+                target_sha256: options.unknownLiveness.evidenceSha256,
+                target: {
+                  binding_id: binding.binding_id,
+                  workspace_root: binding.workspace_root,
+                  mode: options.mode,
+                  liveness: preview.liveness,
+                },
+              })
+            : undefined;
           let preparation: ReclaimPreparation | undefined;
           // Keep ordinary cleanup's terminal-evidence checks, intent and receipts.
           // Its provider callback uses the leases already held here instead of
@@ -967,12 +1017,28 @@ async function reclaim(
             provider: {
               ...provider,
               cleanup: async (candidate, intent) => {
-                assertReclaimLiveness(coordRoot, candidate);
+                assertReclaimLiveness(coordRoot, candidate, options.unknownLiveness);
                 assertReclaimOwnership(coordRoot, candidate);
                 return cleanupUnderLease(coordRoot, candidate, claim, intent, {
                   mode: options.mode,
-                  beforeEffect: () =>
-                    reclaimAuthorityGuard(coordRoot, candidate, claim, reservation),
+                  recovery: options.unknownLiveness,
+                  beforeEffect: () => {
+                    audit?.assertCurrent();
+                    reclaimAuthorityGuard(
+                      coordRoot,
+                      candidate,
+                      claim,
+                      reservation,
+                      options.unknownLiveness,
+                    );
+                  },
+                  beforeRefEffect: () => {
+                    audit?.assertCurrent();
+                    reservation.assertCurrent();
+                    assertReclaimLiveness(coordRoot, candidate, options.unknownLiveness);
+                    requiredClaim(coordRoot, candidate);
+                    assertPeerWorkspaceAuthority(coordRoot, claim);
+                  },
                   prepared: (value) => {
                     preparation = value;
                   },
@@ -991,6 +1057,8 @@ async function reclaim(
                 "workspace cleanup preconditions could not be proved",
             );
           }
+          if (cleanupResult.status === "released" || cleanupResult.status === "already_released")
+            audit?.complete();
           return {
             ...preview,
             action: "reclaimed",
@@ -1104,7 +1172,9 @@ function cleanupUnderLease(
   intent: WorkspaceCleanupIntent,
   reclaimRequest?: {
     mode: ReclaimMode;
+    recovery?: WorkspaceReclaimOptions["unknownLiveness"];
     beforeEffect: () => void;
+    beforeRefEffect: () => void;
     prepared: (value: ReclaimPreparation) => void;
   },
   beforeRemoval?: () => void,
@@ -1152,7 +1222,7 @@ function cleanupUnderLease(
     };
   }
   const liveness = readWorkflowLiveness(coordRoot, binding.run_id);
-  if (liveness !== "inactive") {
+  if (liveness !== "inactive" && !(liveness === "unknown" && reclaimRequest?.recovery)) {
     return {
       ...base,
       status: "blocked",
@@ -1245,7 +1315,7 @@ function cleanupUnderLease(
   }
 
   if (reclaimRequest) {
-    assertReclaimLiveness(coordRoot, binding);
+    assertReclaimLiveness(coordRoot, binding, reclaimRequest.recovery);
     assertReclaimOwnership(coordRoot, binding);
     revalidateClaimResources(claim, root);
     reclaimRequest.prepared(
@@ -1293,6 +1363,7 @@ function cleanupUnderLease(
       return { ...base, status: "blocked", reason: "workspace ref changed during cleanup" };
     }
     revalidateClaimResources(claim, root);
+    reclaimRequest?.beforeRefEffect();
     const deleted = gitMaybe(repository.source_root.realpath, [
       "update-ref",
       "-d",

package/src/core/workflow/workspaces/reclaim.ts

@@ -16,6 +16,7 @@
  */
 
 import { existsSync } from "node:fs";
+import type { WorkflowRecoveryAuthorization } from "../recovery-audit.ts";
 import { git, gitMaybe } from "./git.ts";
 import type { WorkflowLiveness } from "./recovery.ts";
 import type { WorkspaceCleanupAttempt, WorkspaceCleanupReceipt } from "./types.ts";
@@ -25,6 +26,7 @@ export type ReclaimMode = "salvage" | "discard";
 export type WorkflowReclaimRefusalCode =
   | "workflow_reclaim_run_live"
   | "workflow_reclaim_liveness_unknown"
+  | "workflow_reclaim_recovery_mismatch"
   | "workflow_reclaim_ownership_unproven"
   | "workflow_reclaim_lease_held";
 
@@ -41,6 +43,7 @@ export class WorkflowReclaimError extends Error {
 export interface WorkspaceReclaimOptions {
   mode: ReclaimMode;
   yes?: boolean;
+  unknownLiveness?: WorkflowRecoveryAuthorization & { evidenceSha256: string };
 }
 
 export interface ReclaimLeaseHolder {
@@ -56,6 +59,7 @@ export interface WorkspaceReclaimPreview {
   run_id: string;
   mode: ReclaimMode;
   liveness: WorkflowLiveness;
+  evidence_sha256: string;
   ownership: "ok" | "unproven";
   ownership_detail?: string;
   dirty_paths: string[] | null;

package/src/core/workflow/workspaces/recovery.ts

@@ -4,6 +4,29 @@ import { readWorkflowProof } from "../proof.ts";
 
 export type WorkflowLiveness = "active" | "inactive" | "unknown";
 
+/** Corruption must not hide a readable active marker from an audited override. */
+export function hasActiveWorkflowEvidence(coordRoot: string, runId: string): boolean {
+  const path = join(resolve(coordRoot), ".harnery", "workflows", runId, "transcript.jsonl");
+  if (!existsSync(path)) return false;
+  let active = false;
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    try {
+      const event = JSON.parse(line);
+      if (event?.run_id !== runId) continue;
+      if (["run.start", "run.resume", "agent.start"].includes(event.event)) active = true;
+      if (
+        event.event === "run.parked" ||
+        (event.event === "run.end" && typeof event.ok === "boolean") ||
+        (event.event === "workspace.reattach.failed" && ["blocked", "lost"].includes(event.status))
+      )
+        active = false;
+    } catch {
+      /* Unreadable evidence cannot establish inactivity. */
+    }
+  }
+  return active;
+}
+
 export function readWorkflowLiveness(coordRoot: string, runId: string): WorkflowLiveness {
   const root = resolve(coordRoot);
   const transcriptPath = join(root, ".harnery", "workflows", runId, "transcript.jsonl");

package/src/lib/identities/assume.ts

@@ -140,7 +140,6 @@ export function reclaimAbandonedLocalConflict(
   let sessionId = conflict.instance_id;
   let ageSecs: number | undefined;
   const liveRow = readLiveCoordinationRow(coordRoot, conflict.instance_id);
-  let expectedGenerationId = liveRow?.v3_generation_id ?? null;
   if (liveRow) {
     adapter = adapterOf(liveRow.platform);
     sessionId = liveRow.session_id || conflict.instance_id;
@@ -154,9 +153,7 @@ export function reclaimAbandonedLocalConflict(
       // It is required to join the exact producer state when recording the sweep.
       adapter = adapterOf(hb.platform);
       sessionId = hb.session_id || conflict.instance_id;
-      expectedGenerationId = hb.v3_generation_id ?? null;
     } catch {
-      expectedGenerationId = null;
       /* content unreadable — still reclaim the file */
     }
     try {
@@ -171,7 +168,6 @@ export function reclaimAbandonedLocalConflict(
     owner: conflict.instance_id,
     nativeSessionId: sessionId,
     adapter,
-    expectedGenerationId,
     observation: "stale_heartbeat",
     ageMs: Math.max(0, (ageSecs ?? 0) * 1_000),
   });

package/dist/core/agents/state/unchanged-file.d.ts

@@ -1,44 +0,0 @@
-export interface FileRevision {
-    readonly bytes: Buffer;
-    readonly dev: bigint;
-    readonly ino: bigint;
-    readonly size: bigint;
-    readonly mtimeNs: bigint;
-    readonly ctimeNs: bigint;
-}
-export type DeleteFileResult = {
-    state: "deleted" | "changed" | "missing" | "rejected";
-} | {
-    state: "recovery-required";
-    recoveryPath: string;
-    error?: string;
-} | {
-    state: "error";
-    recoveryPath?: string;
-    error: string;
-};
-export interface FileRecoveryResult {
-    state: "restored" | "retained" | "error";
-    recoveryPath: string;
-    sourcePath?: string;
-    error?: string;
-}
-/** A stable read of one regular file, including its exact bytes and revision. */
-export declare function captureFileRevision(filePath: string): FileRevision | null;
-export declare function fileRevisionMatches(filePath: string, expected: FileRevision): boolean;
-/**
- * Writers must publish by atomic rename, never by an open descriptor to the old
- * inode. The private directory is outside their publication namespace. Moving
- * the row gives deletion custody over that inode without owning its live name.
- * The caller owns the state parent and keeps its topology stable. Its platform
- * permissions define which principals can modify it; this protocol does not
- * exclude principals already authorized to change that parent.
- */
-export declare function deleteFileIfUnchanged(filePath: string, expected: FileRevision, validate: (pinned: FileRevision) => boolean): DeleteFileResult;
-/**
- * Recover same-host/platform/PID-namespace pins after process termination. File fsync
- * protects manifest contents; directory entries are not fsynced, so this does
- * not promise recovery after an OS crash or power loss.
- */
-export declare function recoverInterruptedFileDeletions(directoryPath: string, validate: (sourcePath: string) => boolean): FileRecoveryResult[];
-//# sourceMappingURL=unchanged-file.d.ts.map

package/dist/core/agents/state/unchanged-file.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unchanged-file.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/state/unchanged-file.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAA;CAAE,GACzD;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;IACzC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAsED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAoCzE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAGrF;AAsGD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,OAAO,GAC1C,gBAAgB,CAmFlB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,GACxC,kBAAkB,EAAE,CA+FtB"}