@telora/daemon 0.22.189 → 0.22.226

package/dist/completion/team-stillness.js

@@ -0,0 +1,96 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/verify/stall-detectors-clock-wiring.test.ts,
+//   packages/daemon/src/verify/team-stall-reapers.test.ts
+// PINNED-BY-END
+import { getFocusWorktree } from '../focus/focus-worktree-state.js';
+import { getActiveTeams, getTeamLastActivityAt } from '../focus/focus-team-state.js';
+import { getFocusIssues } from '../queries/focuses.js';
+import { readWorktreeHeadSha } from '../git/index.js';
+import { takeDeliveryAdvancementSnapshot } from './delivery-advancement-guard.js';
+import { readTeamActivityMarks, teamProgressMoved } from './team-progress-measure.js';
+const observations = new Map();
+/**
+ * The measure's axes for a focus now, read from its registered worktree. HEAD
+ * and the diff are required when a worktree is registered: either unreadable
+ * makes the reading unreadable.
+ */
+export function readFocusProgress(focusId, deliveries, issues) {
+    const worktreePath = getFocusWorktree(focusId)?.worktreePath ?? null;
+    const head = worktreePath ? readWorktreeHeadSha(worktreePath) : null;
+    const activity = readTeamActivityMarks(focusId, worktreePath);
+    return {
+        axes: takeDeliveryAdvancementSnapshot(deliveries, issues, head, activity),
+        readable: worktreePath === null || (head !== null && activity.worktreeDiffFingerprint !== null),
+    };
+}
+/**
+ * Record a reading of the measure for a focus. A readable reading stamps
+ * `nowMs` as the last movement when it is the first, the first after an
+ * unreadable one (a fresh window), or when any axis moved since the last
+ * readable one. An unreadable reading changes no movement
+ * instant; it only marks the latest reading unreadable.
+ */
+export function observeTeamProgress(focusId, reading, nowMs) {
+    const prior = observations.get(focusId);
+    if (!reading.readable) {
+        if (prior)
+            prior.readable = false;
+        else
+            observations.set(focusId, { axes: reading.axes, movedAt: nowMs, readable: false });
+        return;
+    }
+    // A reading after an unreadable one is a fresh baseline: the blind interval
+    // proved nothing, so it must not count toward a stall window (TEL-8).
+    const movedAt = !prior || !prior.readable || teamProgressMoved(prior.axes, reading.axes) ? nowMs : prior.movedAt;
+    observations.set(focusId, { axes: reading.axes, movedAt, readable: true });
+}
+/**
+ * When the team last showed progress by the ONE measure, for the reapers.
+ * Null -- never stalled -- while the team has produced no event yet, before its
+ * first reading, or while its latest reading was unreadable.
+ */
+export function readTeamLastProgressAt(focusId) {
+    if (getTeamLastActivityAt(focusId) === null)
+        return null;
+    const observation = observations.get(focusId);
+    if (!observation || !observation.readable)
+        return null;
+    return observation.movedAt;
+}
+const defaultObserveDeps = {
+    isTeamLive: (focusId) => getActiveTeams().has(focusId),
+    getFocusIssues,
+    readProgress: readFocusProgress,
+    now: () => Date.now(),
+};
+/**
+ * The cascade pass's reading (the ONE writer): for a focus with a live team,
+ * read the measure's axes and record them; for a focus without one, forget its
+ * readings. An unreadable issue list is an unreadable reading (fail closed).
+ */
+export async function observeLiveTeamProgress(focusId, deliveries, deps = {}) {
+    const d = { ...defaultObserveDeps, ...deps };
+    if (!d.isTeamLive(focusId)) {
+        forgetTeamProgress(focusId);
+        return;
+    }
+    let issues;
+    try {
+        issues = await d.getFocusIssues(focusId);
+    }
+    catch {
+        const prior = observations.get(focusId);
+        observeTeamProgress(focusId, { axes: prior?.axes ?? { deliveryStatuses: {}, focusHeadSha: null }, readable: false }, d.now());
+        return;
+    }
+    observeTeamProgress(focusId, d.readProgress(focusId, deliveries, issues), d.now());
+}
+/** Forget a focus's readings (its team is gone; the next team starts a new baseline). */
+export function forgetTeamProgress(focusId) {
+    observations.delete(focusId);
+}
+/** Test-only: forget every focus. */
+export function __resetTeamStillnessForTesting() {
+    observations.clear();
+}
+//# sourceMappingURL=team-stillness.js.map

package/dist/completion/team-stillness.js.map

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

package/dist/completion/unclaimed-migration-notice-phase.d.ts

@@ -0,0 +1,97 @@
+import type { Writable } from 'node:stream';
+import type { CompletionEventPhaseState, CompletionEventPhaseOutcome } from './event.js';
+/**
+ * What a delivery attempt can produce.
+ *
+ * `no_live_team` is separated from `write_failed` on purpose. Keeping a team
+ * alive so the next event can retry only makes sense when there IS a team: a
+ * focus whose lead is already gone emits no further event, so holding it would
+ * park the teardown for the full ten minutes of the hold and change nothing.
+ * The record is not lost in that case -- it stays unnamed, and the NEXT spawn
+ * of this focus carries it in the prompt. Two carriers, one record.
+ */
+export type NoticeDelivery = 'delivered' | 'write_failed' | 'no_live_team';
+/** The seams: the record's reader and marker, and the write to the team. */
+export interface UnclaimedNoticeDeps {
+    readRecord: (focusId: string) => Promise<string | null>;
+    markNamed: (focusId: string, namedAt: string) => Promise<void>;
+    deliver: (state: CompletionEventPhaseState, message: string) => NoticeDelivery;
+    now: () => string;
+}
+/**
+ * How long to wait before re-driving after a transient failure.
+ *
+ * A kept team is PARKED: a lead only emits a completion event in response to a
+ * wake, so a keep with no stimulus behind it waits for the hold bound to expire
+ * and then tears the team down having told it nothing -- the failure this phase
+ * exists to prevent, arriving by a slower route. The re-drive supplies the
+ * event. It is bounded from above by the hold itself
+ * (UNCLAIMED_MIGRATION_NOTICE_MAX_MS), so a persistently failing read retries
+ * about twenty times and then ends in teardown rather than forever.
+ */
+export declare const UNCLAIMED_NOTICE_RETRY_MS = 30000;
+/**
+ * Production: the real record queries, and a write to the live team's stdin.
+ *
+ * The two QUERIES here are a convenience for a caller that drives this phase
+ * directly with explicit deps; they are NOT how production reaches them. The
+ * completion event wires `readUnclaimedMigrationRecord` /
+ * `markUnclaimedMigrationNamed` on its own deps (`defaultDeps` in event.ts),
+ * and the phase runs only when a reader is actually wired -- see the gate in
+ * `runUnclaimedMigrationNoticePhase`. Falling back to a live API call whenever
+ * the dep happened to be absent is what made every caller of
+ * `handleCompletionEvent` an unwitting caller of this one.
+ *
+ * `deliver` is different and stays here: it needs the phase STATE (the live
+ * team's stdin), which a `(focusId, message)` event dep cannot carry.
+ */
+export declare const defaultUnclaimedNoticeDeps: UnclaimedNoticeDeps;
+/**
+ * Write the notice to a lead's stdin, and classify what that stream IS.
+ *
+ * A STREAM THAT HAS BEEN ENDED IS NOT A TRANSIENT FAILURE. The Codex backend
+ * declares `closeStdinAfterInput`, so `spawnTeamProcess` ends the lead's stdin
+ * the moment the kickoff message is written. From then on the stream is still
+ * an object and is NOT destroyed -- it is `writableEnded` -- so the old check
+ * (absent or destroyed) let it through, `sendMessage` returned false, and the
+ * phase read that as `write_failed`: keep the team, schedule a re-drive, try
+ * again. Every retry was a write-after-end on a stream that can never accept
+ * another byte, about twenty times over, until the hold bound expired into the
+ * teardown it had been holding back -- the team torn down having been told
+ * nothing, by the branch that exists to prevent exactly that.
+ *
+ * So an ended or non-writable stream answers `no_live_team`, which is the
+ * truthful answer: there is no carrier here, and no retry can make one. Nothing
+ * is marked, the record stays unnamed, and the next coding spawn carries it in
+ * its PROMPT -- which on Codex is the only carrier that ever existed, its
+ * kickoff message being the last thing that stream accepts.
+ */
+export declare function stdinDelivery(stdin: Writable | null | undefined, message: string): NoticeDelivery;
+/**
+ * The message a live team receives: the stored record, and what resolves it.
+ *
+ * `false` is not a default here, it is a fact: the phase returns before this is
+ * reached on a review session (see the guard in
+ * `runUnclaimedMigrationNoticePhase`), so the only team this ever composes for
+ * is a coding team.
+ */
+export declare function buildUnclaimedNoticeMessage(record: string): string;
+/**
+ * Phase: deliver the unclaimed-migration notice.
+ *
+ * Continues (changing nothing) when there is no record, when the record has
+ * already been delivered, or when delivery failed. Halts 'kept' only when a
+ * notice was actually written to a live team.
+ */
+export declare function runUnclaimedMigrationNoticePhase(state: CompletionEventPhaseState, 
+/**
+ * Explicit seams, for a caller driving this phase on its own. Omitted by the
+ * registry, which supplies them through the completion event's deps instead.
+ *
+ * `= undefined` rather than `?:` so the function's ARITY stays 1: the registry
+ * calls every phase as `run(state)`, and its structure test pins that shape
+ * (an adapter whose signature has grown a second parameter the registry never
+ * passes is how a seam goes quietly inert).
+ */
+noticeDeps?: UnclaimedNoticeDeps | undefined): Promise<CompletionEventPhaseOutcome>;
+//# sourceMappingURL=unclaimed-migration-notice-phase.d.ts.map

package/dist/completion/unclaimed-migration-notice-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unclaimed-migration-notice-phase.d.ts","sourceRoot":"","sources":["../../src/completion/unclaimed-migration-notice-phase.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAS5C,OAAO,KAAK,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAIzF;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,cAAc,GAAG,cAAc,CAAC;AAE3E,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACxD,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/D,OAAO,EAAE,CAAC,KAAK,EAAE,yBAAyB,EAAE,OAAO,EAAE,MAAM,KAAK,cAAc,CAAC;IAC/E,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAQxC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAIjG;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;GAMG;AACH,wBAAsB,gCAAgC,CACpD,KAAK,EAAE,yBAAyB;AAChC;;;;;;;;GAQG;AACH,UAAU,GAAE,mBAAmB,GAAG,SAAqB,GACtD,OAAO,CAAC,2BAA2B,CAAC,CAwEtC"}

package/dist/completion/unclaimed-migration-notice-phase.js

@@ -0,0 +1,270 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/unclaimed-migration-notice-phase.test.ts
+// PINNED-BY-END
+/**
+ * DELIVERING the unclaimed-migration notice to the team that can act on it,
+ * before anything tears that team down.
+ *
+ * WHAT WENT WRONG WITHOUT THIS PHASE. The record existed, the hold existed, and
+ * the team was still never told:
+ *
+ *   - `scope-coverage-terminate` runs BEFORE the decide phase, so a focus whose
+ *     deliveries are all verify/done/cancelled was terminated before anything
+ *     read the flag. That is the common ending, not an edge case.
+ *   - On the non-terminal path the flag produced a re-engagement, and the
+ *     re-engagement message carries deliveries and issues -- not this. The team
+ *     was woken and told nothing about the file.
+ *   - The spawn path marked the record NAMED while gathering section inputs,
+ *     before the session existed. A spawn that then failed lifted the hold with
+ *     nobody having read anything.
+ *
+ * A notice nobody reads is not a notice. The file lands on integration holding
+ * a number no claim knows about, and the team that wrote it is gone.
+ *
+ * SO THE PHASE RUNS EARLY AND DELIVERS ITSELF. It sits ahead of EVERY
+ * teardown-capable phase -- not merely the first one found. Sitting between
+ * `review-window-routing` and `scope-coverage-terminate` was not that: a coding
+ * lead with verify work and an open review window commonly has no open coding
+ * issues, and review-window-routing terminated it one line above. It writes the
+ * notice into the LIVE team's stdin and marks the record named ONLY after the
+ * write succeeds. A failed write marks nothing and schedules the event that
+ * retries -- retryable unnamed state rather than a lost notice.
+ *
+ * IT KEEPS THE TEAM FOR THAT TURN, and exactly that turn. Halting 'kept' is
+ * what stops the teardown below it from running in the same event; the marker
+ * then lets the next event fall straight through. The record clears only on a
+ * claim or a removal, neither of which the daemon can perform, so a hold that
+ * waited for compliance would never lift on its own.
+ *
+ * @module completion/unclaimed-migration-notice-phase
+ */
+import { sendMessage } from '@telora/daemon-core';
+import { scheduleDeferredReDrive } from './reengagement-redrive.js';
+import { createLogger } from '../shell/log.js';
+import { parseUnclaimedNamedAt, readUnclaimedMigrationRecordStrict, markUnclaimedMigrationNamed, } from '../queries/focus-unclaimed-migration.js';
+import { buildUnclaimedMigrationSection } from '../prompt-sections/unclaimed-migration-section.js';
+const log = createLogger({ module: 'unclaimed-migration-notice' });
+/**
+ * How long to wait before re-driving after a transient failure.
+ *
+ * A kept team is PARKED: a lead only emits a completion event in response to a
+ * wake, so a keep with no stimulus behind it waits for the hold bound to expire
+ * and then tears the team down having told it nothing -- the failure this phase
+ * exists to prevent, arriving by a slower route. The re-drive supplies the
+ * event. It is bounded from above by the hold itself
+ * (UNCLAIMED_MIGRATION_NOTICE_MAX_MS), so a persistently failing read retries
+ * about twenty times and then ends in teardown rather than forever.
+ */
+export const UNCLAIMED_NOTICE_RETRY_MS = 30_000;
+/**
+ * Production: the real record queries, and a write to the live team's stdin.
+ *
+ * The two QUERIES here are a convenience for a caller that drives this phase
+ * directly with explicit deps; they are NOT how production reaches them. The
+ * completion event wires `readUnclaimedMigrationRecord` /
+ * `markUnclaimedMigrationNamed` on its own deps (`defaultDeps` in event.ts),
+ * and the phase runs only when a reader is actually wired -- see the gate in
+ * `runUnclaimedMigrationNoticePhase`. Falling back to a live API call whenever
+ * the dep happened to be absent is what made every caller of
+ * `handleCompletionEvent` an unwitting caller of this one.
+ *
+ * `deliver` is different and stays here: it needs the phase STATE (the live
+ * team's stdin), which a `(focusId, message)` event dep cannot carry.
+ */
+export const defaultUnclaimedNoticeDeps = {
+    // The STRICT read: the lenient one swallows its own failure and returns
+    // null, which this phase would read as "nothing to tell" -- defeating the
+    // fail-closed handler below before it could ever run.
+    readRecord: (focusId) => readUnclaimedMigrationRecordStrict(focusId),
+    markNamed: (focusId, namedAt) => markUnclaimedMigrationNamed(focusId, namedAt),
+    deliver: (state, message) => stdinDelivery(state.ctx.proc?.stdin ?? null, message),
+    now: () => new Date().toISOString(),
+};
+/**
+ * Write the notice to a lead's stdin, and classify what that stream IS.
+ *
+ * A STREAM THAT HAS BEEN ENDED IS NOT A TRANSIENT FAILURE. The Codex backend
+ * declares `closeStdinAfterInput`, so `spawnTeamProcess` ends the lead's stdin
+ * the moment the kickoff message is written. From then on the stream is still
+ * an object and is NOT destroyed -- it is `writableEnded` -- so the old check
+ * (absent or destroyed) let it through, `sendMessage` returned false, and the
+ * phase read that as `write_failed`: keep the team, schedule a re-drive, try
+ * again. Every retry was a write-after-end on a stream that can never accept
+ * another byte, about twenty times over, until the hold bound expired into the
+ * teardown it had been holding back -- the team torn down having been told
+ * nothing, by the branch that exists to prevent exactly that.
+ *
+ * So an ended or non-writable stream answers `no_live_team`, which is the
+ * truthful answer: there is no carrier here, and no retry can make one. Nothing
+ * is marked, the record stays unnamed, and the next coding spawn carries it in
+ * its PROMPT -- which on Codex is the only carrier that ever existed, its
+ * kickoff message being the last thing that stream accepts.
+ */
+export function stdinDelivery(stdin, message) {
+    if (!stdin)
+        return 'no_live_team';
+    if (stdin.destroyed || stdin.writableEnded || !stdin.writable)
+        return 'no_live_team';
+    return sendMessage(stdin, message) ? 'delivered' : 'write_failed';
+}
+/**
+ * The message a live team receives: the stored record, and what resolves it.
+ *
+ * `false` is not a default here, it is a fact: the phase returns before this is
+ * reached on a review session (see the guard in
+ * `runUnclaimedMigrationNoticePhase`), so the only team this ever composes for
+ * is a coding team.
+ */
+export function buildUnclaimedNoticeMessage(record) {
+    return buildUnclaimedMigrationSection(record, false).join('\n');
+}
+/**
+ * Phase: deliver the unclaimed-migration notice.
+ *
+ * Continues (changing nothing) when there is no record, when the record has
+ * already been delivered, or when delivery failed. Halts 'kept' only when a
+ * notice was actually written to a live team.
+ */
+export async function runUnclaimedMigrationNoticePhase(state, 
+/**
+ * Explicit seams, for a caller driving this phase on its own. Omitted by the
+ * registry, which supplies them through the completion event's deps instead.
+ *
+ * `= undefined` rather than `?:` so the function's ARITY stays 1: the registry
+ * calls every phase as `run(state)`, and its structure test pins that shape
+ * (an adapter whose signature has grown a second parameter the registry never
+ * passes is how a seam goes quietly inert).
+ */
+noticeDeps = undefined) {
+    const { focusId, focusName } = state.ctx;
+    // A REVIEW PASS IS NOT THE PARTY THAT CAN ACT, so it is not told and the
+    // obligation is RETAINED.
+    //
+    // The file was written by a coding team, and the two things that resolve it
+    // -- claiming the number, or deleting the file -- are that team's to do. A
+    // reviewer can do neither. Delivering here would nonetheless CONSUME the
+    // record: the write succeeds against the review lead's stdin, the marker is
+    // written, and the next coding team -- the one party that could have fixed it
+    // -- reads a record already marked named and is told nothing. One notice,
+    // spent on the only session that cannot use it.
+    //
+    // Returning 'continue' rather than keeping: a review pass has its own routing
+    // and its own ending, and neither is this phase's business to hold.
+    if (state.ctx.teamState.sessionType === 'review') {
+        log.info(`[unclaimed-migration] "${focusName}": review pass -- the record is retained, unnamed, `
+            + 'for the coding team that can claim or remove the file');
+        return 'continue';
+    }
+    // The registry calls this as run(state), so the seams a test needs are taken
+    // from the event deps when present -- that is what lets the phase be driven
+    // through the REAL registry, which is the only place the ordering (notice
+    // before teardown) is observable.
+    const deps = resolveNoticeDeps(state, noticeDeps);
+    if (deps === null)
+        return 'continue';
+    let record;
+    try {
+        record = await deps.readRecord(focusId);
+    }
+    catch (err) {
+        // FAIL CLOSED on the read. An unreadable artifact is not evidence that
+        // there is nothing to tell, and the destructive reading of it -- "no
+        // record, carry on" -- is the one that ends with the file on integration.
+        // Keeping the team costs one turn and the next event asks again.
+        log.warn(`[unclaimed-migration] "${focusName}": record read failed `
+            + `(${String(err?.message ?? err)}) -- keeping the team rather than `
+            + 'reading a failed read as "nothing to tell"');
+        // The keep needs a stimulus behind it, or it is a park: schedule the event
+        // that will try the read again.
+        scheduleDeferredReDrive(state.ctx, state.deps, UNCLAIMED_NOTICE_RETRY_MS);
+        return { halt: 'kept' };
+    }
+    if (record === null || record.trim() === '')
+        return 'continue';
+    if (parseUnclaimedNamedAt(record) !== null)
+        return 'continue'; // already told
+    const delivery = deps.deliver(state, buildUnclaimedNoticeMessage(record));
+    if (delivery !== 'delivered')
+        return handleUndelivered(state, delivery);
+    // Marked ONLY after a successful write. Before it, a failed delivery would
+    // lift the hold with nobody having read anything -- which is the defect.
+    try {
+        await deps.markNamed(focusId, deps.now());
+    }
+    catch (err) {
+        // The team HAS the notice; only the marker failed to persist. That is the
+        // safe direction -- the next event re-delivers rather than skipping -- and
+        // it must not propagate: an exception here aborts the whole completion
+        // event, which is a far larger failure than telling a team twice.
+        log.warn(`[unclaimed-migration] "${focusName}": notice delivered but the marker did not `
+            + `persist (${String(err?.message ?? err)}) -- it will be delivered again`);
+    }
+    log.info(`[unclaimed-migration] "${focusName}": notice delivered to the team`);
+    return { halt: 'kept' };
+}
+/**
+ * What a delivery that did not land means for this event.
+ *
+ * The two outcomes are opposites and the difference is whether a retry could
+ * ever work: a stream that FAILED a write may accept the next one, and a stream
+ * that is gone or ended never will.
+ */
+function handleUndelivered(state, delivery) {
+    const { focusName } = state.ctx;
+    if (delivery === 'no_live_team') {
+        // Nobody to write to, and nothing a keep could achieve: a lead that is
+        // gone emits no further event, so the hold would simply expire. The record
+        // stays unnamed and the next SPAWN of this focus carries it in the prompt.
+        log.info(`[unclaimed-migration] "${focusName}": no live team to write to -- the record stays `
+            + 'unnamed and the next spawn carries it');
+        return 'continue';
+    }
+    // Nothing written, so nothing is marked: the record stays unnamed and the
+    // scheduled re-drive tries again. Not halting here would let the teardown
+    // below run on a focus nobody has been told about, so this holds too.
+    log.warn(`[unclaimed-migration] "${focusName}": could not write the notice to the team -- `
+        + 'record left unnamed, retrying');
+    scheduleDeferredReDrive(state.ctx, state.deps, UNCLAIMED_NOTICE_RETRY_MS);
+    return { halt: 'kept' };
+}
+/**
+ * The seams this run should use, or null when nobody wired a record reader.
+ *
+ * Precedence: an explicitly-passed seam wins (the caller is saying exactly what
+ * this run should do), then the completion event's deps, then the module
+ * defaults.
+ */
+function resolveNoticeDeps(state, noticeDeps) {
+    const eventDeps = state.deps ?? {};
+    // NO READER WIRED, NOTHING TO READ.
+    //
+    // This phase used to fall back to the real API query whenever its dep was
+    // absent. That made it run -- and, on an uninitialised client, take its
+    // fail-closed keep -- for every caller of `handleCompletionEvent`, twenty-odd
+    // suites of which construct a deps object to drive one unrelated decision and
+    // have no record to read at all. A phase that reaches for a live backend the
+    // caller never handed it is not fail-closed, it is uninvited.
+    //
+    // Production wires the reader on `defaultDeps` (event.ts), pinned there, so
+    // an absent reader HERE means the caller does not model the record.
+    if (!noticeDeps?.readRecord && !eventDeps.readUnclaimedMigrationRecord)
+        return null;
+    return {
+        ...defaultUnclaimedNoticeDeps,
+        ...(eventDeps.readUnclaimedMigrationRecord
+            ? { readRecord: eventDeps.readUnclaimedMigrationRecord }
+            : {}),
+        ...(eventDeps.markUnclaimedMigrationNamed
+            ? { markNamed: eventDeps.markUnclaimedMigrationNamed }
+            : {}),
+        ...(eventDeps.deliverUnclaimedMigrationNotice
+            ? {
+                deliver: (s, message) => eventDeps.deliverUnclaimedMigrationNotice(s.ctx.focusId, message),
+            }
+            : {}),
+        // An explicitly-passed seam wins over both: it is the caller saying exactly
+        // what this run should do.
+        ...noticeDeps,
+    };
+}
+//# sourceMappingURL=unclaimed-migration-notice-phase.js.map

package/dist/completion/unclaimed-migration-notice-phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unclaimed-migration-notice-phase.js","sourceRoot":"","sources":["../../src/completion/unclaimed-migration-notice-phase.ts"],"names":[],"mappings":"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"}

package/dist/completion/worker-wait.d.ts

@@ -0,0 +1,84 @@
+/**
+ * A lead waiting on its workers is left to wait.
+ *
+ * On 2026-09-24 ("A ruling reaches the gate it rules on") a lead handed its
+ * edits to background workers and ended its turn while they ran. The daemon
+ * re-woke it with a mid-focus handoff every ~20s; each wake returned in seconds
+ * and was counted as an empty completion cycle, until the team was killed as a
+ * team_failure with its workers still editing. The daemon's own pokes were the
+ * cycles.
+ *
+ * So while the team's workers are live (completion/team-progress-measure.ts
+ * teamWorkersLive: a started worker that has not ended and is still reporting),
+ * the daemon sends the lead no handoff, no re-engagement and no continuation
+ * turn. The lead is next woken by:
+ *   - its workers' completion -- the engine itself resumes the lead on a
+ *     worker's task notification, and that turn's result is an ordinary cycle;
+ *   - genuinely new work: a delivery the team has not been shown, or an issue
+ *     that appeared since the team was last handed its work;
+ *   - the normal handoff path once the workers go quiet (WORKER_QUIET_MS with no
+ *     event) -- a re-check is scheduled for exactly then.
+ * A lead whose workers have all finished is re-engaged as before, and a team
+ * with no events at all is still reaped by the stalled-team backstop.
+ *
+ * The wait is logged ONCE per park episode (teamState.waitingOnWorkersSince).
+ *
+ * @module completion/worker-wait
+ */
+import type { FocusDeliveryInfo, FocusIssueInfo, FocusTeamState } from '../types/index.js';
+type WaitState = Pick<FocusTeamState, 'waitingOnWorkersSince' | 'shownIssueIds'>;
+/**
+ * Record the issues the lead has now been handed (at every wake actually sent),
+ * so an issue that appears later is recognisably new.
+ */
+export declare function recordIssuesShown(teamState: WaitState, issues: Pick<FocusIssueInfo, 'id'>[]): void;
+/** True when an issue exists that the lead has not been handed (none, before any record). */
+export declare function hasUnshownIssue(teamState: WaitState, issues: Pick<FocusIssueInfo, 'id'>[]): boolean;
+/**
+ * Genuinely new work for a lead waiting on its workers: an agent-actionable
+ * delivery the team has never been told about, or an issue on a delivery the
+ * running arm owes that the lead has not been handed. Work RECORDED as new
+ * intent under the arm is invisible to the team and wakes nothing.
+ */
+export declare function hasUnshownWork(teamState: FocusTeamState, deliveries: FocusDeliveryInfo[], issues: Pick<FocusIssueInfo, 'id' | 'deliveryId'>[]): boolean;
+/**
+ * While the lead waits on live workers, what the waiting re-check does next:
+ * a number is "still waiting -- check again in that many ms" (no completion
+ * cycle, no wake); null is "re-drive the completion decision now", because the
+ * workers are done or quiet, or because work the lead has not been shown has
+ * ARRIVED -- that arrival is itself the trigger, not the next unrelated event.
+ */
+export declare function nextWorkerWaitCheck(args: {
+    teamState: FocusTeamState;
+    focusId: string;
+    quietInMs: number | null;
+    readWork: () => Promise<{
+        deliveries: FocusDeliveryInfo[];
+        issues: FocusIssueInfo[];
+    }>;
+}): Promise<number | null>;
+/**
+ * How often a waiting lead's focus is re-read for newly arrived work -- the
+ * daemon's own poll cadence, so new work reaches a waiting lead no later than
+ * it would reach an idle one.
+ */
+export declare const WORKER_WAIT_RECHECK_MS = 30000;
+/**
+ * Decide whether to HOLD a wake to the lead because its workers are live.
+ * Returns true to hold (send nothing). Logs once per park episode, and ends the
+ * episode (so the next one logs again) whenever a wake is let through.
+ */
+export declare function holdWakeForLiveWorkers(args: {
+    teamState: WaitState;
+    focusId: string;
+    focusName: string;
+    nowMs: number;
+    workersLive: boolean;
+    /** Genuinely new work the lead has not been shown (a delivery or an issue). */
+    hasUnshownWork: boolean;
+    issues: Pick<FocusIssueInfo, 'id'>[];
+    /** What the held wake would have been, for the log line. */
+    wakeKind: string;
+}): boolean;
+export {};
+//# sourceMappingURL=worker-wait.d.ts.map

package/dist/completion/worker-wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-wait.d.ts","sourceRoot":"","sources":["../../src/completion/worker-wait.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQ3F,KAAK,SAAS,GAAG,IAAI,CAAC,cAAc,EAAE,uBAAuB,GAAG,eAAe,CAAC,CAAC;AAEjF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,GAAG,IAAI,CAElG;AAED,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,GAAG,OAAO,CAGnG;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,cAAc,EACzB,UAAU,EAAE,iBAAiB,EAAE,EAC/B,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,YAAY,CAAC,EAAE,GAClD,OAAO,CAOT;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC9C,SAAS,EAAE,cAAc,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,OAAO,CAAC;QAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;QAAC,MAAM,EAAE,cAAc,EAAE,CAAA;KAAE,CAAC,CAAC;CACxF,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAWzB;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,+EAA+E;IAC/E,cAAc,EAAE,OAAO,CAAC;IACxB,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC;IACrC,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAuBV"}