@telora/daemon 0.21.26 → 0.21.82

package/dist/delivery/delivery-advance-block.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Advance-block precondition for delivery progression.
+ *
+ * Extracted from delivery-lifecycle.ts (kept under the daemon file-size limit).
+ * Owns the "agents must commit before the daemon advances" guard and its
+ * durable, dedup-aware escalation. Re-exported from delivery-lifecycle.ts so
+ * existing importers keep their import path.
+ *
+ * @module delivery-advance-block
+ */
+import { createEscalation, hasOpenWorktreeDirtyEscalation, resolveOpenWorktreeDirtyEscalations } from '../queries/issues.js';
+import { sendMessage } from '@telora/daemon-core';
+import type { Writable } from 'node:stream';
+import { getFocusWorktree } from '../focus/focus-worktree-state.js';
+import { worktreeHasUncommittedChanges, dirtyChangesAreGeneratedLockfilesOnly, commitGeneratedLockfiles, safetyCommitWorktree, reconcileTornWrite, isWorktreeUnderVerify } from '../worktree/index.js';
+/**
+ * escalation_kind discriminator for the advance-block escalation class.
+ *
+ * Previously this lived only in the metadata bag (metadata.kind) because the
+ * escalation_kind column has a fixed CHECK. It is now a first-class
+ * escalation_kind (ESCALATION_KINDS.ADVANCE_BLOCKED), so the dedup lookup
+ * matches on the escalation_kind + delivery_id COLUMNS rather than metadata.
+ * Covers the advance-block class generally, not just uncommitted-changes.
+ */
+export declare const ADVANCE_BLOCK_ESCALATION_KIND: "advance_blocked";
+/**
+ * The worktree-dirty escalation kinds a CLEAN worktree clears. advance_blocked
+ * and merge_refused_dirty are both literally "the focus worktree has
+ * uncommitted changes", so once the tree is clean they are stale and can be
+ * auto-resolved. merge_conflict is deliberately excluded: a content conflict
+ * between branches is not a dirty-worktree condition and a clean worktree does
+ * not resolve it (the merge-success path clears merge_conflict instead).
+ */
+export declare const CLEAN_WORKTREE_RESOLVES_KINDS: readonly string[];
+/** Default auto-remediation retry budget when TELORA_AUTO_REMEDIATION_BUDGET is unset. */
+export declare const DEFAULT_AUTO_REMEDIATION_BUDGET = 3;
+/**
+ * Resolve the auto-remediation retry budget: how many times the daemon re-wakes
+ * a team to commit before giving up and filing a human-facing escalation.
+ *
+ * Declared + validated in daemon-core's env-config (the canonical knob index).
+ * Read uncached (explicit env arg) so tests that flip the var per-case see the
+ * live value. Mirrors the team_failure-after-K-cycles budget
+ * (TELORA_SCOPE_COVERAGE_NO_PROGRESS_LIMIT).
+ */
+export declare function resolveAutoRemediationBudget(): number;
+/**
+ * Minimum gap between auto-remediation re-wake nudges for the same focus. The
+ * advance-block guard is called once per DELIVERY per poll, but a dirty
+ * worktree is a focus-level fact -- without this gate an N-delivery focus would
+ * fire N nudges and burn N budget per poll. Keeping the gate below the poll
+ * interval (30s) makes "one re-wake + one budget tick per poll cycle" hold: the
+ * first delivery in a cycle re-wakes, its siblings (same millisecond) no-op,
+ * and the next poll (>= interval later) counts as a fresh cycle.
+ */
+export declare const REWAKE_MIN_INTERVAL_MS = 20000;
+/** Test seam: clear the per-focus auto-remediation state between cases. */
+export declare function __resetAutoRemediationAttempts(): void;
+/** Minimal team handle the advance-block path needs to re-wake a lead. */
+interface AdvanceBlockTeamHandle {
+    leadStdin: Writable | null;
+}
+/**
+ * Injectable collaborators for ensureWorktreeCommittedBeforeAdvance. Defaults
+ * to the real implementations; tests override them to drive the dedup +
+ * auto-remediation paths without a live worktree, team, or Supabase.
+ */
+export interface EnsureWorktreeCommittedDeps {
+    getFocusWorktree?: typeof getFocusWorktree;
+    worktreeHasUncommittedChanges?: typeof worktreeHasUncommittedChanges;
+    createEscalation?: typeof createEscalation;
+    hasOpenWorktreeDirtyEscalation?: typeof hasOpenWorktreeDirtyEscalation;
+    /** Auto-close stale worktree-dirty escalations when the worktree goes clean. */
+    resolveOpenWorktreeDirtyEscalations?: typeof resolveOpenWorktreeDirtyEscalations;
+    /**
+     * Reconcile a pure torn-write index (staged entries with no worktree content
+     * behind them) to HEAD. Runs BEFORE lockfile/re-wake/safety-commit so a torn
+     * write self-clears without a pointless team nudge or an escalation.
+     */
+    reconcileTornWrite?: typeof reconcileTornWrite;
+    /** True while a verify command runs in the focus worktree -> defer, do not commit/escalate. */
+    isWorktreeUnderVerify?: typeof isWorktreeUnderVerify;
+    dirtyChangesAreGeneratedLockfilesOnly?: typeof dirtyChangesAreGeneratedLockfilesOnly;
+    commitGeneratedLockfiles?: typeof commitGeneratedLockfiles;
+    /**
+     * Last-resort WIP safety-commit of real uncommitted agent work when no team
+     * is reachable to re-wake (DECIDED 2026-06-22, Jeremy). Reuses the same
+     * primitive crash-recovery and removeWorktree use.
+     */
+    safetyCommitWorktree?: typeof safetyCommitWorktree;
+    getActiveTeam?: (focusId: string) => AdvanceBlockTeamHandle | undefined;
+    sendMessage?: typeof sendMessage;
+    autoRemediationBudget?: number;
+    /** Min gap between re-wakes for a focus (default REWAKE_MIN_INTERVAL_MS). Tests pass 0. */
+    rewakeMinIntervalMs?: number;
+    /** Clock seam (default Date.now). */
+    now?: () => number;
+}
+/**
+ * Precondition for advancing a delivery out of coding: the focus worktree
+ * must have no uncommitted changes. Agents must commit their work before
+ * the daemon advances the delivery, otherwise uncommitted changes are at
+ * risk of being lost on focus merge.
+ *
+ * Returns ok=true when the worktree is clean (or no worktree is registered
+ * for the focus -- e.g. teamless cleanup with the worktree already pruned, or
+ * the dirt was auto-remediated). Returns ok=false when uncommitted changes
+ * remain.
+ *
+ * Disposition-aware routing (D1): a dirty worktree is an agent_resolvable
+ * condition -- no human is needed to clear it -- so the daemon AUTO-REMEDIATES
+ * before ever filing a human-facing escalation, mirroring the
+ * team_failure-after-K-cycles pattern:
+ *   1. Pure generated-lockfile churn  -> the daemon commits it and advances.
+ *   2. Real uncommitted agent work    -> re-wake the team lead to commit, up to
+ *      a bounded retry budget (TELORA_AUTO_REMEDIATION_BUDGET); no escalation
+ *      while within budget.
+ *   3. Budget exhausted, or no team is reachable and the dirt is not
+ *      lockfile-only -> file a human escalation, now disposition NEEDS_OPERATOR
+ *      (it genuinely needs a human). agent_resolvable rows no longer reach the
+ *      human inbox.
+ *
+ * Dedup: at most ONE open worktree-dirty escalation per FOCUS, collapsed
+ * across the sibling classes. A dirty worktree is a property of the focus
+ * worktree shared by all the focus's deliveries, so before filing we query
+ * hasOpenWorktreeDirtyEscalation(focusId) -- if ANY sibling class
+ * (advance_blocked / merge_conflict / merge_refused_dirty) is already open for
+ * the focus we no-op. This collapses the old per-delivery storm (N deliveries
+ * -> N rows) to one row, suppresses across the merge paths, and is durable
+ * across daemon restarts (it reads the DB, holds no in-memory state).
+ */
+export declare function ensureWorktreeCommittedBeforeAdvance(params: {
+    deliveryId: string;
+    deliveryName: string;
+    focusId: string;
+    organizationId: string;
+    sessionId: string | null;
+}, deps?: EnsureWorktreeCommittedDeps): Promise<{
+    ok: boolean;
+    reason?: string;
+}>;
+export {};
+//# sourceMappingURL=delivery-advance-block.d.ts.map

package/dist/delivery/delivery-advance-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-advance-block.d.ts","sourceRoot":"","sources":["../../src/delivery/delivery-advance-block.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,gBAAgB,EAAE,8BAA8B,EAAE,mCAAmC,EAAuC,MAAM,sBAAsB,CAAC;AAClK,OAAO,EAAa,WAAW,EAAgF,MAAM,qBAAqB,CAAC;AAC3I,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EACL,6BAA6B,EAC7B,qCAAqC,EACrC,wBAAwB,EACxB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EAEtB,MAAM,sBAAsB,CAAC;AAQ9B;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,mBAAmC,CAAC;AAE9E;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAG1D,CAAC;AAEF,0FAA0F;AAC1F,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAQrD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAiB7C,2EAA2E;AAC3E,wBAAgB,8BAA8B,IAAI,IAAI,CAErD;AA0BD,0EAA0E;AAC1E,UAAU,sBAAsB;IAC9B,SAAS,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,6BAA6B,CAAC,EAAE,OAAO,6BAA6B,CAAC;IACrE,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,8BAA8B,CAAC,EAAE,OAAO,8BAA8B,CAAC;IACvE,gFAAgF;IAChF,mCAAmC,CAAC,EAAE,OAAO,mCAAmC,CAAC;IAEjF;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAC;IAC/C,+FAA+F;IAC/F,qBAAqB,CAAC,EAAE,OAAO,qBAAqB,CAAC;IACrD,qCAAqC,CAAC,EAAE,OAAO,qCAAqC,CAAC;IACrF,wBAAwB,CAAC,EAAE,OAAO,wBAAwB,CAAC;IAC3D;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;IACnD,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,sBAAsB,GAAG,SAAS,CAAC;IACxE,WAAW,CAAC,EAAE,OAAO,WAAW,CAAC;IACjC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2FAA2F;IAC3F,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,qCAAqC;IACrC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,oCAAoC,CAAC,MAAM,EAAE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,EAAE,IAAI,GAAE,2BAAgC,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAsQpF"}

package/dist/delivery/delivery-advance-block.js

@@ -0,0 +1,360 @@
+/**
+ * Advance-block precondition for delivery progression.
+ *
+ * Extracted from delivery-lifecycle.ts (kept under the daemon file-size limit).
+ * Owns the "agents must commit before the daemon advances" guard and its
+ * durable, dedup-aware escalation. Re-exported from delivery-lifecycle.ts so
+ * existing importers keep their import path.
+ *
+ * @module delivery-advance-block
+ */
+import { createEscalation, hasOpenWorktreeDirtyEscalation, resolveOpenWorktreeDirtyEscalations, MERGE_REFUSED_DIRTY_ESCALATION_KIND } from '../queries/issues.js';
+import { withRetry, sendMessage, loadEnvConfig, ESCALATION_REASONS, ESCALATION_DISPOSITIONS, ESCALATION_KINDS } from '@telora/daemon-core';
+import { getFocusWorktree } from '../focus/focus-worktree-state.js';
+import { worktreeHasUncommittedChanges, dirtyChangesAreGeneratedLockfilesOnly, commitGeneratedLockfiles, safetyCommitWorktree, reconcileTornWrite, isWorktreeUnderVerify, } from '../worktree/index.js';
+import { getActiveTeams } from '../focus/focus-team-state.js';
+import { nextResolverStep } from '../directive/resolver-dispatch.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'delivery-lifecycle' });
+/**
+ * escalation_kind discriminator for the advance-block escalation class.
+ *
+ * Previously this lived only in the metadata bag (metadata.kind) because the
+ * escalation_kind column has a fixed CHECK. It is now a first-class
+ * escalation_kind (ESCALATION_KINDS.ADVANCE_BLOCKED), so the dedup lookup
+ * matches on the escalation_kind + delivery_id COLUMNS rather than metadata.
+ * Covers the advance-block class generally, not just uncommitted-changes.
+ */
+export const ADVANCE_BLOCK_ESCALATION_KIND = ESCALATION_KINDS.ADVANCE_BLOCKED;
+/**
+ * The worktree-dirty escalation kinds a CLEAN worktree clears. advance_blocked
+ * and merge_refused_dirty are both literally "the focus worktree has
+ * uncommitted changes", so once the tree is clean they are stale and can be
+ * auto-resolved. merge_conflict is deliberately excluded: a content conflict
+ * between branches is not a dirty-worktree condition and a clean worktree does
+ * not resolve it (the merge-success path clears merge_conflict instead).
+ */
+export const CLEAN_WORKTREE_RESOLVES_KINDS = [
+    ADVANCE_BLOCK_ESCALATION_KIND,
+    MERGE_REFUSED_DIRTY_ESCALATION_KIND,
+];
+/** Default auto-remediation retry budget when TELORA_AUTO_REMEDIATION_BUDGET is unset. */
+export const DEFAULT_AUTO_REMEDIATION_BUDGET = 3;
+/**
+ * Resolve the auto-remediation retry budget: how many times the daemon re-wakes
+ * a team to commit before giving up and filing a human-facing escalation.
+ *
+ * Declared + validated in daemon-core's env-config (the canonical knob index).
+ * Read uncached (explicit env arg) so tests that flip the var per-case see the
+ * live value. Mirrors the team_failure-after-K-cycles budget
+ * (TELORA_SCOPE_COVERAGE_NO_PROGRESS_LIMIT).
+ */
+export function resolveAutoRemediationBudget() {
+    try {
+        return loadEnvConfig(process.env).TELORA_AUTO_REMEDIATION_BUDGET;
+    }
+    catch {
+        // Startup already failed loudly on invalid env; a mid-run mutation must
+        // not crash a poll tick -- fall back to the documented default.
+        return DEFAULT_AUTO_REMEDIATION_BUDGET;
+    }
+}
+/**
+ * Minimum gap between auto-remediation re-wake nudges for the same focus. The
+ * advance-block guard is called once per DELIVERY per poll, but a dirty
+ * worktree is a focus-level fact -- without this gate an N-delivery focus would
+ * fire N nudges and burn N budget per poll. Keeping the gate below the poll
+ * interval (30s) makes "one re-wake + one budget tick per poll cycle" hold: the
+ * first delivery in a cycle re-wakes, its siblings (same millisecond) no-op,
+ * and the next poll (>= interval later) counts as a fresh cycle.
+ */
+export const REWAKE_MIN_INTERVAL_MS = 20_000;
+const remediationState = new Map();
+/** Test seam: clear the per-focus auto-remediation state between cases. */
+export function __resetAutoRemediationAttempts() {
+    remediationState.clear();
+}
+/**
+ * Best-effort: close any open advance_blocked / merge_refused_dirty escalation
+ * for the focus now that its worktree is clean. Never throws -- a resolve
+ * failure is the resolver's own concern and must not block the advance.
+ */
+async function autoResolveClearedEscalations(resolveOpenEsc, focusId) {
+    try {
+        const n = await resolveOpenEsc(focusId, CLEAN_WORKTREE_RESOLVES_KINDS);
+        if (n > 0) {
+            log.info(`[delivery-lifecycle] Worktree clean for focus ${focusId}; auto-resolved ${n} ` +
+                `stale worktree-dirty escalation(s).`);
+        }
+    }
+    catch (err) {
+        log.warn(`[delivery-lifecycle] Auto-resolve of cleared worktree-dirty escalations failed for focus ${focusId}: ${err.message}`);
+    }
+}
+/**
+ * Precondition for advancing a delivery out of coding: the focus worktree
+ * must have no uncommitted changes. Agents must commit their work before
+ * the daemon advances the delivery, otherwise uncommitted changes are at
+ * risk of being lost on focus merge.
+ *
+ * Returns ok=true when the worktree is clean (or no worktree is registered
+ * for the focus -- e.g. teamless cleanup with the worktree already pruned, or
+ * the dirt was auto-remediated). Returns ok=false when uncommitted changes
+ * remain.
+ *
+ * Disposition-aware routing (D1): a dirty worktree is an agent_resolvable
+ * condition -- no human is needed to clear it -- so the daemon AUTO-REMEDIATES
+ * before ever filing a human-facing escalation, mirroring the
+ * team_failure-after-K-cycles pattern:
+ *   1. Pure generated-lockfile churn  -> the daemon commits it and advances.
+ *   2. Real uncommitted agent work    -> re-wake the team lead to commit, up to
+ *      a bounded retry budget (TELORA_AUTO_REMEDIATION_BUDGET); no escalation
+ *      while within budget.
+ *   3. Budget exhausted, or no team is reachable and the dirt is not
+ *      lockfile-only -> file a human escalation, now disposition NEEDS_OPERATOR
+ *      (it genuinely needs a human). agent_resolvable rows no longer reach the
+ *      human inbox.
+ *
+ * Dedup: at most ONE open worktree-dirty escalation per FOCUS, collapsed
+ * across the sibling classes. A dirty worktree is a property of the focus
+ * worktree shared by all the focus's deliveries, so before filing we query
+ * hasOpenWorktreeDirtyEscalation(focusId) -- if ANY sibling class
+ * (advance_blocked / merge_conflict / merge_refused_dirty) is already open for
+ * the focus we no-op. This collapses the old per-delivery storm (N deliveries
+ * -> N rows) to one row, suppresses across the merge paths, and is durable
+ * across daemon restarts (it reads the DB, holds no in-memory state).
+ */
+export async function ensureWorktreeCommittedBeforeAdvance(params, deps = {}) {
+    const getWorktree = deps.getFocusWorktree ?? getFocusWorktree;
+    const hasUncommitted = deps.worktreeHasUncommittedChanges ?? worktreeHasUncommittedChanges;
+    const createEsc = deps.createEscalation ?? createEscalation;
+    const hasOpenEsc = deps.hasOpenWorktreeDirtyEscalation ?? hasOpenWorktreeDirtyEscalation;
+    const resolveOpenEsc = deps.resolveOpenWorktreeDirtyEscalations ?? resolveOpenWorktreeDirtyEscalations;
+    const reconcileTorn = deps.reconcileTornWrite ?? reconcileTornWrite;
+    const isUnderVerify = deps.isWorktreeUnderVerify ?? isWorktreeUnderVerify;
+    const isLockfileOnly = deps.dirtyChangesAreGeneratedLockfilesOnly ?? dirtyChangesAreGeneratedLockfilesOnly;
+    const commitLockfiles = deps.commitGeneratedLockfiles ?? commitGeneratedLockfiles;
+    const safetyCommit = deps.safetyCommitWorktree ?? safetyCommitWorktree;
+    const getTeam = deps.getActiveTeam ?? ((id) => getActiveTeams().get(id));
+    const sendMsg = deps.sendMessage ?? sendMessage;
+    const budget = deps.autoRemediationBudget ?? resolveAutoRemediationBudget();
+    const rewakeMinIntervalMs = deps.rewakeMinIntervalMs ?? REWAKE_MIN_INTERVAL_MS;
+    const now = deps.now ?? Date.now;
+    const { deliveryId, deliveryName, focusId, organizationId, sessionId } = params;
+    const worktree = getWorktree(focusId);
+    if (!worktree)
+        return { ok: true };
+    // Verify interlock: if a verify command is running in this focus worktree, the
+    // tree may be mid-mutation (a verify that writes+restores a tracked file). DEFER
+    // the whole advance decision -- do not read dirt as work, do not commit, do not
+    // re-wake, do not escalate. This leaves NO state (no remediation episode, no
+    // budget spent), so the next poll re-evaluates cleanly once the verify completes.
+    // Guarding here as well as in guardedCommit keeps a transient mid-verify dirt
+    // from ever being read as an uncommitted-work condition in the first place.
+    if (isUnderVerify(worktree.worktreePath)) {
+        log.info(`[delivery-lifecycle] Deferring advance of "${deliveryName}": a verify command is ` +
+            `running in ${worktree.worktreePath}. Not committing, re-waking, or escalating; ` +
+            `the next poll retries once verify completes.`);
+        return { ok: false, reason: 'verify in flight (safety-commit deferred)' };
+    }
+    if (!hasUncommitted(worktree.worktreePath)) {
+        // Clean -- the dirty episode (if any) is over. Reset the retry budget so a
+        // future episode starts fresh, and auto-close any worktree-dirty escalation
+        // we filed for it so a resolved-in-fact condition stops sitting in the human
+        // inbox. Gate the resolve query on having seen an episode THIS run so the
+        // common clean-advance path adds no extra DB round-trip.
+        const hadEpisode = remediationState.delete(focusId);
+        if (hadEpisode) {
+            await autoResolveClearedEscalations(resolveOpenEsc, focusId);
+        }
+        return { ok: true };
+    }
+    const reason = `uncommitted changes in focus worktree ${worktree.worktreePath}`;
+    log.warn(`Blocking advance of "${deliveryName}": ${reason}`);
+    // ── Auto-remediation 0: pure torn write -> reconcile the index, advance ────
+    // A staged index entry with NO worktree content behind it (index != HEAD,
+    // worktree == HEAD) is not agent work -- it is a torn write (e.g. a verify
+    // command mutated a tracked file and restored it while a safety-commit
+    // snapshotted the index mid-flight). There is nothing for a team to commit and
+    // nothing to preserve, so re-waking or escalating would loop forever. Reconcile
+    // the index to the worktree; the tree goes clean and the delivery advances with
+    // NO escalation. Runs FIRST so a torn write never reaches the lockfile /
+    // re-wake / safety-commit branches below. The advance-gate DETECTOR
+    // (worktreeHasUncommittedChanges, `git status --porcelain`) and this REMEDIATOR
+    // (reconcileTornWrite, index-aware) agree on this dirt -- the wedge is what this
+    // focus exists to remove (escalation 2170fdde, 2026-08-16).
+    const reconciled = reconcileTorn(worktree.worktreePath);
+    if (reconciled) {
+        log.info(`[delivery-lifecycle] Reconciled torn-write index for "${deliveryName}" at ` +
+            `${worktree.worktreePath} (${reconciled.reconciled.length} staged path(s) with no ` +
+            `worktree content); advancing without escalation.`);
+        remediationState.delete(focusId);
+        await autoResolveClearedEscalations(resolveOpenEsc, focusId);
+        return { ok: true };
+    }
+    // ── Auto-remediation 1: pure generated-lockfile churn -> auto-commit ──────
+    if (isLockfileOnly(worktree.worktreePath)) {
+        const sha = commitLockfiles(worktree.worktreePath);
+        if (sha) {
+            log.info(`[delivery-lifecycle] Auto-committed generated lockfile churn for "${deliveryName}" ` +
+                `(${sha.slice(0, 8)}); advancing without escalation.`);
+            remediationState.delete(focusId);
+            // The worktree is now clean -- close any escalation the dirty churn raised.
+            await autoResolveClearedEscalations(resolveOpenEsc, focusId);
+            return { ok: true };
+        }
+        // Commit failed -- fall through to re-wake / escalation.
+    }
+    // Record that this focus has an active dirty episode so the clean path can
+    // later auto-resolve whatever escalation we file/maintain for it, even when
+    // the episode is escalated without ever re-waking a team.
+    if (!remediationState.has(focusId)) {
+        remediationState.set(focusId, { attempts: 0, lastNudgeAt: 0 });
+    }
+    // ── Auto-remediation 2: real work -> re-wake the team, within budget ──────
+    // Idempotent per poll cycle at FOCUS grain: this guard runs once per delivery,
+    // but the dirty worktree is one focus-level fact. Only the first delivery in a
+    // cycle acts (re-wake or escalate); siblings within the same cycle no-op.
+    //
+    // whatWasTried context for the eventual human escalation -- overwritten by the
+    // branch that actually decides to escalate so the row explains itself.
+    let escalationContext = 'the focus worktree had uncommitted changes the daemon could not auto-remediate';
+    const leadStdin = getTeam(focusId)?.leadStdin ?? null;
+    if (leadStdin) {
+        const state = remediationState.get(focusId) ?? { attempts: 0, lastNudgeAt: 0 };
+        const newCycle = now() - state.lastNudgeAt >= rewakeMinIntervalMs;
+        if (!newCycle) {
+            // A sibling delivery already acted on this focus's dirty worktree this
+            // poll cycle (re-woke or escalated). Suppress to hold "one action per
+            // cycle" -- without re-filing or double-counting budget.
+            return { ok: false, reason };
+        }
+        // Claim the cycle up front (idempotency) regardless of which branch we take.
+        state.lastNudgeAt = now();
+        remediationState.set(focusId, state);
+        // Delegate the bounded-retry-vs-escalate boundary to the shared
+        // resolver-dispatch policy primitive (nextResolverStep), so this
+        // dirty-worktree path and the general seam agree on the ONE definition of
+        // "retry within budget, else escalate" -- the attempt-first, bounded-retry,
+        // escalate-on-exhaustion shape this whole focus generalizes. The re-wake IS
+        // the resolver attempt here; escalation is the residue when it is spent.
+        if (nextResolverStep(state.attempts, budget) === 'retry') {
+            // Within budget: try to re-wake the lead. Only a SUCCESSFUL nudge spends a
+            // budget tick -- a failed write means the lead is effectively unreachable,
+            // so we stop pretending a re-wake is possible and escalate now (TEL-5).
+            try {
+                sendMsg(leadStdin, `Your focus worktree has uncommitted changes, so the daemon cannot advance ` +
+                    `delivery "${deliveryName}" yet. Please commit (or discard) your work in ` +
+                    `${worktree.worktreePath}; the daemon advances automatically once the worktree ` +
+                    `is clean. (auto-remediation attempt ${state.attempts + 1}/${budget})`);
+                state.attempts += 1;
+                remediationState.set(focusId, state);
+                log.info(`[delivery-lifecycle] Re-woke team for focus ${focusId} to commit ` +
+                    `(auto-remediation ${state.attempts}/${budget}); not escalating.`);
+                return { ok: false, reason };
+            }
+            catch (err) {
+                log.warn(`[delivery-lifecycle] Re-wake of team for "${deliveryName}" failed (${err.message}); ` +
+                    `treating the lead as unreachable and escalating to a human.`);
+                escalationContext =
+                    're-waking the team to commit failed because its input stream was unwritable ' +
+                        '(the lead is effectively unreachable), so the daemon could not ask it to commit';
+                // fall through to escalation; the failed nudge did NOT spend budget.
+            }
+        }
+        else {
+            // Budget exhausted -- fall through to the human escalation (durably deduped).
+            log.warn(`[delivery-lifecycle] Auto-remediation budget (${budget}) exhausted for focus ${focusId}; escalating to a human.`);
+            escalationContext =
+                `auto-remediation (generated-lockfile auto-commit and re-waking the team to commit) ` +
+                    `did not clear the uncommitted changes within the retry budget (${budget})`;
+        }
+    }
+    else {
+        // No live team to re-wake and the dirt is not generated-lockfile-only. The
+        // team wrote real work but exited (or was killed) before committing, leaving
+        // it stranded: the commit-gate has no team to re-wake, and re-spawning a team
+        // is out of scope here. Rather than file a needs_operator escalation for a
+        // condition the daemon can self-resolve, make a WIP safety-commit of the
+        // uncommitted agent work and advance to verify -- review is the real gate, so
+        // committing the work-in-progress loses nothing and the differential loop is
+        // not left churning on a stranded delivery. This reuses the same
+        // safetyCommitWorktree primitive crash-recovery and removeWorktree use.
+        // DECIDED 2026-06-22, Jeremy -- this deliberately reverses the prior
+        // "committing incomplete agent work and merging it is unsafe" stance: the
+        // safety-commit lands on the focus branch and review still gates the merge.
+        // Capture a mass-sweep refusal so the eventual escalation can name the
+        // count/paths the guard withheld (the work stays recoverable).
+        let sweepRefusal = null;
+        const sha = safetyCommit(worktree.worktreePath, deliveryName, (r) => {
+            sweepRefusal = r;
+        });
+        if (sha) {
+            log.info(`[delivery-lifecycle] No live team for focus ${focusId} to re-wake; safety-committed ` +
+                `uncommitted agent work ${sha.slice(0, 8)} and advancing "${deliveryName}" to verify -- ` +
+                `review is the gate.`);
+            // The worktree is now clean -- close out the dirty episode and auto-resolve
+            // any worktree-dirty escalation we filed for this focus, mirroring the
+            // lockfile-only auto-commit branch above.
+            remediationState.delete(focusId);
+            await autoResolveClearedEscalations(resolveOpenEsc, focusId);
+            return { ok: true };
+        }
+        // Safety-commit failed -- the one genuine corner that still needs a human.
+        // Fall through to the escalation block, explaining the corner (TEL-3).
+        // A sweep refusal is a distinct, recoverable corner: name the count/paths so
+        // an agent/operator can commit the legitimate subset (the daemon kept the
+        // scratch/sweep out of history and preserved the working tree).
+        if (sweepRefusal) {
+            const r = sweepRefusal;
+            escalationContext =
+                `no team is live to re-wake and the daemon REFUSED to safety-commit ${r.count} files ` +
+                    `(exceeds the ${r.maxFiles}-file sweep threshold; e.g. ${r.sample.slice(0, 5).join(', ')}), ` +
+                    `so a mass sweep was kept out of history and the working tree is preserved for recovery`;
+        }
+        else {
+            escalationContext =
+                'no team is live to re-wake and the WIP safety-commit of the uncommitted agent work ' +
+                    'failed, so the daemon could not self-resolve';
+        }
+    }
+    // ── Escalate to a human (needs_operator) ──────────────────────────────────
+    // Reached only when the retry budget is exhausted, the lead was unreachable,
+    // or no team is reachable to re-wake and the dirt is not lockfile-only. Durable
+    // focus-grain dedup still applies; fail open on lookup error so a genuine first
+    // escalation is not silently swallowed.
+    let alreadyOpen = false;
+    try {
+        alreadyOpen = await hasOpenEsc(focusId);
+    }
+    catch (err) {
+        log.warn(`[delivery-lifecycle] Open advance-block escalation lookup failed for "${deliveryName}", proceeding to file: ${err.message}`);
+    }
+    if (alreadyOpen) {
+        return { ok: false, reason };
+    }
+    try {
+        await withRetry(() => createEsc({
+            organizationId,
+            sessionId: sessionId ?? '',
+            issueId: null,
+            reasonType: ESCALATION_REASONS.ERROR_ENCOUNTERED,
+            // Auto-remediation has been exhausted (or was impossible): this now
+            // genuinely needs a human, so route to the operator -- not agent_resolvable.
+            disposition: ESCALATION_DISPOSITIONS.NEEDS_OPERATOR,
+            // First-class kind + provenance columns (was metadata.kind/deliveryId).
+            escalationKind: ADVANCE_BLOCK_ESCALATION_KIND,
+            anchor: { deliveryId, focusId },
+            description: `Delivery "${deliveryName}" cannot advance: focus worktree has uncommitted changes ` +
+                `that the daemon could not auto-remediate.`,
+            whatWasTried: 'Daemon detected all work issues Done and was about to advance the delivery, but the ' +
+                `focus worktree had uncommitted changes. Escalating because ${escalationContext}.`,
+            helpNeeded: `Commit (or discard) pending changes in ${worktree.worktreePath}, then the next poll will advance the delivery.`,
+        }), { maxAttempts: 3, label: 'escalation-uncommitted-before-advance' });
+    }
+    catch (err) {
+        log.error(`Failed to create uncommitted-changes escalation: ${err.message}`);
+    }
+    return { ok: false, reason };
+}
+//# sourceMappingURL=delivery-advance-block.js.map

package/dist/delivery/delivery-advance-block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-advance-block.js","sourceRoot":"","sources":["../../src/delivery/delivery-advance-block.ts"],"names":[],"mappings":"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"}

package/dist/delivery/delivery-artifacts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Derive delivery completion_artifacts deterministically from git, so the
+ * daemon close path populates the same shape the drift evaluator consumes
+ * without asking a human to type file paths.
+ *
+ * The diff is computed in the focus worktree against the integration branch,
+ * mirroring the base-ref policy used by the `git.diff_against_base` assembly
+ * resolver. Per-delivery branch isolation is not available -- focuses share a
+ * single worktree -- so the resulting set is the focus's full diff. That is
+ * coarser than per-delivery but still useful: every artifact returned is a
+ * real file the work touched, which is what drift detection needs.
+ *
+ * Path shape matches `drift-evaluator.ts` expectations:
+ *   - repo-relative (git diff --name-only already does this)
+ *   - forward slashes (POSIX)
+ *   - no leading slash, no `./`
+ */
+import type { ArtifactReferences } from '../drift/drift-evaluator.js';
+/**
+ * Return the list of repo-relative paths changed in the worktree vs. the
+ * base branch, or null when no diff is available (no worktree, empty diff,
+ * git failure). Callers treat the result as best-effort: null means
+ * "couldn't derive, leave completion_artifacts as-is".
+ */
+export declare function deriveCompletionArtifactsFromWorktree(worktreePath: string, baseBranch: string): ArtifactReferences | null;
+//# sourceMappingURL=delivery-artifacts.d.ts.map

package/dist/delivery/delivery-artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-artifacts.d.ts","sourceRoot":"","sources":["../../src/delivery/delivery-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAgBtE;;;;;GAKG;AACH,wBAAgB,qCAAqC,CACnD,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,kBAAkB,GAAG,IAAI,CAiB3B"}

package/dist/delivery/delivery-artifacts.js

@@ -0,0 +1,56 @@
+/**
+ * Derive delivery completion_artifacts deterministically from git, so the
+ * daemon close path populates the same shape the drift evaluator consumes
+ * without asking a human to type file paths.
+ *
+ * The diff is computed in the focus worktree against the integration branch,
+ * mirroring the base-ref policy used by the `git.diff_against_base` assembly
+ * resolver. Per-delivery branch isolation is not available -- focuses share a
+ * single worktree -- so the resulting set is the focus's full diff. That is
+ * coarser than per-delivery but still useful: every artifact returned is a
+ * real file the work touched, which is what drift detection needs.
+ *
+ * Path shape matches `drift-evaluator.ts` expectations:
+ *   - repo-relative (git diff --name-only already does this)
+ *   - forward slashes (POSIX)
+ *   - no leading slash, no `./`
+ */
+import { resolveDeliveryDiffRange, getChangedFilesRange, } from '../resolvers/shared/git-diff.js';
+function normalizePath(p) {
+    let out = p.trim();
+    if (!out)
+        return '';
+    // git diff --name-only on Windows may emit backslashes; normalize.
+    out = out.replace(/\\/g, '/');
+    if (out.startsWith('./'))
+        out = out.slice(2);
+    while (out.startsWith('/'))
+        out = out.slice(1);
+    return out;
+}
+/**
+ * Return the list of repo-relative paths changed in the worktree vs. the
+ * base branch, or null when no diff is available (no worktree, empty diff,
+ * git failure). Callers treat the result as best-effort: null means
+ * "couldn't derive, leave completion_artifacts as-is".
+ */
+export function deriveCompletionArtifactsFromWorktree(worktreePath, baseBranch) {
+    // Merge-aware seam: resolve the range that contains the delivery's work
+    // (base...HEAD while ahead, else the recorded/searched merge range) so a
+    // focus branch that has already merged back still lists its changed files
+    // instead of an empty base...HEAD name-only diff.
+    const range = resolveDeliveryDiffRange(worktreePath, baseBranch);
+    if (!range)
+        return null;
+    const files = getChangedFilesRange(worktreePath, range);
+    const seen = new Set();
+    for (const line of files) {
+        const normalized = normalizePath(line);
+        if (normalized)
+            seen.add(normalized);
+    }
+    if (seen.size === 0)
+        return null;
+    return { files: Array.from(seen) };
+}
+//# sourceMappingURL=delivery-artifacts.js.map

package/dist/delivery/delivery-artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-artifacts.js","sourceRoot":"","sources":["../../src/delivery/delivery-artifacts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EACL,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,iCAAiC,CAAC;AAEzC,SAAS,aAAa,CAAC,CAAS;IAC9B,IAAI,GAAG,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;IACnB,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,CAAC;IACpB,mEAAmE;IACnE,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IAC9B,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC7C,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/C,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qCAAqC,CACnD,YAAoB,EACpB,UAAkB;IAElB,wEAAwE;IACxE,yEAAyE;IACzE,0EAA0E;IAC1E,kDAAkD;IAClD,MAAM,KAAK,GAAG,wBAAwB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;IACjE,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,MAAM,KAAK,GAAG,oBAAoB,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;IAExD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,UAAU;YAAE,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACjC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACrC,CAAC"}