@telora/daemon 0.22.245 → 0.22.289

package/dist/supervision/stop-rows-work-holds.js

@@ -0,0 +1,148 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/supervision/stop-registry.test.ts
+// PINNED-BY-END
+/**
+ * Stop-registry rows: the holds on a team's WORK outside the delivery gate_state
+ * holds (supervision/stop-rows-delivery.ts) -- a verify shortfall parked on an
+ * unchanged commit set, convergence held over an undisposed shortfall proposal,
+ * a daemon commit deferred while a verify runs in the worktree, a focus-branch
+ * merge held on ungated commits, an audit pass left unarmed over branch
+ * work the create gate cannot see, and an audit focus's ratify crossing held
+ * while it states no bar.
+ *
+ * Each row IS the decision its enforcing module acts on: the module asks
+ * supervision/stop-registry.ts evaluateStop for the verdict and decides nothing
+ * on its own.
+ *
+ * @module supervision/stop-rows-work-holds
+ */
+import { booleanStopRow } from './stop-row.js';
+export const WORK_HOLD_STOP_ROWS = {
+    shortfall_park: booleanStopRow({
+        id: 'shortfall_park',
+        kind: 'hold',
+        stopsOn: 'identical_shortfall_on_unchanged_commit_set',
+        enforcedBy: 'verify/shortfalls/shortfall-park.ts',
+        condition: 'The verify reconciliation judged the same shortfall SHORTFALL_PARK_REPEAT_LIMIT times on an unchanged ' +
+            '(or unknown) delivery commit set: re-judging the same commits cannot change the verdict.',
+        factsRead: [
+            'verificationHistory shortfall repeat record (signature, count, commit set)',
+            "the delivery's current commit-set fingerprint",
+            'SHORTFALL_PARK_REPEAT_LIMIT',
+        ],
+        effect: 'Parks the delivery in verify (a durable shortfallPark record in the verification history) instead of ' +
+            'sending it back to coding; one cause-keyed escalation names the parked nodes.',
+        releaser: 'Verify: a re-judgement on a CHANGED delivery commit set, a pass, or an operator ruling recorded since ' +
+            'the park (isShortfallParkReleased).',
+        releaseCondition: 'The commit set changed, a new ruling was recorded, or the verify passed.',
+        evaluate: ({ repeatCount, limit }) => repeatCount >= limit,
+        characterization: {
+            trigger: [{ repeatCount: 3, limit: 3 }, { repeatCount: 5, limit: 3 }],
+            release: [{ repeatCount: 2, limit: 3 }, { repeatCount: 1, limit: 3 }],
+        },
+    }),
+    shortfall_adjudication_hold: booleanStopRow({
+        id: 'shortfall_adjudication_hold',
+        kind: 'hold',
+        stopsOn: 'undisposed_shortfall_proposal',
+        enforcedBy: 'completion/review-exit-holds/review-exit-shortfall.ts',
+        condition: 'The focus carries an open (undisposed) shortfall drift proposal -- an unadjudicated contradiction ' +
+            'between declared intent and what was built -- or the proposals could not be read (fail-closed).',
+        factsRead: ['open shortfall drift proposals on the focus (listOpenShortfallProposalIds)'],
+        effect: 'No delivery on the focus converges to done: the review exit and the standing-approval convergence ' +
+            'withhold and write the hold onto gate_state (verify re-asserted, no transition).',
+        releaser: 'Whoever disposes of the proposal: ratified (the claim was wrong) or dismissed (defects filed).',
+        releaseCondition: 'The proposals were read and none is open.',
+        evaluate: ({ openShortfallProposals, readFailed }) => readFailed || openShortfallProposals > 0,
+        characterization: {
+            trigger: [
+                { openShortfallProposals: 1, readFailed: false },
+                { openShortfallProposals: 0, readFailed: true },
+            ],
+            release: [{ openShortfallProposals: 0, readFailed: false }],
+        },
+    }),
+    verify_interlock: booleanStopRow({
+        id: 'verify_interlock',
+        kind: 'hold',
+        stopsOn: 'worktree_mutation_during_verify',
+        enforcedBy: 'worktree/verify-interlock.ts',
+        condition: 'A daemon-authored worktree mutation (a safety / WIP / lockfile commit) would run while a verify ' +
+            'command holds the same worktree -- inside its mutation window, where it would stage transient ' +
+            'content (a torn write).',
+        factsRead: ['the in-memory per-worktree verify hold (acquireVerifyHold)'],
+        effect: 'The mutation is DEFERRED, not lost: it is retried on the next poll.',
+        releaser: 'The verify command finishing (its release function drops the hold); a daemon restart resets it.',
+        releaseCondition: 'No verify holds the worktree.',
+        evaluate: ({ worktreeUnderVerify }) => worktreeUnderVerify,
+        characterization: {
+            trigger: [{ worktreeUnderVerify: true }],
+            release: [{ worktreeUnderVerify: false }],
+        },
+    }),
+    merge_gate_coverage: booleanStopRow({
+        id: 'merge_gate_coverage',
+        kind: 'guard',
+        stopsOn: 'focus_merge_carries_ungated_commits',
+        enforcedBy: 'merge/merge-gate-coverage.ts',
+        condition: 'A focus-branch merge to integration would add a commit that no passing recorded verdict and no ' +
+            "current approval covers (clean integration-sync merges excepted), or the branch's gate coverage " +
+            'could not be read (fail-closed).',
+        factsRead: [
+            'integration..branch commits (git)',
+            'recorded deterministic verdicts per commit',
+            "the focus's newest current approval (focus_reviews / auto-approval record)",
+        ],
+        effect: 'The merge holds, logged with the reason; the branch stays unmerged.',
+        releaser: 'The verify gate passing on the ungated commits, or a review approving them.',
+        releaseCondition: 'Every commit the merge would add is gated, and the coverage was read.',
+        evaluate: ({ coverageReadable, ungatedCommits }) => !coverageReadable || ungatedCommits > 0,
+        characterization: {
+            trigger: [
+                { coverageReadable: true, ungatedCommits: 2 },
+                { coverageReadable: false, ungatedCommits: 0 },
+            ],
+            release: [{ coverageReadable: true, ungatedCommits: 0 }],
+        },
+    }),
+    unrecorded_branch_work_hold: booleanStopRow({
+        id: 'unrecorded_branch_work_hold',
+        kind: 'hold',
+        stopsOn: 'proved_branch_work_invisible_to_create_gate',
+        enforcedBy: 'audit/audit-phase.ts',
+        condition: "The review-coverage read PROVED committed delivery work on the focus branch whose own columns say it " +
+            'produced nothing, and the hand-off to the delivery-create residue gate failed, so the gate is blind to it.',
+        factsRead: ['AssemblySignals.unrecordedBranchWorkHold (set by the review-coverage resolver)'],
+        effect: 'No create-capable audit pass is armed this cycle.',
+        releaser: 'The evidence write landing (the next read records the ids), or a completed review covering the delivery.',
+        releaseCondition: 'The assembly proved no unrecordable branch work.',
+        evaluate: ({ provedWorkUnrecorded }) => provedWorkUnrecorded,
+        characterization: {
+            trigger: [{ provedWorkUnrecorded: true }],
+            release: [{ provedWorkUnrecorded: false }],
+        },
+    }),
+    ratify_bar_hold: booleanStopRow({
+        id: 'ratify_bar_hold',
+        kind: 'hold',
+        stopsOn: 'ratified_audit_focus_states_no_bar',
+        enforcedBy: 'focus-stage-lifecycle/ratify-bar-gate.ts',
+        condition: 'A ratified read_only (audit) focus is due to cross into execution (its held planning deliveries ' +
+            'released, read_only flipped false), but it states no bar -- a covered effect has no future stated -- ' +
+            'or whether it does could not be read (fail-closed).',
+        factsRead: ['readFocusStatesABar (prd/arm-readiness.ts): the injection bundle targets and their frt_statements'],
+        effect: 'Nothing is released and read_only stays true; the next poll asks again. A readable refusal is recorded ' +
+            'as the arm_refused debug artifact (no escalation).',
+        releaser: 'An agent or human writing the missing futures on the tree (frt_statements on every covered effect).',
+        releaseCondition: 'The bar was read and the focus states one.',
+        evaluate: ({ barReadable, statesABar }) => !(barReadable && statesABar),
+        characterization: {
+            trigger: [
+                { barReadable: true, statesABar: false },
+                { barReadable: false, statesABar: false },
+            ],
+            release: [{ barReadable: true, statesABar: true }],
+        },
+    }),
+};
+//# sourceMappingURL=stop-rows-work-holds.js.map

package/dist/supervision/stop-rows-work-holds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-rows-work-holds.js","sourceRoot":"","sources":["../../src/supervision/stop-rows-work-holds.ts"],"names":[],"mappings":"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"}

package/dist/supervision/team-stall-reapers.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The team-stall reapers as the per-focus cascade pass runs them, in one unit:
+ * take a reading of the one progress measure for the focus's live team
+ * (completion/team-progress/team-stillness.ts observeLiveTeamProgress), then run
+ * the two completion-event-independent recoveries in order -- the
+ * outcome backstop (the team_outcome_dead row: positive death
+ * evidence) and the stalled-team stop (the stalled_team row: stillness on the
+ * record, supervision/stalled-team-backstop.ts).
+ *
+ * One unit so the composition is testable as production composes it: the
+ * reading and the reapers' reader are the same module state, so a test that
+ * drives this unit with the production effects and only its side effects
+ * injected fails if the reading is dropped or a reaper stops reading the measure.
+ *
+ * The reapers DECIDE here; every act and effect-layer reading (taking the
+ * reading, reading it back, terminating the team, recording the firing) arrives
+ * through TeamStallReaperEffects, whose production wiring is
+ * composition/team-stall-reaper-effects.ts teamStallReaperEffects.
+ *
+ * @module supervision/team-stall-reapers
+ */
+import type { FocusDeliveryInfo } from '../types/index.js';
+import { type FocusStallContext } from './stall-detectors.js';
+import { type StalledTeamBackstopDeps, type StalledTeamBackstopEffects } from './stalled-team-backstop.js';
+/**
+ * Dependencies for the outcome-liveness backstop, all but the grace required.
+ * Production (composition/state-cascade-context.ts) reads the error-result clock, the ONE team-progress record (the
+ * same getLastProgressAt the stalled-team stop reads, supplied through the
+ * caller's effects); recovery reuses the same
+ * terminateTeam mechanism (and isTeamRecoverable gate) as the stalled-team
+ * stop, so a team is recovered at most once per shutdown.
+ */
+export interface TeamOutcomeStallDeps {
+    getErrorResultAt: (focusId: string) => number | null;
+    /** When the team last moved on the team-progress record (null = no readable reading). */
+    getLastProgressAt: (focusId: string) => number | null;
+    isTeamRecoverable: (focusId: string) => boolean;
+    recoverTeam: (focusId: string) => boolean;
+    now: () => number;
+    /** The announced-death grace (a value; TEAM_OUTCOME_STALL_GRACE_MS when absent). */
+    graceMs?: number;
+}
+/**
+ * Check ONE focus's tracked team against its session OUTCOME, and RECOVER it
+ * (terminate -> the daemon's normal release/merge-back/re-gate paths resume)
+ * when it announced its death past the grace -- the "better
+ * signal that can act in minutes", leaving the stalled_team row as the
+ * backstop for deaths this cannot see.
+ *
+ * Rides the per-focus cascade seam and files NO escalation: the ask -- recover the wedged team -- names an act the
+ * daemon performs itself. A genuinely working team is untouched (see
+ * isTeamOutcomeDead). Gated on isTeamRecoverable so a team already tearing down
+ * is not re-terminated each pass.
+ */
+export declare function checkTeamOutcomeStallForFocus(ctx: FocusStallContext, deps: TeamOutcomeStallDeps): void;
+/**
+ * The acts and effect-layer readings the two reapers run through (production:
+ * composition/team-stall-reaper-effects.ts teamStallReaperEffects):
+ * the stalled-team stop's effects -- the progress-measure reader and
+ * terminateTeam are shared by both reapers -- plus taking the reading itself.
+ */
+export interface TeamStallReaperEffects extends StalledTeamBackstopEffects {
+    /** Take a reading of the one progress measure for the focus's live team (the one writer). */
+    observeLiveTeamProgress: (focusId: string, deliveries: Pick<FocusDeliveryInfo, 'id' | 'executionStatus'>[]) => Promise<void>;
+}
+/**
+ * The two reapers' collaborators, whole: the reading, the outcome backstop's
+ * deps and the stalled-team stop's deps. Production composes them at the root
+ * (composition/state-cascade-context.ts buildTeamStallReapersDeps), sharing one
+ * progress reader and one terminateTeam between both reapers.
+ */
+export interface TeamStallReapersDeps {
+    observeLiveTeamProgress: TeamStallReaperEffects['observeLiveTeamProgress'];
+    outcome: TeamOutcomeStallDeps;
+    backstop: StalledTeamBackstopDeps;
+}
+/** Read the measure for the focus's live team, then run the two recoveries (module doc). */
+export declare function runTeamStallReapers(ctx: FocusStallContext, deliveries: Pick<FocusDeliveryInfo, 'id' | 'executionStatus'>[], deps: TeamStallReapersDeps): Promise<void>;
+//# sourceMappingURL=team-stall-reapers.d.ts.map

package/dist/supervision/team-stall-reapers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-stall-reapers.d.ts","sourceRoot":"","sources":["../../src/supervision/team-stall-reapers.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAChC,MAAM,4BAA4B,CAAC;AAOpC;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACrD,yFAAyF;IACzF,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IACtD,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAChD,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAC3C,GAAG,EAAE,iBAAiB,EACtB,IAAI,EAAE,oBAAoB,GACzB,IAAI,CA0BN;AAID;;;;;GAKG;AACH,MAAM,WAAW,sBAAuB,SAAQ,0BAA0B;IACxE,6FAA6F;IAC7F,uBAAuB,EAAE,CACvB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,iBAAiB,CAAC,EAAE,KAC5D,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,uBAAuB,EAAE,sBAAsB,CAAC,yBAAyB,CAAC,CAAC;IAC3E,OAAO,EAAE,oBAAoB,CAAC;IAC9B,QAAQ,EAAE,uBAAuB,CAAC;CACnC;AAED,4FAA4F;AAC5F,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,iBAAiB,EACtB,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,iBAAiB,CAAC,EAAE,EAC/D,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/supervision/team-stall-reapers.js

@@ -0,0 +1,53 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/supervision/team-outcome-stall-detector.test.ts,
+//   packages/daemon/src/supervision/team-stall-reapers.test.ts
+// PINNED-BY-END
+import { isTeamOutcomeDead, TEAM_OUTCOME_STALL_GRACE_MS, } from './stall-detectors.js';
+import { checkStalledTeamBackstopForFocus, } from './stalled-team-backstop.js';
+import { createLogger } from '../log/daemon-log.js';
+const log = createLogger({ module: 'stall-detectors' });
+/**
+ * Check ONE focus's tracked team against its session OUTCOME, and RECOVER it
+ * (terminate -> the daemon's normal release/merge-back/re-gate paths resume)
+ * when it announced its death past the grace -- the "better
+ * signal that can act in minutes", leaving the stalled_team row as the
+ * backstop for deaths this cannot see.
+ *
+ * Rides the per-focus cascade seam and files NO escalation: the ask -- recover the wedged team -- names an act the
+ * daemon performs itself. A genuinely working team is untouched (see
+ * isTeamOutcomeDead). Gated on isTeamRecoverable so a team already tearing down
+ * is not re-terminated each pass.
+ */
+export function checkTeamOutcomeStallForFocus(ctx, deps) {
+    if (!deps.isTeamRecoverable(ctx.focusId))
+        return;
+    const graceMs = deps.graceMs ?? TEAM_OUTCOME_STALL_GRACE_MS;
+    const nowMs = deps.now();
+    const errorResultAt = deps.getErrorResultAt(ctx.focusId);
+    const lastProgressMs = deps.getLastProgressAt(ctx.focusId);
+    if (!isTeamOutcomeDead({ errorResultAt, lastProgressMs, nowMs, graceMs }))
+        return;
+    const reason = 'terminal-error result with no progress since (announced death; pid may still be alive)';
+    const recovered = deps.recoverTeam(ctx.focusId);
+    if (recovered) {
+        log.warn(`[stall-detectors] Recovered outcome-dead team for focus "${ctx.focusName}" ` +
+            `(${reason}): terminated so slot release, merge-back, and delivery re-gating ` +
+            `resume in minutes -- no 3h wait, no operator kill.`);
+    }
+    else {
+        log.warn(`[stall-detectors] outcome-dead: focus "${ctx.focusName}" is outcome-dead but ` +
+            `terminateTeam found no live team to recover (already torn down?).`);
+    }
+}
+/** Read the measure for the focus's live team, then run the two recoveries (module doc). */
+export async function runTeamStallReapers(ctx, deliveries, deps) {
+    // The reading comes first: both reapers below judge stillness by it.
+    await deps.observeLiveTeamProgress(ctx.focusId, deliveries);
+    // Outcome backstop -> recover a tracked team that announced its death (an
+    // error result, no progress since), in minutes. No escalation.
+    checkTeamOutcomeStallForFocus(ctx, deps.outcome);
+    // Stalled-team stop -> the stalled_team row's one action (reap and file one
+    // team_failure, reap, or observe).
+    await checkStalledTeamBackstopForFocus(ctx, deps.backstop);
+}
+//# sourceMappingURL=team-stall-reapers.js.map

package/dist/supervision/team-stall-reapers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-stall-reapers.js","sourceRoot":"","sources":["../../src/supervision/team-stall-reapers.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,kFAAkF;AAClF,+DAA+D;AAC/D,gBAAgB;AAyBhB,OAAO,EACL,iBAAiB,EACjB,2BAA2B,GAE5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,gCAAgC,GAGjC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;AAuBxD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAC3C,GAAsB,EACtB,IAA0B;IAE1B,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC;QAAE,OAAO;IAEjD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,2BAA2B,CAAC;IAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAEzB,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACzD,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAE3D,IAAI,CAAC,iBAAiB,CAAC,EAAE,aAAa,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAAE,OAAO;IAElF,MAAM,MAAM,GAAG,wFAAwF,CAAC;IAExG,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAChD,IAAI,SAAS,EAAE,CAAC;QACd,GAAG,CAAC,IAAI,CACN,4DAA4D,GAAG,CAAC,SAAS,IAAI;YAC7E,IAAI,MAAM,oEAAoE;YAC9E,oDAAoD,CACrD,CAAC;IACJ,CAAC;SAAM,CAAC;QACN,GAAG,CAAC,IAAI,CACN,0CAA0C,GAAG,CAAC,SAAS,wBAAwB;YAC/E,mEAAmE,CACpE,CAAC;IACJ,CAAC;AACH,CAAC;AA8BD,4FAA4F;AAC5F,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,GAAsB,EACtB,UAA+D,EAC/D,IAA0B;IAE1B,qEAAqE;IACrE,MAAM,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IAC5D,0EAA0E;IAC1E,+DAA+D;IAC/D,6BAA6B,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACjD,4EAA4E;IAC5E,mCAAmC;IACnC,MAAM,gCAAgC,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC7D,CAAC"}

package/dist/supervision/team-work.d.ts

@@ -0,0 +1,145 @@
+import { type ArmFacts } from './recorded-new-intent.js';
+/** The delivery slice the team-work fact reads (structural). */
+export interface HoldWorkDelivery {
+    id: string;
+    executionStatus?: string | null;
+}
+/**
+ * The issue slice the team-work fact reads (structural). `issueType` absent
+ * reads as a work issue: only a row that says it is a Context Group is excluded.
+ */
+export interface HoldWorkIssue {
+    deliveryId: string;
+    status: string;
+    issueType?: string;
+}
+/** The focus-side facts {@link deliveriesWithTeamWork} is decided with. */
+export interface TeamWorkOptions {
+    /**
+     * The live arm's facts. A delivery RECORDED as new intent under it
+     * (supervision/recorded-new-intent.ts) is not work this arm owes. Absent => nothing
+     * is excluded (fail closed: the work counts).
+     */
+    armFacts?: ArmFacts | null;
+    /**
+     * Whether a `planning` delivery is work to scope. False on an audit-phase
+     * focus, where planning awaits ratification rather than the team.
+     */
+    planningIsWork: boolean;
+    /**
+     * Whether an agent-actionable delivery with NO work issue at all is work to
+     * scope. Only the spawn gate sets it (focus/ready-focus-team-work.ts): a
+     * spawn is how a queued, un-scoped delivery gets its issues. A delivery whose
+     * work issues are all Done still holds none.
+     */
+    unscopedIsWork?: boolean;
+    /** Deliveries withheld from the fact (the ones an in-flight verify is judging). */
+    excludeDeliveryIds?: ReadonlySet<string>;
+}
+/**
+ * THE definition of "this delivery holds team work", and so of "this focus has
+ * team work": an OPEN work issue (OPEN_ISSUE_STATUSES; a Context Group is
+ * reference material, never work) on an arm-visible agent-actionable delivery
+ * (queued / coding / verify_failed), or a `planning` delivery to scope where
+ * planning is the team's to scope.
+ *
+ * STATUS ALONE IS NOT WORK. A coding delivery whose every work issue is Done is
+ * waiting on the daemon's coding->verify advance, not on the team; counting it
+ * woke a finished lead with "still agent-actionable" turns naming nothing it
+ * could do, and it escalated to a human for a status the daemon owns (Tinker
+ * Tailor, 2026-09-25). The continuation stamp (spawn/idle-work-stamp.ts), the
+ * re-engagement listing (prompt/focus-prompt-builder.ts), the team-exit facts
+ * (completion/team-outcome/work-facts.ts, completion/team-outcome/apply-turn.ts) and the spawn
+ * gate's outside-the-hold fact ({@link hasTeamWorkOutsideVerify}) and the
+ * ready-focus spawn gate (focus/ready-focus-team-work.ts) all read it,
+ * so none of them can call a focus busy that another calls finished.
+ *
+ * Returns the deliveries in input order.
+ */
+export declare function deliveriesWithTeamWork<T extends HoldWorkDelivery>(deliveries: readonly T[], issues: readonly HoldWorkIssue[], opts: TeamWorkOptions): T[];
+/** Whether any delivery of the focus holds team work ({@link deliveriesWithTeamWork}). */
+export declare function focusHasTeamWork(deliveries: readonly HoldWorkDelivery[], issues: readonly HoldWorkIssue[], opts: TeamWorkOptions): boolean;
+/**
+ * Whether a delivery OUTSIDE the verified set carries open work a coding team
+ * could act on: {@link focusHasTeamWork} with the held deliveries withheld and
+ * planning not counted (the spawn gate's question is whether the hold starves
+ * a sibling's open work, not whether scoping is pending).
+ *
+ * A coding delivery whose advance the hold defers has every issue terminal (that
+ * is why it is advancing), so it contributes nothing -- the 2026-09-06 storm
+ * shape stays "no actionable work".
+ */
+export declare function hasTeamWorkOutsideVerify(input: {
+    deliveries: readonly HoldWorkDelivery[];
+    issues: readonly HoldWorkIssue[];
+    heldDeliveryIds: ReadonlySet<string>;
+}): boolean;
+/** Facts the actionable-work question is decided from. */
+export interface TeamActionableWorkInput {
+    /**
+     * Whether the focus has work a coding team could act on IF nothing were
+     * holding it -- a non-terminal delivery to advance or scope. At the spawn gate
+     * this is true by construction (getReadyFocuses only surfaces focuses with
+     * queued/coding deliveries, or none to scope); at the team-exit it is the live
+     * "the team owns open actionable work" fact (hasPlanning || postHasActionableOpen).
+     */
+    hasUnheldActionableWork: boolean;
+    /**
+     * Whether a verify command is currently running for a delivery of this focus
+     * (focusUnderVerifyHold). While held, the daemon is deferring this focus's
+     * advance.
+     */
+    underVerifyHold: boolean;
+    /**
+     * Under a hold: whether a delivery OUTSIDE the verified set still carries open
+     * work ({@link hasTeamWorkOutsideVerify}). Absent reads as false -- a caller
+     * that cannot see sibling work keeps the storm-safe "held = no work" verdict.
+     * Ignored when there is no hold.
+     */
+    workOutsideVerifyHold?: boolean;
+    /**
+     * Whether the daemon has sent THIS team a merge-conflict resolution request it
+     * has not yet answered (teamState.resolvingMergeConflict, set in
+     * merge/focus-merge.ts requestTeamLeadResolution). An outstanding resolution is
+     * itself team-actionable work: the team is mid-resolution, and the exit path
+     * must not tear it down -- doing so strands the conflict markers in the worktree
+     * and forces a respawn + fallback agent to clean up the mess the daemon made
+     * (delivery 61ee33eb, the 2026-09-07 incident). Absent (falsy) for every caller
+     * that is not the completion team-exit decision.
+     */
+    mergeResolutionOutstanding?: boolean;
+    /**
+     * Whether this focus's branch holds a migration file with no claim behind it
+     * that the team has NOT YET BEEN SHOWN (`focus_debug_artifacts` kind
+     * `unclaimed_migration`, with no `Named to the team at:` line). Like an
+     * outstanding merge resolution, it is actionable work: the number that file
+     * carries is one no claim knows about, so the next team to claim can be
+     * granted it, and the team that wrote it is the only one that can claim or
+     * remove it. Torn down first, it lands on integration with nobody told.
+     *
+     * ONE TURN, NOT UNTIL COMPLIANCE. The marker is written the moment the record
+     * is composed into a spawn prompt, so this is true for exactly one coding
+     * turn per newly-named ordinal. Holding until the team complied would be a
+     * wedge: the record clears only on a claim or a removal, neither of which the
+     * daemon can perform.
+     *
+     * Absent (falsy) for every caller that does not read the record.
+     */
+    unclaimedMigrationUnnamed?: boolean;
+}
+/**
+ * The one predicate. An outstanding merge-conflict resolution request the daemon
+ * sent this team IS actionable work regardless of delivery state -- it takes
+ * precedence so a team finishing its last delivery is never torn down mid-merge.
+ * Otherwise, under a verify hold the focus is actionable only when work exists
+ * OUTSIDE the delivery being verified (never more than the caller's own fact);
+ * with no hold, the caller's own actionable-work fact stands. Pure, so every
+ * controller reads the identical answer for a given state.
+ */
+export declare function focusHasTeamActionableWork(input: TeamActionableWorkInput): boolean;
+/** The hold facts a spawn-producing controller feeds the shared predicate. */
+export interface VerifyHoldFacts {
+    underVerifyHold: boolean;
+    workOutsideVerifyHold: boolean;
+}
+//# sourceMappingURL=team-work.d.ts.map

package/dist/supervision/team-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-work.d.ts","sourceRoot":"","sources":["../../src/supervision/team-work.ts"],"names":[],"mappings":"AAqDA,OAAO,EAAuB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAE9E,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC3B;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mFAAmF;IACnF,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,gBAAgB,EAC/D,UAAU,EAAE,SAAS,CAAC,EAAE,EACxB,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,IAAI,EAAE,eAAe,GACpB,CAAC,EAAE,CAeL;AAED,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,SAAS,gBAAgB,EAAE,EACvC,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,IAAI,EAAE,eAAe,GACpB,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAC;IACjC,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACtC,GAAG,OAAO,CAKV;AAED,0DAA0D;AAC1D,MAAM,WAAW,uBAAuB;IACtC;;;;;;OAMG;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;;;;;;;;OASG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAKlF;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;CAChC"}

package/dist/supervision/team-work.js

@@ -0,0 +1,129 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/worktree/verify-hold-facts.test.ts
+// PINNED-BY-END
+/**
+ * The single definition of "is there team-actionable work for this focus right
+ * now?", read by every controller that can spawn, hold, or exit a team so they
+ * cannot disagree about the same focus state:
+ *   - the spawn gate            (focus/focus-spawn-decision.ts decideFocusSpawn +
+ *                                focus/focus-poller-spawn.ts processPendingSpawnFocuses)
+ *   - the team-exit decision    (completion/team-outcome/work-facts.ts, buildTeamWorkFacts)
+ *   - the directive executor's spawn-producing paths
+ *                               (directive/directive-verify-hold-gate.ts, consumed
+ *                                by executeInjectDirective's no-team fallback and
+ *                                executeSpawnDirective in spawn/directive-dispatch.ts)
+ *   - the drain/idle gate       (update/auto-update-idle.ts isBatchSafeIdle, wired in
+ *                                shell/unified-shell.ts via anyFocusUnderVerifyHold --
+ *                                never restart the daemon while a verify is in flight)
+ *   - the continuation stamp    (spawn/idle-work-stamp.ts, and the listing it sends:
+ *                                prompt/focus-prompt-builder.ts buildReEngagementMessage)
+ *                                -- through deliveriesWithTeamWork, the per-delivery
+ *                                "holds team work" fact every site above counts
+ *
+ * That set is the WHOLE converged surface: no other module re-derives the
+ * held-vs-unheld actionable-work verdict from delivery state. (spawn-decision.ts
+ * findActionableDeliveries answers a different question -- WHICH deliveries a
+ * focus already cleared to spawn should hand its team -- and is downstream of
+ * this gate, not a peer of it.)
+ *
+ * Why one predicate: with ONE predicate that accounts for the verify hold (whose
+ * facts are read by worktree/verify-hold-facts.ts), a held focus is never
+ * reported ready in the first place: no spawn, no no-op cycle to bound, nothing
+ * billed. Pure: the hold facts are handed in, never read here.
+ *
+ * Why the hold is DELIVERY-scoped: the hold is keyed on the focus worktree, which
+ * every delivery of the focus shares, but "held = nothing to do" is only true of
+ * the delivery the verify is JUDGING (and a delivery whose advance it defers,
+ * which has no open work by construction). Reading the worktree hold as "the
+ * whole focus has nothing to do" would starve a sibling delivery holding an open
+ * Bug -- the very defect failing every verify -- so the team that would fix the
+ * red would be torn down and never respawned. So under a hold a
+ * focus is actionable iff a delivery OUTSIDE the verified set still carries open
+ * work ({@link hasTeamWorkOutsideVerify}); the storm shape (the verified delivery
+ * is the only non-terminal work) still reads as no actionable work.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (worktree/verify-hold-facts.ts).
+ *
+ * @module supervision/team-work
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { isStatusAgentActionable } from '../workflow/stage-classifier.js';
+import { OPEN_ISSUE_STATUSES, CONTEXT_GROUP_TYPE } from '../types/issue-status.js';
+import { isRecordedNewIntent } from './recorded-new-intent.js';
+/**
+ * THE definition of "this delivery holds team work", and so of "this focus has
+ * team work": an OPEN work issue (OPEN_ISSUE_STATUSES; a Context Group is
+ * reference material, never work) on an arm-visible agent-actionable delivery
+ * (queued / coding / verify_failed), or a `planning` delivery to scope where
+ * planning is the team's to scope.
+ *
+ * STATUS ALONE IS NOT WORK. A coding delivery whose every work issue is Done is
+ * waiting on the daemon's coding->verify advance, not on the team; counting it
+ * woke a finished lead with "still agent-actionable" turns naming nothing it
+ * could do, and it escalated to a human for a status the daemon owns (Tinker
+ * Tailor, 2026-09-25). The continuation stamp (spawn/idle-work-stamp.ts), the
+ * re-engagement listing (prompt/focus-prompt-builder.ts), the team-exit facts
+ * (completion/team-outcome/work-facts.ts, completion/team-outcome/apply-turn.ts) and the spawn
+ * gate's outside-the-hold fact ({@link hasTeamWorkOutsideVerify}) and the
+ * ready-focus spawn gate (focus/ready-focus-team-work.ts) all read it,
+ * so none of them can call a focus busy that another calls finished.
+ *
+ * Returns the deliveries in input order.
+ */
+export function deliveriesWithTeamWork(deliveries, issues, opts) {
+    const workIssues = issues.filter((i) => i.issueType !== CONTEXT_GROUP_TYPE);
+    const openWorkDeliveryIds = new Set(workIssues.filter((i) => OPEN_ISSUE_STATUSES.has(i.status)).map((i) => i.deliveryId));
+    const scopedDeliveryIds = new Set(workIssues.map((i) => i.deliveryId));
+    return deliveries.filter((d) => {
+        if (opts.excludeDeliveryIds?.has(d.id))
+            return false;
+        // Recorded new intent waits for the NEXT arm (supervision/recorded-new-intent.ts).
+        if (isRecordedNewIntent({ id: d.id, executionStatus: d.executionStatus ?? null }, opts.armFacts))
+            return false;
+        const status = d.executionStatus ?? '';
+        if (status === DELIVERY_STATUS.PLANNING)
+            return opts.planningIsWork;
+        if (!isStatusAgentActionable(status))
+            return false;
+        return openWorkDeliveryIds.has(d.id) || (opts.unscopedIsWork === true && !scopedDeliveryIds.has(d.id));
+    });
+}
+/** Whether any delivery of the focus holds team work ({@link deliveriesWithTeamWork}). */
+export function focusHasTeamWork(deliveries, issues, opts) {
+    return deliveriesWithTeamWork(deliveries, issues, opts).length > 0;
+}
+/**
+ * Whether a delivery OUTSIDE the verified set carries open work a coding team
+ * could act on: {@link focusHasTeamWork} with the held deliveries withheld and
+ * planning not counted (the spawn gate's question is whether the hold starves
+ * a sibling's open work, not whether scoping is pending).
+ *
+ * A coding delivery whose advance the hold defers has every issue terminal (that
+ * is why it is advancing), so it contributes nothing -- the 2026-09-06 storm
+ * shape stays "no actionable work".
+ */
+export function hasTeamWorkOutsideVerify(input) {
+    return focusHasTeamWork(input.deliveries, input.issues, {
+        planningIsWork: false,
+        excludeDeliveryIds: input.heldDeliveryIds,
+    });
+}
+/**
+ * The one predicate. An outstanding merge-conflict resolution request the daemon
+ * sent this team IS actionable work regardless of delivery state -- it takes
+ * precedence so a team finishing its last delivery is never torn down mid-merge.
+ * Otherwise, under a verify hold the focus is actionable only when work exists
+ * OUTSIDE the delivery being verified (never more than the caller's own fact);
+ * with no hold, the caller's own actionable-work fact stands. Pure, so every
+ * controller reads the identical answer for a given state.
+ */
+export function focusHasTeamActionableWork(input) {
+    if (input.mergeResolutionOutstanding)
+        return true;
+    if (input.unclaimedMigrationUnnamed)
+        return true;
+    if (input.underVerifyHold)
+        return input.hasUnheldActionableWork && input.workOutsideVerifyHold === true;
+    return input.hasUnheldActionableWork;
+}
+//# sourceMappingURL=team-work.js.map

package/dist/supervision/team-work.js.map

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