harnery 0.33.0 → 0.34.0

package/dist/core/agents/rules/claim-conflict.js

@@ -8,15 +8,16 @@
  *      the peer's name in the reason.
  *   2. Ordering: if we already hold a claim on path A and want path
  *      B, B must sort > A lexicographically. Otherwise emit
- *      claim.conflict (ordering_violation) and block.
+ *      claim.authority_conflict (ordering_violation) and block.
  *
- * Reads from `.harnery/active/<id>.json`, the single canonical heartbeat
- * location after Phase 8 collapsed the v1/v2 dual-write.
+ * Reads the authority-safe V3 coordination projection. Disposable heartbeat
+ * caches are materialization targets, never the source of claim authority.
  */
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { emit } from "../events/emit.js";
+import { recordLiveClaimChangeV3 } from "../live-authority-v3.js";
+import { readLiveCoordinationRows } from "../state/live-coordination-view.js";
 const FRESHNESS_SECS = 600;
 /**
  * Evaluate a file-claim. Returns deny when another fresh peer claims the
@@ -45,14 +46,16 @@ export function evaluateClaim(coordRoot, req) {
         // prune the claim from their heartbeat and allow the edit. Skips when the
         // file doesn't exist (intent-to-create claim); that surface IS load-bearing.
         if (isFileCommittedClean(coordRoot, req.path)) {
-            pruneClaimFromPeer(coordRoot, conflict.instance_id, req.path);
+            if (!releaseClaimThroughLedger(coordRoot, conflict.instance_id, req.path, req)) {
+                return authorityUnavailable(req.path, "release the stale claim on");
+            }
             // Fall through to ordering check + allow.
         }
         else {
             return {
                 allow: false,
                 exit_code: 2,
-                rule: "claim.conflict",
+                rule: "claim.authority_conflict",
                 reason: `File ${req.path} is currently being edited by agent-${conflict.name ?? conflict.instance_id.slice(0, 8)}. Wait for them to finish or pick a different file. Set HARNERY_AGENT_COORD_OFF=1 to bypass (not recommended).`,
             };
         }
@@ -104,93 +107,37 @@ export function evaluateClaim(coordRoot, req) {
             }
             // Every blocker is a finished (committed-clean) edit: prune them so they
             // stop constraining future acquisitions, then fall through to allow.
-            for (const p of blockers)
-                pruneClaimFromPeer(coordRoot, req.instance_id, p);
+            for (const p of blockers) {
+                if (!releaseClaimThroughLedger(coordRoot, req.instance_id, p, req)) {
+                    return authorityUnavailable(p, "release the completed claim on");
+                }
+            }
         }
     }
     // Acquire the claim: atomic check-and-set. Adds req.path to my
     // files_touched if not already present.
     if (req.mode !== "read") {
-        addClaimToOwner(coordRoot, req.instance_id, req.path);
-    }
-    return { allow: true, exit_code: 0, rule: "claim.pass" };
-}
-/**
- * Add `relPath` to the owner's heartbeat `files_touched` array (idempotent;
- * no-op if already present). Atomic temp + rename. If the owner has no
- * heartbeat yet (subagent that hasn't been initialized), creates a minimal one.
- */
-function addClaimToOwner(coordRoot, instanceId, relPath) {
-    const activeDir = join(coordRoot, ".harnery", "active");
-    if (!existsSync(activeDir))
-        return;
-    const path = join(activeDir, `${instanceId}.json`);
-    if (!existsSync(path)) {
-        const now = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
-        const minimal = {
-            schema_version: 1,
-            instance_id: instanceId,
-            session_id: instanceId,
-            files_touched: [relPath],
-            started_at: now,
-            last_heartbeat: now,
-        };
-        try {
-            const tmp = `${path}.tmp.${process.pid}`;
-            writeFileSync(tmp, JSON.stringify(minimal, null, 2), "utf8");
-            renameSync(tmp, path);
-        }
-        catch {
-            /* silent */
+        if (!acquireClaimThroughLedger(coordRoot, req)) {
+            return authorityUnavailable(req.path, "acquire");
         }
-        return;
-    }
-    try {
-        const body = JSON.parse(readFileSync(path, "utf8"));
-        const files = body.files_touched ?? [];
-        if (files.includes(relPath))
-            return;
-        body.files_touched = [...files, relPath];
-        const tmp = `${path}.tmp.${process.pid}`;
-        writeFileSync(tmp, JSON.stringify(body, null, 2), "utf8");
-        renameSync(tmp, path);
-    }
-    catch {
-        /* silent */
     }
+    return { allow: true, exit_code: 0, rule: "claim.pass" };
 }
 function readPeers(coordRoot) {
-    const out = [];
-    const path = join(coordRoot, ".harnery", "active");
-    if (!existsSync(path))
-        return out;
-    for (const f of readdirSync(path)) {
-        if (!f.endsWith(".json"))
-            continue;
-        try {
-            const hb = JSON.parse(readFileSync(join(path, f), "utf8"));
-            if (!hb.instance_id)
-                continue;
-            // Derive parent_instance_id: explicit field first, then infer from
-            // session_id-differs-from-instance_id (the subagent shape:
-            // instance_id is the agent_id, session_id is the parent session).
-            const inferredParent = hb.parent_instance_id ??
-                hb.parent_session_id ??
-                (hb.session_id && hb.session_id !== hb.instance_id ? hb.session_id : undefined);
-            out.push({
-                instance_id: hb.instance_id,
-                name: hb.name,
-                session_id: hb.session_id ?? hb.instance_id,
-                files_touched: hb.files_touched ?? [],
-                last_heartbeat: hb.last_heartbeat ?? "",
-                parent_instance_id: inferredParent,
-            });
-        }
-        catch {
-            /* skip */
-        }
-    }
-    return out;
+    return readLiveCoordinationRows(coordRoot).map((heartbeat) => {
+        // Session IDs are opaque fingerprints. Parentage is valid only when the
+        // V3 projection supplies an explicit parent instance.
+        const inferredParent = heartbeat.parent_instance_id;
+        return {
+            instance_id: heartbeat.instance_id,
+            name: heartbeat.name,
+            session_id: heartbeat.session_id,
+            files_touched: heartbeat.files_touched ?? [],
+            last_heartbeat: heartbeat.last_heartbeat ?? "",
+            platform: heartbeat.platform,
+            parent_instance_id: inferredParent,
+        };
+    });
 }
 /**
  * Compute the group root for `instanceId`. For a parent session it's instanceId
@@ -257,50 +204,55 @@ function isFileCommittedClean(coordRoot, relPath) {
         return false;
     }
 }
-/**
- * Remove a stale claim from a peer's heartbeat. Atomic temp + rename. Silent
- * on failure.
- */
-function pruneClaimFromPeer(coordRoot, instanceId, relPath) {
-    const path = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
-    if (!existsSync(path))
-        return;
+function acquireClaimThroughLedger(coordRoot, req) {
+    const owner = readPeers(coordRoot).find((peer) => peer.instance_id === req.instance_id);
     try {
-        const body = JSON.parse(readFileSync(path, "utf8"));
-        const files = body.files_touched ?? [];
-        // Normalize both sides: files_touched can hold absolute-under-coordRoot
-        // entries as well as canonical relative ones — an
-        // exact-string filter silently no-ops on the mixed-form case and the
-        // stale claim never heals.
-        const norm = (p) => p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
-        const target = norm(relPath);
-        const next = files.filter((p) => norm(p) !== target);
-        if (next.length === files.length)
-            return;
-        body.files_touched = next;
-        const tmp = `${path}.tmp.${process.pid}`;
-        writeFileSync(tmp, JSON.stringify(body, null, 2), "utf8");
-        renameSync(tmp, path);
-        // Durable subtraction: the projector rebuilds files_touched from the
-        // permanent Edit/Write events, so a file-only prune resurrects on the
-        // next replay. Soft-fail — the heartbeat write already landed.
-        try {
-            const platform = body.platform;
-            emit(coordRoot, {
-                event_type: "claim.release",
-                instance_id: instanceId,
-                session_id: body.session_id ?? instanceId,
-                adapter: platform === "cursor" ? "cursor" : platform === "codex" ? "codex" : "claude-code",
-                source: "agent-coord",
-                data: { path: target, reason: "heal" },
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            });
-        }
-        catch {
-            /* soft-fail */
-        }
+        recordLiveClaimChangeV3({
+            coordRoot,
+            owner: req.instance_id,
+            nativeSessionId: req.session_id ?? owner?.session_id ?? req.instance_id,
+            adapter: adapterFromPlatform(owner?.platform),
+            operation: "acquired",
+            path: req.path,
+            access: "write",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseClaimThroughLedger(coordRoot, subjectInstanceId, relPath, actor) {
+    const owner = readPeers(coordRoot).find((peer) => peer.instance_id === actor.instance_id);
+    try {
+        recordLiveClaimChangeV3({
+            coordRoot,
+            owner: actor.instance_id,
+            subject: subjectInstanceId,
+            nativeSessionId: actor.session_id ?? owner?.session_id ?? actor.instance_id,
+            adapter: adapterFromPlatform(owner?.platform),
+            operation: "released",
+            path: relPath,
+            access: "write",
+        });
+        return true;
     }
     catch {
-        /* silent */
+        return false;
     }
 }
+function adapterFromPlatform(platform) {
+    if (platform === "cursor")
+        return "cursor";
+    if (platform === "codex")
+        return "codex";
+    return "claude-code";
+}
+function authorityUnavailable(path, operation) {
+    return {
+        allow: false,
+        exit_code: 2,
+        rule: "claim.authority_unavailable",
+        reason: `Cannot safely ${operation} ${path}; V3 authority is unavailable.`,
+    };
+}

package/dist/core/agents/rules/commit-conflict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commit-conflict.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/commit-conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAiBH,UAAU,QAAQ;IAChB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;wEACoE;IACpE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,mBAAmB,CAuHhG"}
+{"version":3,"file":"commit-conflict.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/commit-conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH,UAAU,QAAQ;IAChB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;wEACoE;IACpE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,mBAAmB,CAuHhG"}

package/dist/core/agents/rules/commit-conflict.js

@@ -20,10 +20,11 @@
  * in that set are matched with the staged-is-gitlink rule.
  */
 import { spawnSync } from "node:child_process";
-import { appendFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { appendFileSync, existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.js";
 import { resolveOwner } from "../../hooks/resolve/owner.js";
+import { readLiveCoordinationRows } from "../state/live-coordination-view.js";
 import { instanceHasLivePid } from "../state/pidmap.js";
 export function evaluateCommit(coordRoot, req) {
     // Resolve the committer here, not in the calling hook. The bash shims used
@@ -278,23 +279,7 @@ function isPathCleanInHead(coordRoot, relPath) {
     return gitProbe(["diff", "--quiet", "HEAD", "--", base], cwd).status === 0;
 }
 function readActivePeers(coordRoot) {
-    const dir = join(coordRoot, ".harnery", "active");
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    for (const f of readdirSync(dir)) {
-        if (!f.endsWith(".json"))
-            continue;
-        try {
-            const hb = JSON.parse(readFileSync(join(dir, f), "utf8"));
-            if (hb.instance_id)
-                out.push(hb);
-        }
-        catch {
-            /* skip */
-        }
-    }
-    return out;
+    return readLiveCoordinationRows(coordRoot);
 }
 function shortName(peer) {
     if (peer.name && peer.name.length > 0)

package/dist/core/agents/rules/stop-hook.d.ts

@@ -1,71 +1,30 @@
 /**
- * Stop-hook verdict: rule 1/3, 2/3, 3/3 enforcement evaluated
- * from the canonical event stream alone (no transcript scan).
+ * End-of-turn ritual verdict derived from the authoritative V3 event ledger.
  *
- * Codex is observe-only: its Stop continuation can replace the user-facing
- * answer in clients that retain only the final continuation response.
- *
- * Enforced adapters:
- * Rule 1/3: `state.status_checked` event with matching turn boundary exists.
- * Rule 2/3: latest `turn.stop` event has `status_box_present: true` (or the
- *            stop currently firing carries that field via the in-flight event
- *            agent-hook emits before the stop hook runs).
- * Rule 3/3: `state.task_set` event with matching turn boundary exists.
- * Session-naming rule (at most once per session, CC semantics only): the turn
- *            whose set-task produced `suggested_session_name` must carry an
- *            in-window `turn.stop` with `session_name_present: true`.
- *
- * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
- * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
- * as a user-visible mobile cue.
- *
- * Remediation continuity: an adapter whose Stop channel re-prompts by
- * submitting a new user message (Cursor's `followup_message`) opens a fresh
- * turn to repair the previous one. Such a turn inherits the window of the turn
- * it repairs, so ritual events accumulate instead of alternating. See
- * `resolveTurnStartMs`.
+ * V3 keeps prompt and reply bodies private. The hook producer records only the
+ * structural observations needed here: whether the reply showed the status box
+ * and current session name, and whether a prompt was emitted by Harnery's own
+ * Cursor remediation channel. Task and status evidence comes from the existing
+ * `coord.task_changed` and `coord.status_observed` events.
  */
+import type { EventV3 } from "../../events/v3/contract.js";
 export type { VerdictResult } from "./verdict.js";
 import type { VerdictResult } from "./verdict.js";
 export interface StopHookRequest {
     rule: "stop-hook";
     instance_id: string;
     session_id?: string;
-    /** Firing adapter. Selects the end-of-turn ack signal (see `ackSignalFor`).
-     * Undefined → Claude Code semantics (transcript-scanned status box). */
     adapter?: string;
-    /** Wall-clock cutoff for the current turn; events strictly after this are not yet relevant. */
     now_ms?: number;
-    /** Override the turn-window discovery (used by tests). */
     turn_window?: {
         start_ms: number;
         end_ms: number;
     };
-    /** Bypass switch: operator escape hatch identical to HARNERY_AGENT_COORD_BYPASS_STOP. */
     bypass?: boolean;
-    /** Headless child spawned by `harn workflow` (HARNERY_WORKFLOW_CHILD=1).
-     * The end-of-turn ritual exists to surface status to a HUMAN reader; a
-     * workflow child reports to the engine's transcript instead, so the ritual is
-     * meaningless there — worse, blocking burns the child's turn budget on
-     * re-prompts (observed as error_max_turns in the Phase 1 spike). Exempting
-     * here, rather than disabling the child's hooks wholesale, keeps heartbeat +
-     * event capture on: the child stays visible to peers and the coord layer. */
     workflow_child?: boolean;
 }
-/**
- * Machine marker that opens a Stop-remediation message. Written by
- * `hooks/adapter/output.ts` on the adapters whose Stop channel is a new user
- * message, and read back here off `user_prompt.submit.data.prompt_text` to
- * recognize a turn Harnery itself opened.
- *
- * Leading position is deliberate: `prompt_text` is clamped when recorded, so a
- * trailing marker could be truncated away on a long reason.
- */
 export declare const STOP_REMEDIATION_MARKER = "[harnery:stop-remediation";
-/**
- * Evaluate the Stop-hook verdict. Returns the first failing rule (or allow
- * when all three pass). Soft-fails open when the event stream isn't
- * readable, fail-open posture on a verdict failure.
- */
 export declare function evaluateStopHook(coordRoot: string, req: StopHookRequest): VerdictResult;
+/** Pure V3 evaluator used by replay and regression tests after authority checks. */
+export declare function evaluateStopHookV3Events(coordRoot: string, req: StopHookRequest, events: readonly EventV3[]): VerdictResult;
 //# sourceMappingURL=stop-hook.d.ts.map

package/dist/core/agents/rules/stop-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;iFAM6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+BD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AA4DnE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CA8JvF"}
+{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAM3D,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AAInE,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CA6BvF;AAED,oFAAoF;AACpF,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,aAAa,CA2Gf"}