@webpieces/rules-config 0.4.709 → 0.4.710

package/src/worktree-lock-verdicts.d.ts

@@ -1,46 +1,149 @@
 import { AgentWorktreeLock, AgentWorktreeLockReader } from './agent-worktree-lock';
+import { AgentActivity, HarnessAgentActivityReader } from './harness-agent-activity';
 import { DeletableWorktree } from './merged-branch-verdicts';
-import { Worktree } from './worktrees';
+import { Worktree, WorktreeService } from './worktrees';
 /**
  * What a `git worktree lock` DOES to a worktree's cleanup verdict.
  *
- * Separate from agent-worktree-lock.ts, which only reads a lock reason and asks the kernel about a
- * pid: this is the policy built on top of that evidence — which locks stop a reap, what a spared lock
- * is allowed to claim about who took it, and what a stale one has to leave behind on the verdict so
- * the reaper knows a lock is standing in its way.
+ * Separate from agent-worktree-lock.ts (which only parses a lock reason) and from
+ * harness-agent-activity.ts (which only asks the harness about an agent): this is the POLICY built on
+ * top of that evidence — what stops a reap, what a spared lock is allowed to CLAIM about who took it,
+ * and what an overridden one has to leave on the verdict so the reaper knows to clear it.
+ *
+ * ─── WHY THE POLICY CHANGED ──────────────────────────────────────────────────────────────────────
+ * It used to be one question, asked of the kernel: is the pid in the lock reason still running? That
+ * pid is the Claude Code SESSION process, shared by every subagent, so the answer was yes for the
+ * whole life of a session and every agent worktree was spared forever — nine against a cap of five,
+ * with one agent running, each carrying the sentence "that agent is working in here" about agents
+ * whose PRs had already merged. Both halves were defects: the reap never happened, and the message
+ * asserted something nobody knew.
+ *
+ * ─── THE DECISION TABLE, AND THE ONE RULE BEHIND IT ──────────────────────────────────────────────
+ *
+ *      HARNESS STATE MAY ONLY VETO A REAP. IT MAY NEVER LICENSE ONE.
+ *
+ * The licence comes solely from the branch/commit evidence wp-cleanup already computes and already
+ * gets right. So, for a lock this repo can read as the harness's own:
+ *
+ *   branch evidence does NOT say deletable          → SPARE. The harness is not even consulted; it
+ *                                                     cannot promote a spare into a reap.
+ *   deletable, but the worktree is DIRTY            → SPARE, unconditionally. Uncommitted or
+ *                                                     untracked files are work no archive tag can
+ *                                                     bring back. This one overrides everything,
+ *                                                     including the explicit flag.
+ *   deletable, clean, harness says the agent is
+ *   mid-tool-call and writing                       → SPARE. The veto.
+ *   deletable, clean, harness says returned /
+ *   long-stale / cannot tell                        → judge it on its branch like any unlocked tree,
+ *                                                     clearing the lock on the way out.
+ *
+ * `--ignore-stale-locks` moves ONE line of that table: it lets a locked worktree whose branch is not
+ * provably dead be classified on its real branch and commit state anyway (so a zero-commit husk gets
+ * reaped and a worktree holding unique commits reaches the numbered block a human can answer). It
+ * does not touch the dirty rail or the live-agent veto, because neither of those is what the caller
+ * is complaining about when they pass it.
+ *
+ * ─── SCOPE: AGENT LOCKS ONLY ─────────────────────────────────────────────────────────────────────
+ * Every override applies ONLY to a lock this file can read as the harness's own. A lock reason naming
+ * anything else — a human's "dean is debugging", or nothing at all — is still an instruction from
+ * somebody, and wp-cleanup still obeys it.
+ */
+/**
+ * The exact phrase a spared "we cannot tell" verdict carries, exported so wp-cleanup can spot those
+ * worktrees and offer the flag that judges them on their branch instead.
+ *
+ * ONE spelling, shared: the alternative is the caller re-deriving the same condition from a second
+ * copy of the sentence, which is how a message and the code that keys off it drift apart.
+ */
+export declare const LOCK_LIVENESS_UNVERIFIABLE = "whether that agent is still running cannot be verified";
+/**
+ * The stand-in for "the harness was never asked", used on the paths where asking could not change the
+ * answer. It is UNKNOWN, so a caller that consults it anyway still fails safe.
+ */
+export declare const HARNESS_NOT_CONSULTED: AgentActivity;
+export declare class LockEvidence {
+    /** The lock reason verbatim, straight out of `git worktree list --porcelain`. */
+    lockReason: string;
+    /** What the harness says about the agent named in that reason, or HARNESS_NOT_CONSULTED. */
+    activity: AgentActivity;
+    /** Does `git status --porcelain` report anything, or could it not answer? Either way: held. */
+    workInFlight: boolean;
+    /** Why it is held, in git's terms — printed verbatim, because the two reasons differ for a human. */
+    workInFlightReason: string;
+    /** Is the branch this worktree holds ALREADY provably dead by the ordinary verdicts? */
+    branchDeletable: boolean;
+    /** The caller said to treat a standing agent lock as no evidence at all. */
+    ignoreStaleAgentLocks: boolean;
+    constructor(lockReason: string, activity: AgentActivity, workInFlight: boolean, workInFlightReason: string, branchDeletable: boolean, ignoreStaleAgentLocks: boolean);
+}
+/**
+ * Data-only. The one verdict this file produces: spare or override, the sentence that says WHY, and
+ * the agent lock the reaper will have to clear if the worktree goes.
+ *
+ * ONE class rather than a spare-path method and an override-path method, because the two answers are
+ * mutually exclusive readings of the same evidence, and two methods is how they drift apart — which
+ * is precisely what happened before: the old spared message and the old stale-lock test were computed
+ * from the same pid by different code, and only one of them was ever corrected.
  */
+export declare class LockDecision {
+    /** True: leave this worktree alone, and `reason` is the whole story. */
+    spare: boolean;
+    /** Spared: why it was left. Overridden: the clause appended to the branch's own verdict. */
+    reason: string;
+    /** The agent lock to clear on the way out — null when nothing may be cleared. */
+    lock: AgentWorktreeLock | null;
+    constructor(spare: boolean, reason: string, lock: AgentWorktreeLock | null);
+}
 export declare class WorktreeLockVerdicts {
     private readonly agentLocks;
-    constructor(agentLocks?: AgentWorktreeLockReader);
+    private readonly harness;
+    private readonly worktrees;
+    constructor(agentLocks?: AgentWorktreeLockReader, harness?: HarnessAgentActivityReader, worktrees?: WorktreeService);
     /**
-     * The lock on this worktree was taken by a Claude agent whose process is GONE — or null, meaning
-     * the lock is still standing for something and the worktree must be spared.
+     * Collect what `decide` rules on — and, just as deliberately, DECLINE to collect the two
+     * expensive facts when they cannot change the answer.
      *
-     * Null covers three genuinely different situations that all end the same way: a live agent, a
-     * reason we do not recognise, and no reason at all. `sparedReason` is what tells them apart for
-     * the reader; here they are one answer, "do not touch".
+     * `git status --porcelain` and a walk of the harness's state tree are gathered only when a reap
+     * is otherwise on the table: the lock is one this repo can read as the harness's own, and either
+     * the branch is already provably dead or the caller asked for locks to be ignored. That is not an
+     * optimisation dressed up as a rule — harness state may only VETO a reap, never license one, so on
+     * a path with no reap to veto there is nothing to ask, and asking would invite a later reader to
+     * let the answer decide something.
      */
-    staleAgentLock(tree: Worktree): AgentWorktreeLock | null;
+    gather(tree: Worktree, branchDeletable: boolean, ignoreStaleAgentLocks: boolean): LockEvidence;
     /**
-     * WHY a locked worktree was left alone — reporting what the lock SAYS, never who we imagine wrote
-     * it.
+     * Spare this locked worktree, or judge it on its branch like any unlocked one — with the sentence
+     * that says which piece of evidence decided it.
      *
-     * This used to read `locked by a human — do not touch` for every lock in existence, which was
-     * wrong twice over. It was factually wrong about the agent harness's own locks, which is what let
-     * every `/full-cycle` worktree pile up forever. And it named an actor nothing in the evidence
-     * identifies: the lock reason is the ONLY thing we have, a human may have locked it, so may some
-     * other tool, and asserting either is the same defect whichever way it lands.
+     * The order below IS the decision table in the class header, in the same order, for the same
+     * reasons. Read it there.
+     */
+    decide(evidence: LockEvidence): LockDecision;
+    /**
+     * WHY a locked worktree was left alone when the lock is NOT the harness's — reporting what the
+     * reason SAYS, never who we imagine wrote it.
+     *
+     * This used to read `locked by a human — do not touch` for every lock in existence, which named an
+     * actor nothing in the evidence identifies: the lock reason is the ONLY thing we have, a human may
+     * have locked it, so may some other tool, and asserting either is the same defect whichever way it
+     * lands.
+     */
+    private foreignLockReason;
+    /**
+     * The sentence that replaced "pid N still running — that agent is working in here".
      *
-     * So: name the agent and pid when the reason ASSERTS them, and otherwise quote the reason back
-     * verbatim and say plainly that we cannot tell who locked it.
+     * It says only what is known: which agent the reason names, that the pid in it cannot answer the
+     * question because it is the shared session process, and that nothing else made the worktree
+     * provably dead either. No claim about anybody working — and no claim about the harness, which on
+     * this path was deliberately never asked, because its answer could not have changed the outcome.
      */
-    sparedReason(tree: Worktree): string;
+    private unverifiableReason;
     /**
-     * Stamp a verdict with the stale lock on its worktree: the lock has to be CLEARED before git will
-     * remove the directory, and the reason has to say why a lock is being overridden at all.
+     * Stamp an overridden verdict with the lock the reap must CLEAR: git refuses to remove a locked
+     * worktree, and the reason has to say why a lock is being overridden at all.
      *
      * Applied to every verdict the fall-through can produce, not just the deletable one, because the
      * spared cases are exactly where a human reads the reason and asks "wasn't that locked?".
      */
-    annotate(verdict: DeletableWorktree, lock: AgentWorktreeLock | null): DeletableWorktree;
+    annotate(verdict: DeletableWorktree, decision: LockDecision | null): DeletableWorktree;
 }

package/src/worktree-lock-verdicts.js

@@ -1,80 +1,225 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorktreeLockVerdicts = void 0;
+exports.WorktreeLockVerdicts = exports.LockDecision = exports.LockEvidence = exports.HARNESS_NOT_CONSULTED = exports.LOCK_LIVENESS_UNVERIFIABLE = void 0;
 const tslib_1 = require("tslib");
 const inversify_1 = require("inversify");
 const agent_worktree_lock_1 = require("./agent-worktree-lock");
+const harness_agent_activity_1 = require("./harness-agent-activity");
+const worktrees_1 = require("./worktrees");
 /**
  * What a `git worktree lock` DOES to a worktree's cleanup verdict.
  *
- * Separate from agent-worktree-lock.ts, which only reads a lock reason and asks the kernel about a
- * pid: this is the policy built on top of that evidence — which locks stop a reap, what a spared lock
- * is allowed to claim about who took it, and what a stale one has to leave behind on the verdict so
- * the reaper knows a lock is standing in its way.
+ * Separate from agent-worktree-lock.ts (which only parses a lock reason) and from
+ * harness-agent-activity.ts (which only asks the harness about an agent): this is the POLICY built on
+ * top of that evidence — what stops a reap, what a spared lock is allowed to CLAIM about who took it,
+ * and what an overridden one has to leave on the verdict so the reaper knows to clear it.
+ *
+ * ─── WHY THE POLICY CHANGED ──────────────────────────────────────────────────────────────────────
+ * It used to be one question, asked of the kernel: is the pid in the lock reason still running? That
+ * pid is the Claude Code SESSION process, shared by every subagent, so the answer was yes for the
+ * whole life of a session and every agent worktree was spared forever — nine against a cap of five,
+ * with one agent running, each carrying the sentence "that agent is working in here" about agents
+ * whose PRs had already merged. Both halves were defects: the reap never happened, and the message
+ * asserted something nobody knew.
+ *
+ * ─── THE DECISION TABLE, AND THE ONE RULE BEHIND IT ──────────────────────────────────────────────
+ *
+ *      HARNESS STATE MAY ONLY VETO A REAP. IT MAY NEVER LICENSE ONE.
+ *
+ * The licence comes solely from the branch/commit evidence wp-cleanup already computes and already
+ * gets right. So, for a lock this repo can read as the harness's own:
+ *
+ *   branch evidence does NOT say deletable          → SPARE. The harness is not even consulted; it
+ *                                                     cannot promote a spare into a reap.
+ *   deletable, but the worktree is DIRTY            → SPARE, unconditionally. Uncommitted or
+ *                                                     untracked files are work no archive tag can
+ *                                                     bring back. This one overrides everything,
+ *                                                     including the explicit flag.
+ *   deletable, clean, harness says the agent is
+ *   mid-tool-call and writing                       → SPARE. The veto.
+ *   deletable, clean, harness says returned /
+ *   long-stale / cannot tell                        → judge it on its branch like any unlocked tree,
+ *                                                     clearing the lock on the way out.
+ *
+ * `--ignore-stale-locks` moves ONE line of that table: it lets a locked worktree whose branch is not
+ * provably dead be classified on its real branch and commit state anyway (so a zero-commit husk gets
+ * reaped and a worktree holding unique commits reaches the numbered block a human can answer). It
+ * does not touch the dirty rail or the live-agent veto, because neither of those is what the caller
+ * is complaining about when they pass it.
+ *
+ * ─── SCOPE: AGENT LOCKS ONLY ─────────────────────────────────────────────────────────────────────
+ * Every override applies ONLY to a lock this file can read as the harness's own. A lock reason naming
+ * anything else — a human's "dean is debugging", or nothing at all — is still an instruction from
+ * somebody, and wp-cleanup still obeys it.
  */
+/**
+ * The exact phrase a spared "we cannot tell" verdict carries, exported so wp-cleanup can spot those
+ * worktrees and offer the flag that judges them on their branch instead.
+ *
+ * ONE spelling, shared: the alternative is the caller re-deriving the same condition from a second
+ * copy of the sentence, which is how a message and the code that keys off it drift apart.
+ */
+exports.LOCK_LIVENESS_UNVERIFIABLE = 'whether that agent is still running cannot be verified';
+/**
+ * The stand-in for "the harness was never asked", used on the paths where asking could not change the
+ * answer. It is UNKNOWN, so a caller that consults it anyway still fails safe.
+ */
+exports.HARNESS_NOT_CONSULTED = new harness_agent_activity_1.AgentActivity(harness_agent_activity_1.AGENT_ACTIVITY_UNKNOWN, 'the harness was not consulted');
+// Data-only (per CLAUDE.md, classes for data). Everything `decide` rules on, as one value — see
+// `gather`, which is the only thing that builds one outside a test.
+class LockEvidence {
+    /** The lock reason verbatim, straight out of `git worktree list --porcelain`. */
+    lockReason;
+    /** What the harness says about the agent named in that reason, or HARNESS_NOT_CONSULTED. */
+    activity;
+    /** Does `git status --porcelain` report anything, or could it not answer? Either way: held. */
+    workInFlight;
+    /** Why it is held, in git's terms — printed verbatim, because the two reasons differ for a human. */
+    workInFlightReason;
+    /** Is the branch this worktree holds ALREADY provably dead by the ordinary verdicts? */
+    branchDeletable;
+    /** The caller said to treat a standing agent lock as no evidence at all. */
+    ignoreStaleAgentLocks;
+    constructor(lockReason, activity, workInFlight, workInFlightReason, branchDeletable, ignoreStaleAgentLocks) {
+        this.lockReason = lockReason;
+        this.activity = activity;
+        this.workInFlight = workInFlight;
+        this.workInFlightReason = workInFlightReason;
+        this.branchDeletable = branchDeletable;
+        this.ignoreStaleAgentLocks = ignoreStaleAgentLocks;
+    }
+}
+exports.LockEvidence = LockEvidence;
+/**
+ * Data-only. The one verdict this file produces: spare or override, the sentence that says WHY, and
+ * the agent lock the reaper will have to clear if the worktree goes.
+ *
+ * ONE class rather than a spare-path method and an override-path method, because the two answers are
+ * mutually exclusive readings of the same evidence, and two methods is how they drift apart — which
+ * is precisely what happened before: the old spared message and the old stale-lock test were computed
+ * from the same pid by different code, and only one of them was ever corrected.
+ */
+class LockDecision {
+    /** True: leave this worktree alone, and `reason` is the whole story. */
+    spare;
+    /** Spared: why it was left. Overridden: the clause appended to the branch's own verdict. */
+    reason;
+    /** The agent lock to clear on the way out — null when nothing may be cleared. */
+    lock;
+    constructor(spare, reason, lock) {
+        this.spare = spare;
+        this.reason = reason;
+        this.lock = lock;
+    }
+}
+exports.LockDecision = LockDecision;
 let WorktreeLockVerdicts = class WorktreeLockVerdicts {
     agentLocks;
-    constructor(agentLocks = new agent_worktree_lock_1.AgentWorktreeLockReader()) {
+    harness;
+    worktrees;
+    // Defaulted like BranchReaper's collaborators, so the non-DI call sites can just
+    // `new WorktreeLockVerdicts()` while inversify still injects the singletons from a container.
+    constructor(agentLocks = new agent_worktree_lock_1.AgentWorktreeLockReader(), harness = new harness_agent_activity_1.HarnessAgentActivityReader(), worktrees = new worktrees_1.WorktreeService()) {
         this.agentLocks = agentLocks;
+        this.harness = harness;
+        this.worktrees = worktrees;
     }
     /**
-     * The lock on this worktree was taken by a Claude agent whose process is GONE — or null, meaning
-     * the lock is still standing for something and the worktree must be spared.
+     * Collect what `decide` rules on — and, just as deliberately, DECLINE to collect the two
+     * expensive facts when they cannot change the answer.
      *
-     * Null covers three genuinely different situations that all end the same way: a live agent, a
-     * reason we do not recognise, and no reason at all. `sparedReason` is what tells them apart for
-     * the reader; here they are one answer, "do not touch".
+     * `git status --porcelain` and a walk of the harness's state tree are gathered only when a reap
+     * is otherwise on the table: the lock is one this repo can read as the harness's own, and either
+     * the branch is already provably dead or the caller asked for locks to be ignored. That is not an
+     * optimisation dressed up as a rule — harness state may only VETO a reap, never license one, so on
+     * a path with no reap to veto there is nothing to ask, and asking would invite a later reader to
+     * let the answer decide something.
      */
-    staleAgentLock(tree) {
+    gather(tree, branchDeletable, ignoreStaleAgentLocks) {
         const lock = this.agentLocks.parse(tree.lockReason);
-        if (lock === null)
-            return null;
-        return this.agentLocks.isRunning(lock) ? null : lock;
+        if (lock === null || (!branchDeletable && !ignoreStaleAgentLocks)) {
+            return new LockEvidence(tree.lockReason, exports.HARNESS_NOT_CONSULTED, false, '', branchDeletable, ignoreStaleAgentLocks);
+        }
+        const held = this.worktrees.workInFlight(tree.path);
+        return new LockEvidence(tree.lockReason, this.harness.activityOf(lock.agent, tree.path), held.held, held.reason, branchDeletable, ignoreStaleAgentLocks);
     }
     /**
-     * WHY a locked worktree was left alone — reporting what the lock SAYS, never who we imagine wrote
-     * it.
-     *
-     * This used to read `locked by a human — do not touch` for every lock in existence, which was
-     * wrong twice over. It was factually wrong about the agent harness's own locks, which is what let
-     * every `/full-cycle` worktree pile up forever. And it named an actor nothing in the evidence
-     * identifies: the lock reason is the ONLY thing we have, a human may have locked it, so may some
-     * other tool, and asserting either is the same defect whichever way it lands.
+     * Spare this locked worktree, or judge it on its branch like any unlocked one — with the sentence
+     * that says which piece of evidence decided it.
      *
-     * So: name the agent and pid when the reason ASSERTS them, and otherwise quote the reason back
-     * verbatim and say plainly that we cannot tell who locked it.
+     * The order below IS the decision table in the class header, in the same order, for the same
+     * reasons. Read it there.
      */
-    sparedReason(tree) {
-        const lock = this.agentLocks.parse(tree.lockReason);
-        if (lock !== null) {
-            return `locked by claude agent ${lock.agent}, pid ${String(lock.pid)} still running — `
-                + 'that agent is working in here';
+    decide(evidence) {
+        const lock = this.agentLocks.parse(evidence.lockReason);
+        if (lock === null)
+            return new LockDecision(true, this.foreignLockReason(evidence.lockReason), null);
+        if (!evidence.branchDeletable && !evidence.ignoreStaleAgentLocks) {
+            return new LockDecision(true, this.unverifiableReason(lock), null);
         }
-        if (tree.lockReason === '') {
+        if (evidence.workInFlight) {
+            return new LockDecision(true, `locked by claude agent ${lock.agent}, and the worktree ${evidence.workInFlightReason} — `
+                + 'nothing archives that, so it is left exactly where it is', null);
+        }
+        if (evidence.activity.state === harness_agent_activity_1.AGENT_ACTIVITY_LIVE) {
+            return new LockDecision(true, `locked by claude agent ${lock.agent}, and the Claude Code harness says `
+                + `${evidence.activity.detail} — that agent is working in here`, null);
+        }
+        if (evidence.branchDeletable) {
+            return new LockDecision(false, `the lock from claude agent ${lock.agent} did not stop this — the worktree is clean, its `
+                + `branch is already dead, and ${evidence.activity.detail}`, lock);
+        }
+        return new LockDecision(false, `the lock from claude agent ${lock.agent} was treated as no evidence, as asked`, lock);
+    }
+    /**
+     * WHY a locked worktree was left alone when the lock is NOT the harness's — reporting what the
+     * reason SAYS, never who we imagine wrote it.
+     *
+     * This used to read `locked by a human — do not touch` for every lock in existence, which named an
+     * actor nothing in the evidence identifies: the lock reason is the ONLY thing we have, a human may
+     * have locked it, so may some other tool, and asserting either is the same defect whichever way it
+     * lands.
+     */
+    foreignLockReason(lockReason) {
+        if (lockReason === '') {
             return 'locked with no reason recorded — nothing says who locked it or why, so it is left alone';
         }
-        return `locked, reason "${tree.lockReason}" — that is not a claude agent lock, so who locked it `
+        return `locked, reason "${lockReason}" — that is not a claude agent lock, so who locked it `
             + 'is unknown; left alone';
     }
     /**
-     * Stamp a verdict with the stale lock on its worktree: the lock has to be CLEARED before git will
-     * remove the directory, and the reason has to say why a lock is being overridden at all.
+     * The sentence that replaced "pid N still running — that agent is working in here".
+     *
+     * It says only what is known: which agent the reason names, that the pid in it cannot answer the
+     * question because it is the shared session process, and that nothing else made the worktree
+     * provably dead either. No claim about anybody working — and no claim about the harness, which on
+     * this path was deliberately never asked, because its answer could not have changed the outcome.
+     */
+    unverifiableReason(lock) {
+        return `locked by claude agent ${lock.agent}; ${exports.LOCK_LIVENESS_UNVERIFIABLE} — the recorded pid `
+            + `${String(lock.pid)} is the shared Claude Code session process, not the agent's. Its branch `
+            + 'is not provably dead either, so it is left alone';
+    }
+    /**
+     * Stamp an overridden verdict with the lock the reap must CLEAR: git refuses to remove a locked
+     * worktree, and the reason has to say why a lock is being overridden at all.
      *
      * Applied to every verdict the fall-through can produce, not just the deletable one, because the
      * spared cases are exactly where a human reads the reason and asks "wasn't that locked?".
      */
-    annotate(verdict, lock) {
-        if (lock === null)
+    annotate(verdict, decision) {
+        if (decision === null || decision.spare || decision.lock === null)
             return verdict;
         verdict.unlockBeforeRemove = true;
-        verdict.reason = `${verdict.reason}; stale lock from claude agent ${lock.agent}, `
-            + `pid ${String(lock.pid)} is gone`;
+        verdict.reason = `${verdict.reason}; ${decision.reason}`;
         return verdict;
     }
 };
 exports.WorktreeLockVerdicts = WorktreeLockVerdicts;
 exports.WorktreeLockVerdicts = WorktreeLockVerdicts = tslib_1.__decorate([
     (0, inversify_1.injectable)(inversify_1.bindingScopeValues.Singleton),
-    tslib_1.__metadata("design:paramtypes", [agent_worktree_lock_1.AgentWorktreeLockReader])
+    tslib_1.__metadata("design:paramtypes", [agent_worktree_lock_1.AgentWorktreeLockReader,
+        harness_agent_activity_1.HarnessAgentActivityReader,
+        worktrees_1.WorktreeService])
 ], WorktreeLockVerdicts);
 //# sourceMappingURL=worktree-lock-verdicts.js.map

package/src/worktree-lock-verdicts.js.map

@@ -1 +1 @@
-{"version":3,"file":"worktree-lock-verdicts.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-config/src/worktree-lock-verdicts.ts"],"names":[],"mappings":";;;;AAAA,yCAA2D;AAE3D,+DAAmF;AAInF;;;;;;;GAOG;AAEI,IAAM,oBAAoB,GAA1B,MAAM,oBAAoB;IACA;IAA7B,YAA6B,aAAsC,IAAI,6CAAuB,EAAE;QAAnE,eAAU,GAAV,UAAU,CAAyD;IAAG,CAAC;IAEpG;;;;;;;OAOG;IACH,cAAc,CAAC,IAAc;QACzB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QAC/B,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACzD,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,IAAc;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACpD,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChB,OAAO,0BAA0B,IAAI,CAAC,KAAK,SAAS,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB;kBACjF,+BAA+B,CAAC;QAC1C,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,KAAK,EAAE,EAAE,CAAC;YACzB,OAAO,yFAAyF,CAAC;QACrG,CAAC;QACD,OAAO,mBAAmB,IAAI,CAAC,UAAU,wDAAwD;cAC3F,wBAAwB,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,OAA0B,EAAE,IAA8B;QAC/D,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,OAAO,CAAC;QAClC,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAClC,OAAO,CAAC,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,kCAAkC,IAAI,CAAC,KAAK,IAAI;cAC5E,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC;QACxC,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ,CAAA;AAzDY,oDAAoB;+BAApB,oBAAoB;IADhC,IAAA,sBAAU,EAAC,8BAAkB,CAAC,SAAS,CAAC;6CAEI,6CAAuB;GADvD,oBAAoB,CAyDhC","sourcesContent":["import { injectable, bindingScopeValues } from 'inversify';\n\nimport { AgentWorktreeLock, AgentWorktreeLockReader } from './agent-worktree-lock';\nimport { DeletableWorktree } from './merged-branch-verdicts';\nimport { Worktree } from './worktrees';\n\n/**\n * What a `git worktree lock` DOES to a worktree's cleanup verdict.\n *\n * Separate from agent-worktree-lock.ts, which only reads a lock reason and asks the kernel about a\n * pid: this is the policy built on top of that evidence — which locks stop a reap, what a spared lock\n * is allowed to claim about who took it, and what a stale one has to leave behind on the verdict so\n * the reaper knows a lock is standing in its way.\n */\n@injectable(bindingScopeValues.Singleton)\nexport class WorktreeLockVerdicts {\n    constructor(private readonly agentLocks: AgentWorktreeLockReader = new AgentWorktreeLockReader()) {}\n\n    /**\n     * The lock on this worktree was taken by a Claude agent whose process is GONE — or null, meaning\n     * the lock is still standing for something and the worktree must be spared.\n     *\n     * Null covers three genuinely different situations that all end the same way: a live agent, a\n     * reason we do not recognise, and no reason at all. `sparedReason` is what tells them apart for\n     * the reader; here they are one answer, \"do not touch\".\n     */\n    staleAgentLock(tree: Worktree): AgentWorktreeLock | null {\n        const lock = this.agentLocks.parse(tree.lockReason);\n        if (lock === null) return null;\n        return this.agentLocks.isRunning(lock) ? null : lock;\n    }\n\n    /**\n     * WHY a locked worktree was left alone — reporting what the lock SAYS, never who we imagine wrote\n     * it.\n     *\n     * This used to read `locked by a human — do not touch` for every lock in existence, which was\n     * wrong twice over. It was factually wrong about the agent harness's own locks, which is what let\n     * every `/full-cycle` worktree pile up forever. And it named an actor nothing in the evidence\n     * identifies: the lock reason is the ONLY thing we have, a human may have locked it, so may some\n     * other tool, and asserting either is the same defect whichever way it lands.\n     *\n     * So: name the agent and pid when the reason ASSERTS them, and otherwise quote the reason back\n     * verbatim and say plainly that we cannot tell who locked it.\n     */\n    sparedReason(tree: Worktree): string {\n        const lock = this.agentLocks.parse(tree.lockReason);\n        if (lock !== null) {\n            return `locked by claude agent ${lock.agent}, pid ${String(lock.pid)} still running — `\n                + 'that agent is working in here';\n        }\n        if (tree.lockReason === '') {\n            return 'locked with no reason recorded — nothing says who locked it or why, so it is left alone';\n        }\n        return `locked, reason \"${tree.lockReason}\" — that is not a claude agent lock, so who locked it `\n            + 'is unknown; left alone';\n    }\n\n    /**\n     * Stamp a verdict with the stale lock on its worktree: the lock has to be CLEARED before git will\n     * remove the directory, and the reason has to say why a lock is being overridden at all.\n     *\n     * Applied to every verdict the fall-through can produce, not just the deletable one, because the\n     * spared cases are exactly where a human reads the reason and asks \"wasn't that locked?\".\n     */\n    annotate(verdict: DeletableWorktree, lock: AgentWorktreeLock | null): DeletableWorktree {\n        if (lock === null) return verdict;\n        verdict.unlockBeforeRemove = true;\n        verdict.reason = `${verdict.reason}; stale lock from claude agent ${lock.agent}, `\n            + `pid ${String(lock.pid)} is gone`;\n        return verdict;\n    }\n}\n"]}
+{"version":3,"file":"worktree-lock-verdicts.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-config/src/worktree-lock-verdicts.ts"],"names":[],"mappings":"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","sourcesContent":["import { injectable, bindingScopeValues } from 'inversify';\n\nimport { AgentWorktreeLock, AgentWorktreeLockReader } from './agent-worktree-lock';\nimport {\n    AGENT_ACTIVITY_LIVE,\n    AGENT_ACTIVITY_UNKNOWN,\n    AgentActivity,\n    HarnessAgentActivityReader,\n} from './harness-agent-activity';\nimport { DeletableWorktree } from './merged-branch-verdicts';\nimport { Worktree, WorktreeService } from './worktrees';\n\n/**\n * What a `git worktree lock` DOES to a worktree's cleanup verdict.\n *\n * Separate from agent-worktree-lock.ts (which only parses a lock reason) and from\n * harness-agent-activity.ts (which only asks the harness about an agent): this is the POLICY built on\n * top of that evidence — what stops a reap, what a spared lock is allowed to CLAIM about who took it,\n * and what an overridden one has to leave on the verdict so the reaper knows to clear it.\n *\n * ─── WHY THE POLICY CHANGED ──────────────────────────────────────────────────────────────────────\n * It used to be one question, asked of the kernel: is the pid in the lock reason still running? That\n * pid is the Claude Code SESSION process, shared by every subagent, so the answer was yes for the\n * whole life of a session and every agent worktree was spared forever — nine against a cap of five,\n * with one agent running, each carrying the sentence \"that agent is working in here\" about agents\n * whose PRs had already merged. Both halves were defects: the reap never happened, and the message\n * asserted something nobody knew.\n *\n * ─── THE DECISION TABLE, AND THE ONE RULE BEHIND IT ──────────────────────────────────────────────\n *\n *      HARNESS STATE MAY ONLY VETO A REAP. IT MAY NEVER LICENSE ONE.\n *\n * The licence comes solely from the branch/commit evidence wp-cleanup already computes and already\n * gets right. So, for a lock this repo can read as the harness's own:\n *\n *   branch evidence does NOT say deletable          → SPARE. The harness is not even consulted; it\n *                                                     cannot promote a spare into a reap.\n *   deletable, but the worktree is DIRTY            → SPARE, unconditionally. Uncommitted or\n *                                                     untracked files are work no archive tag can\n *                                                     bring back. This one overrides everything,\n *                                                     including the explicit flag.\n *   deletable, clean, harness says the agent is\n *   mid-tool-call and writing                       → SPARE. The veto.\n *   deletable, clean, harness says returned /\n *   long-stale / cannot tell                        → judge it on its branch like any unlocked tree,\n *                                                     clearing the lock on the way out.\n *\n * `--ignore-stale-locks` moves ONE line of that table: it lets a locked worktree whose branch is not\n * provably dead be classified on its real branch and commit state anyway (so a zero-commit husk gets\n * reaped and a worktree holding unique commits reaches the numbered block a human can answer). It\n * does not touch the dirty rail or the live-agent veto, because neither of those is what the caller\n * is complaining about when they pass it.\n *\n * ─── SCOPE: AGENT LOCKS ONLY ─────────────────────────────────────────────────────────────────────\n * Every override applies ONLY to a lock this file can read as the harness's own. A lock reason naming\n * anything else — a human's \"dean is debugging\", or nothing at all — is still an instruction from\n * somebody, and wp-cleanup still obeys it.\n */\n\n/**\n * The exact phrase a spared \"we cannot tell\" verdict carries, exported so wp-cleanup can spot those\n * worktrees and offer the flag that judges them on their branch instead.\n *\n * ONE spelling, shared: the alternative is the caller re-deriving the same condition from a second\n * copy of the sentence, which is how a message and the code that keys off it drift apart.\n */\nexport const LOCK_LIVENESS_UNVERIFIABLE = 'whether that agent is still running cannot be verified';\n\n/**\n * The stand-in for \"the harness was never asked\", used on the paths where asking could not change the\n * answer. It is UNKNOWN, so a caller that consults it anyway still fails safe.\n */\nexport const HARNESS_NOT_CONSULTED = new AgentActivity(\n    AGENT_ACTIVITY_UNKNOWN, 'the harness was not consulted');\n\n// Data-only (per CLAUDE.md, classes for data). Everything `decide` rules on, as one value — see\n// `gather`, which is the only thing that builds one outside a test.\nexport class LockEvidence {\n    /** The lock reason verbatim, straight out of `git worktree list --porcelain`. */\n    lockReason: string;\n    /** What the harness says about the agent named in that reason, or HARNESS_NOT_CONSULTED. */\n    activity: AgentActivity;\n    /** Does `git status --porcelain` report anything, or could it not answer? Either way: held. */\n    workInFlight: boolean;\n    /** Why it is held, in git's terms — printed verbatim, because the two reasons differ for a human. */\n    workInFlightReason: string;\n    /** Is the branch this worktree holds ALREADY provably dead by the ordinary verdicts? */\n    branchDeletable: boolean;\n    /** The caller said to treat a standing agent lock as no evidence at all. */\n    ignoreStaleAgentLocks: boolean;\n\n    constructor(\n        lockReason: string,\n        activity: AgentActivity,\n        workInFlight: boolean,\n        workInFlightReason: string,\n        branchDeletable: boolean,\n        ignoreStaleAgentLocks: boolean,\n    ) {\n        this.lockReason = lockReason;\n        this.activity = activity;\n        this.workInFlight = workInFlight;\n        this.workInFlightReason = workInFlightReason;\n        this.branchDeletable = branchDeletable;\n        this.ignoreStaleAgentLocks = ignoreStaleAgentLocks;\n    }\n}\n\n/**\n * Data-only. The one verdict this file produces: spare or override, the sentence that says WHY, and\n * the agent lock the reaper will have to clear if the worktree goes.\n *\n * ONE class rather than a spare-path method and an override-path method, because the two answers are\n * mutually exclusive readings of the same evidence, and two methods is how they drift apart — which\n * is precisely what happened before: the old spared message and the old stale-lock test were computed\n * from the same pid by different code, and only one of them was ever corrected.\n */\nexport class LockDecision {\n    /** True: leave this worktree alone, and `reason` is the whole story. */\n    spare: boolean;\n    /** Spared: why it was left. Overridden: the clause appended to the branch's own verdict. */\n    reason: string;\n    /** The agent lock to clear on the way out — null when nothing may be cleared. */\n    lock: AgentWorktreeLock | null;\n\n    constructor(spare: boolean, reason: string, lock: AgentWorktreeLock | null) {\n        this.spare = spare;\n        this.reason = reason;\n        this.lock = lock;\n    }\n}\n\n@injectable(bindingScopeValues.Singleton)\nexport class WorktreeLockVerdicts {\n    // Defaulted like BranchReaper's collaborators, so the non-DI call sites can just\n    // `new WorktreeLockVerdicts()` while inversify still injects the singletons from a container.\n    constructor(\n        private readonly agentLocks: AgentWorktreeLockReader = new AgentWorktreeLockReader(),\n        private readonly harness: HarnessAgentActivityReader = new HarnessAgentActivityReader(),\n        private readonly worktrees: WorktreeService = new WorktreeService(),\n    ) {}\n\n    /**\n     * Collect what `decide` rules on — and, just as deliberately, DECLINE to collect the two\n     * expensive facts when they cannot change the answer.\n     *\n     * `git status --porcelain` and a walk of the harness's state tree are gathered only when a reap\n     * is otherwise on the table: the lock is one this repo can read as the harness's own, and either\n     * the branch is already provably dead or the caller asked for locks to be ignored. That is not an\n     * optimisation dressed up as a rule — harness state may only VETO a reap, never license one, so on\n     * a path with no reap to veto there is nothing to ask, and asking would invite a later reader to\n     * let the answer decide something.\n     */\n    gather(tree: Worktree, branchDeletable: boolean, ignoreStaleAgentLocks: boolean): LockEvidence {\n        const lock = this.agentLocks.parse(tree.lockReason);\n        if (lock === null || (!branchDeletable && !ignoreStaleAgentLocks)) {\n            return new LockEvidence(tree.lockReason, HARNESS_NOT_CONSULTED, false, '',\n                branchDeletable, ignoreStaleAgentLocks);\n        }\n        const held = this.worktrees.workInFlight(tree.path);\n        return new LockEvidence(\n            tree.lockReason, this.harness.activityOf(lock.agent, tree.path), held.held, held.reason,\n            branchDeletable, ignoreStaleAgentLocks);\n    }\n\n    /**\n     * Spare this locked worktree, or judge it on its branch like any unlocked one — with the sentence\n     * that says which piece of evidence decided it.\n     *\n     * The order below IS the decision table in the class header, in the same order, for the same\n     * reasons. Read it there.\n     */\n    decide(evidence: LockEvidence): LockDecision {\n        const lock = this.agentLocks.parse(evidence.lockReason);\n        if (lock === null) return new LockDecision(true, this.foreignLockReason(evidence.lockReason), null);\n\n        if (!evidence.branchDeletable && !evidence.ignoreStaleAgentLocks) {\n            return new LockDecision(true, this.unverifiableReason(lock), null);\n        }\n        if (evidence.workInFlight) {\n            return new LockDecision(true,\n                `locked by claude agent ${lock.agent}, and the worktree ${evidence.workInFlightReason} — `\n                + 'nothing archives that, so it is left exactly where it is', null);\n        }\n        if (evidence.activity.state === AGENT_ACTIVITY_LIVE) {\n            return new LockDecision(true,\n                `locked by claude agent ${lock.agent}, and the Claude Code harness says `\n                + `${evidence.activity.detail} — that agent is working in here`, null);\n        }\n        if (evidence.branchDeletable) {\n            return new LockDecision(false,\n                `the lock from claude agent ${lock.agent} did not stop this — the worktree is clean, its `\n                + `branch is already dead, and ${evidence.activity.detail}`, lock);\n        }\n        return new LockDecision(false,\n            `the lock from claude agent ${lock.agent} was treated as no evidence, as asked`, lock);\n    }\n\n    /**\n     * WHY a locked worktree was left alone when the lock is NOT the harness's — reporting what the\n     * reason SAYS, never who we imagine wrote it.\n     *\n     * This used to read `locked by a human — do not touch` for every lock in existence, which named an\n     * actor nothing in the evidence identifies: the lock reason is the ONLY thing we have, a human may\n     * have locked it, so may some other tool, and asserting either is the same defect whichever way it\n     * lands.\n     */\n    private foreignLockReason(lockReason: string): string {\n        if (lockReason === '') {\n            return 'locked with no reason recorded — nothing says who locked it or why, so it is left alone';\n        }\n        return `locked, reason \"${lockReason}\" — that is not a claude agent lock, so who locked it `\n            + 'is unknown; left alone';\n    }\n\n    /**\n     * The sentence that replaced \"pid N still running — that agent is working in here\".\n     *\n     * It says only what is known: which agent the reason names, that the pid in it cannot answer the\n     * question because it is the shared session process, and that nothing else made the worktree\n     * provably dead either. No claim about anybody working — and no claim about the harness, which on\n     * this path was deliberately never asked, because its answer could not have changed the outcome.\n     */\n    private unverifiableReason(lock: AgentWorktreeLock): string {\n        return `locked by claude agent ${lock.agent}; ${LOCK_LIVENESS_UNVERIFIABLE} — the recorded pid `\n            + `${String(lock.pid)} is the shared Claude Code session process, not the agent's. Its branch `\n            + 'is not provably dead either, so it is left alone';\n    }\n\n    /**\n     * Stamp an overridden verdict with the lock the reap must CLEAR: git refuses to remove a locked\n     * worktree, and the reason has to say why a lock is being overridden at all.\n     *\n     * Applied to every verdict the fall-through can produce, not just the deletable one, because the\n     * spared cases are exactly where a human reads the reason and asks \"wasn't that locked?\".\n     */\n    annotate(verdict: DeletableWorktree, decision: LockDecision | null): DeletableWorktree {\n        if (decision === null || decision.spare || decision.lock === null) return verdict;\n        verdict.unlockBeforeRemove = true;\n        verdict.reason = `${verdict.reason}; ${decision.reason}`;\n        return verdict;\n    }\n}\n"]}