@telora/daemon 0.22.239 → 0.22.289

package/dist/completion/completion-event/event.d.ts

@@ -0,0 +1,211 @@
+/**
+ * The LEAD-TURN-COMPLETE exit path -- reacts to CompletionDetector events.
+ *
+ * When a team lead completes a turn, handleCompletionEvent builds the turn's
+ * TeamOutcome and hands it to the one team-exit pipeline: decide()
+ * (completion/team-outcome/decide.ts, the turn-complete rows) returns the
+ * actions and the one applier (completion/team-outcome/apply.ts) performs them.
+ * This module owns the event's context and its deps; it decides
+ * nothing.
+ *
+ * Reader's guide: docs/daemon/team-exit-pipeline.md.
+ * History: docs/daemon/history-team-lifecycle.md (completion/completion-event/event.ts).
+ */
+import type { ChildProcess } from 'node:child_process';
+import type { DaemonConfig, FocusTeamState, FocusDeliveryInfo, FocusIssueInfo, Workflow, TeamActivityMarks } from '../../types/index.js';
+import type { CompletionDetector, CompletionInfo } from './detector.js';
+import type { CreateEscalationParams } from '../../supervision/escalation-filing.js';
+import type { ReconcileTerminatedWorkParams, ReconcileTerminatedWorkResult } from '../team-exit/terminated-work-reconcile.js';
+import { type TeamOutcome } from '../team-outcome/team-outcome.js';
+import type { NoticeDelivery } from './unclaimed-migration-notice.js';
+export interface CompletionEventContext {
+    config: DaemonConfig;
+    focusId: string;
+    focusName: string;
+    teamState: FocusTeamState;
+    completionDetector: CompletionDetector;
+    proc: ChildProcess;
+    completionInfo: CompletionInfo;
+}
+/**
+ * The completion event's collaborators. Required: production builds them once
+ * at the daemon composition root (`composition/completion-event-context.ts`)
+ * and the focus engine carries them here; a test names every one it runs
+ * against (testing/fixtures/completion-event-deps.ts builds an inert set).
+ */
+export interface CompletionEventDeps {
+    getFocusDeliveries: (focusId: string) => Promise<FocusDeliveryInfo[]>;
+    getFocusIssues: (focusId: string) => Promise<FocusIssueInfo[]>;
+    createEscalation: (params: CreateEscalationParams) => Promise<{
+        escalationId: string | null;
+    } | void>;
+    terminateTeam: (focusId: string) => boolean;
+    advanceDeliveryStatuses: (config: DaemonConfig, teamState: FocusTeamState, sessionId: string) => Promise<void>;
+    /**
+     * Resolve the effective workflow (with transitions) for a delivery so the
+     * non-advanceability guard can check for an automatic transition out of the
+     * delivery's current stage. Uses the transitions-included fetch -- the plain
+     * fetchEffectiveWorkflow strips transitions.
+     */
+    fetchEffectiveWorkflow: (deliveryId: string) => Promise<Workflow>;
+    /**
+     * True when an open (pending/in_review) team_failure escalation already
+     * names this focus. Backs the idempotency guard: at most one open escalation
+     * per stuck focus, so the guard does not file a fresh row every tick. The
+     * production read is the DEDUP read (hasOpenTeamFailureEscalationForDedup), which also
+     * sees a promoted / correlated team_failure; the respawn guard's hold read is
+     * a different function.
+     */
+    hasOpenTeamFailureEscalation: (focusId: string) => Promise<boolean>;
+    /**
+     * Resolve the focus's review_requested_at FRESH (it can be set or cleared
+     * between team spawn and this completion event). Backs the review-window
+     * guard below. Returns the ISO timestamp or null (no review requested).
+     */
+    getReviewRequestedAt: (config: DaemonConfig, focusId: string) => Promise<string | null>;
+    /**
+     * Resolve the focus's human-ratification state (product_focuses.read_only /
+     * ratified_at). Backs the scope-coverage no-progress guard: a `planning`
+     * delivery on a read_only focus is awaiting the human ratify gate, NOT team
+     * work the team is failing to advance -- counting it as actionable accrued a
+     * spurious no-progress team_failure on audit focuses (escalation aa58d9c3).
+     */
+    getFocusRatificationState: (config: DaemonConfig, focusId: string) => Promise<{
+        readOnly: boolean;
+        auditOrigin?: boolean;
+        ratifiedAt: string | null;
+    }>;
+    /**
+     * Route a completed review pass deterministically: close clean verify
+     * deliveries to `done`, send open-work deliveries to `verify_failed`, and
+     * clear `review_requested_at`. Called on the review-pass COMPLETION signal
+     * (not process exit) so a resumed interactive review session -- which never
+     * exits -- still closes the focus. The same handler also runs on the close
+     * path; the second call is a no-op once `review_requested_at` is cleared.
+     */
+    runReviewExitHandler: (params: {
+        focusId: string;
+        focusName: string;
+        organizationId: string;
+        productId: string;
+        sessionId: string;
+        sessionType: 'coding' | 'review';
+        succeeded: boolean;
+        reviewSpawnTip?: string | null;
+        currentBranchTip?: string | null;
+        reviewInspected?: boolean;
+        reviewPriorWatermark?: string | null;
+    }) => Promise<void>;
+    /**
+     * Resolve the focus's persistent worktree (path) so the no-progress guard can
+     * read its git state. Backs BOTH the git-activity dimension on the progress
+     * snapshot (a fresh commit on the focus branch resets the no-progress counter)
+     * AND the dirty re-wake-before-terminate guard. Undefined when the focus has
+     * no registered worktree (focusHeadSha=null, no dirty re-wake).
+     */
+    getFocusWorktree: (focusId: string) => {
+        worktreePath: string;
+    } | undefined;
+    /**
+     * The focus's unclaimed-migration record, read at the team exit so a file
+     * written without a claim is named to the team that wrote it before the team
+     * is torn down. Null when the focus has no record.
+     */
+    readUnclaimedMigrationRecord: (focusId: string) => Promise<string | null>;
+    /** Marks that record as handed to the team (its named-at marker). */
+    markUnclaimedMigrationNamed: (focusId: string, namedAt: string) => Promise<void>;
+    /**
+     * Writes the notice to the live team of this completion event and classifies
+     * the write. Takes the event's context because the carrier is the event's own
+     * lead process (production: its stdin, via stdinDelivery), not a global.
+     */
+    deliverUnclaimedMigrationNotice: (ctx: CompletionEventContext, message: string) => NoticeDelivery;
+    /**
+     * The team-activity axes of the one progress measure (agent activity, the
+     * uncommitted diff -- completion/team-progress/team-progress-measure.ts).
+     */
+    readTeamActivityMarks: (focusId: string, worktreePath: string | null) => TeamActivityMarks;
+    /**
+     * Ms until the team's live workers would go quiet, null when none are live;
+     * while non-null the lead gets no wake (completion/completion-event/worker-wait.ts).
+     */
+    teamWorkersQuietInMs: (focusId: string, nowMs: number) => number | null;
+    /**
+     * True while a verify command is running in the focus worktree (the
+     * verify-interlock hold). Folded into teamHasActionableWork via the shared
+     * team-actionable-work predicate so the team-exit and the spawn gate agree
+     * about a held focus.
+     */
+    isWorktreeUnderVerify: (worktreePath: string) => boolean;
+    /**
+     * The delivery ids the in-flight verify in a worktree is judging (the
+     * verify-interlock's delivery record). Under a hold, only these are withheld
+     * from the team; a sibling delivery's open work stays actionable.
+     */
+    verifyHeldDeliveryIds: (worktreePath: string) => ReadonlySet<string>;
+    /**
+     * Read the focus worktree's HEAD sha for the snapshot's git-activity
+     * dimension. Returns null when the worktree path does not exist or git fails.
+     */
+    readWorktreeHeadSha: (worktreePath: string) => string | null;
+    /**
+     * Rescue a terminated team's committed work into the verify/review gate on
+     * the no-progress terminate path: safety-commit a dirty worktree, and if the
+     * focus branch carries committed work, flip each finished coding delivery's
+     * In-Progress issues -> In Review and advance coding -> verify. Returns the
+     * count reconciled; the handler escalates the no-progress team_failure ONLY
+     * when nothing was reconciled.
+     */
+    reconcileTerminatedTeamWork: (params: ReconcileTerminatedWorkParams) => Promise<ReconcileTerminatedWorkResult>;
+    /**
+     * The clock. The stall-guard time floors -- the
+     * no-progress counter floor, the stall window, and the handoff-loop
+     * floor -- all read the clock through this so their invariants are testable
+     * without real sleeps. Kept out of the PURE decision (completion-decision.ts):
+     * the clock is read here in the fact/side-effect layer and the elapsed result
+     * is fed into the decision as data.
+     */
+    now: () => number;
+    /**
+     * Liveness probe for the lead process. Backs the honest re-wake guard: a non-null
+     * teamState.leadStdin (a Writable) can OUTLIVE its process -- the object
+     * reference persists after exit while writes fail (EPIPE) -- so a non-null
+     * stdin is NOT proof of a reachable lead. Gating the deferred re-drive on a
+     * real pid liveness check closes that latent dishonesty.
+     */
+    isLeadAlive: (pid: number) => boolean;
+    /**
+     * Timer for the handoff-floor deferral's self re-drive. When a re-engagement is deferred
+     * inside HANDOFF_MIN_INTERVAL_MS, executeCompletionAction schedules a re-drive
+     * after the remaining floor interval; on fire the re-drive re-invokes
+     * handleCompletionEvent (re-reading deliveries/issues) so a parked lead whose
+     * FINAL completion was deferred is never lost. Returns a canceller stored on
+     * teamState.reDriveCancel so a newer event or a teardown supersedes the pending
+     * re-drive.
+     */
+    scheduleReDrive: (fn: () => void, delayMs: number) => () => void;
+    /**
+     * The re-drive action a scheduled handoff-floor re-drive runs on fire:
+     * re-invoke the completion-event decision with no new lead event (production:
+     * handleCompletionEvent). Routed through deps -- rather than the
+     * applier importing handleCompletionEvent directly -- because that import
+     * would form a runtime cycle event.ts <-> team-outcome/apply.ts (gated at
+     * error by import-x/no-cycle).
+     */
+    reDrive: (ctx: CompletionEventContext, deps: CompletionEventDeps) => Promise<void>;
+}
+/**
+ * The TeamOutcome of a lead-turn completion. A missing/partial completionInfo
+ * is "not a terminal error" -- production always passes a populated one
+ * (process-spawn.ts).
+ */
+export declare function buildCompletionEventOutcome(ctx: CompletionEventContext): TeamOutcome;
+/**
+ * Handle a 'complete' event from the CompletionDetector.
+ *
+ * Builds the turn's TeamOutcome and runs it through the one team-exit
+ * pipeline: decide() (completion/team-outcome/decide.ts, the turn-complete
+ * rows) returns the actions and the one applier performs them.
+ */
+export declare function handleCompletionEvent(ctx: CompletionEventContext, deps: CompletionEventDeps): Promise<void>;
+//# sourceMappingURL=event.d.ts.map

package/dist/completion/completion-event/event.d.ts.map

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

package/dist/completion/completion-event/event.js

@@ -0,0 +1,48 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/completion-event/exit-unclaimed-migration-hold.test.ts,
+//   packages/daemon/src/completion/completion-event/exit-verify-hold.test.ts,
+//   packages/daemon/src/completion/completion-event/merge-resolution-hold.test.ts,
+//   packages/daemon/src/completion/completion-event/review-window-idle-coding-lead-regression.test.ts,
+//   packages/daemon/src/completion/completion-event/teardown-demotion-gate.test.ts,
+//   packages/daemon/src/completion/completion-event/terminal-error-terminate.test.ts,
+//   packages/daemon/src/completion/completion-event/unclaimed-migration-notice.test.ts,
+//   packages/daemon/src/completion/team-outcome/apply.test.ts,
+//   packages/daemon/src/completion/team-outcome/team-outcome-characterization.test.ts,
+//   packages/daemon/src/completion/team-progress/progress-guards-recorded-intent.test.ts,
+//   packages/daemon/src/composition/daemon-contexts.test.ts,
+//   packages/daemon/src/spawn/progress-measure-wiring.test.ts
+// PINNED-BY-END
+import { buildTeamOutcome } from '../team-outcome/team-outcome.js';
+import { createExitPipelineState } from '../team-outcome/exit-pipeline-state.js';
+import { runTeamExitPipeline } from '../team-outcome/apply.js';
+import { turnCompleteEnv } from '../team-outcome/apply-turn.js';
+import { cancelPendingReDrive } from './reengagement-redrive.js';
+/**
+ * The TeamOutcome of a lead-turn completion. A missing/partial completionInfo
+ * is "not a terminal error" -- production always passes a populated one
+ * (process-spawn.ts).
+ */
+export function buildCompletionEventOutcome(ctx) {
+    return buildTeamOutcome({
+        trigger: 'turn_complete',
+        teamState: ctx.teamState,
+        resultIsError: ctx.completionInfo?.result?.isError === true,
+    });
+}
+// ── Handler ─────────────────────────────────────────────────────────────
+/**
+ * Handle a 'complete' event from the CompletionDetector.
+ *
+ * Builds the turn's TeamOutcome and runs it through the one team-exit
+ * pipeline: decide() (completion/team-outcome/decide.ts, the turn-complete
+ * rows) returns the actions and the one applier performs them.
+ */
+export async function handleCompletionEvent(ctx, deps) {
+    // A fresh event (a real lead completion, or the scheduled re-drive itself)
+    // supersedes any pending handoff-floor re-drive: cancel it so the decision is
+    // taken exactly once per event and no stale timer fires afterward.
+    cancelPendingReDrive(ctx.teamState);
+    const state = createExitPipelineState(buildCompletionEventOutcome(ctx), ctx.teamState);
+    await runTeamExitPipeline(state, turnCompleteEnv(ctx, deps));
+}
+//# sourceMappingURL=event.js.map

package/dist/completion/completion-event/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../../src/completion/completion-event/event.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,oGAAoG;AACpG,8EAA8E;AAC9E,mFAAmF;AACnF,uGAAuG;AACvG,oFAAoF;AACpF,sFAAsF;AACtF,wFAAwF;AACxF,+DAA+D;AAC/D,uFAAuF;AACvF,0FAA0F;AAC1F,6DAA6D;AAC7D,8DAA8D;AAC9D,gBAAgB;AAwBhB,OAAO,EAAE,gBAAgB,EAAoB,MAAM,iCAAiC,CAAC;AACrF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAwLjE;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CAAC,GAA2B;IACrE,OAAO,gBAAgB,CAAC;QACtB,OAAO,EAAE,eAAe;QACxB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,aAAa,EAAE,GAAG,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI;KAC5D,CAAC,CAAC;AACL,CAAC;AAED,2EAA2E;AAE3E;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,GAA2B,EAC3B,IAAyB;IAEzB,2EAA2E;IAC3E,8EAA8E;IAC9E,mEAAmE;IACnE,oBAAoB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACpC,MAAM,KAAK,GAAG,uBAAuB,CAAC,2BAA2B,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;IACvF,MAAM,mBAAmB,CAAC,KAAK,EAAE,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC;AAC/D,CAAC"}

package/dist/completion/completion-event/reengagement-redrive.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Handoff-floor SELF RE-DRIVE.
+ *
+ * The handoff floor DEFERS a re-engagement/handoff that arrives inside
+ * HANDOFF_MIN_INTERVAL_MS (anti-spam). A parked lead only emits a completion
+ * event in RESPONSE to a wake, so a deferred FINAL completion is never followed
+ * by another; waiting on the lead's next completion would leave the team at
+ * phase=executing (merge-back skips it) until the idle-stall timer. So
+ * executeCompletionAction schedules a post-floor re-drive here: after the
+ * remaining floor interval, with NO new lead event, it re-invokes the completion
+ * decision (deps.reDrive -> handleCompletionEvent), which re-reads
+ * deliveries/issues and either hands off actionable work or terminates work that
+ * turned out terminal.
+ *
+ * Owner of a team's `reDrive` sub-record (types/focus-team-state.ts,
+ * TEAM_STATE_OWNERS): reDriveCancel is written only here.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/completion-event/reengagement-redrive.ts).
+ */
+import type { FocusTeamState } from '../../types/index.js';
+import type { CompletionEventContext, CompletionEventDeps } from './event.js';
+/**
+ * Cancel any pending handoff-floor self re-drive on this team. Called at the
+ * top of handleCompletionEvent (a fresh/newer event supersedes a pending
+ * re-drive) and on teardown so no stale timer fires against a torn-down or
+ * already-reacted team. Idempotent.
+ */
+export declare function cancelPendingReDrive(teamState: FocusTeamState): void;
+/**
+ * Schedule a post-floor self re-drive for a team whose re-engagement was just
+ * deferred by the handoff floor.
+ *
+ * The fire is guarded: it re-drives only a still-`executing`, still-alive team.
+ * A newer deferral supersedes the prior pending re-drive (cancel then
+ * reschedule); handleCompletionEvent and terminateTeam also cancel it, so at
+ * most one re-drive is ever pending and it is taken at most once. The re-drive
+ * itself re-enters the floor check with lastHandoffAt unchanged, so once the
+ * floor has elapsed it hands off (or terminates) rather than deferring again --
+ * the loop converges and the anti-spam bound (<=1 handoff per interval) holds.
+ */
+export declare function scheduleDeferredReDrive(ctx: CompletionEventContext, deps: CompletionEventDeps, delayMs: number, 
+/**
+ * Asked when the timer fires: a number means "still holding -- check again
+ * in that many ms" (no re-drive, no cycle), null means re-drive now. Used by
+ * the wait on live workers (completion/completion-event/worker-wait.ts), so a worker that keeps
+ * reporting costs the lead no completion cycles at all.
+ */
+recheck?: () => number | null | Promise<number | null>): void;
+//# sourceMappingURL=reengagement-redrive.d.ts.map

package/dist/completion/completion-event/reengagement-redrive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reengagement-redrive.d.ts","sourceRoot":"","sources":["../../../src/completion/completion-event/reengagement-redrive.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAsB,MAAM,sBAAsB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAK9E;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAOpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,MAAM;AACf;;;;;GAKG;AACH,OAAO,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GACrD,IAAI,CAgCN"}

package/dist/completion/completion-event/reengagement-redrive.js

@@ -0,0 +1,71 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/completion-event/reengagement-redrive.test.ts
+// PINNED-BY-END
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'focus-executor' });
+/**
+ * Cancel any pending handoff-floor self re-drive on this team. Called at the
+ * top of handleCompletionEvent (a fresh/newer event supersedes a pending
+ * re-drive) and on teardown so no stale timer fires against a torn-down or
+ * already-reacted team. Idempotent.
+ */
+export function cancelPendingReDrive(teamState) {
+    const cancel = teamState.reDriveCancel;
+    if (cancel) {
+        const reDrive = teamState;
+        reDrive.reDriveCancel = undefined;
+        cancel();
+    }
+}
+/**
+ * Schedule a post-floor self re-drive for a team whose re-engagement was just
+ * deferred by the handoff floor.
+ *
+ * The fire is guarded: it re-drives only a still-`executing`, still-alive team.
+ * A newer deferral supersedes the prior pending re-drive (cancel then
+ * reschedule); handleCompletionEvent and terminateTeam also cancel it, so at
+ * most one re-drive is ever pending and it is taken at most once. The re-drive
+ * itself re-enters the floor check with lastHandoffAt unchanged, so once the
+ * floor has elapsed it hands off (or terminates) rather than deferring again --
+ * the loop converges and the anti-spam bound (<=1 handoff per interval) holds.
+ */
+export function scheduleDeferredReDrive(ctx, deps, delayMs, 
+/**
+ * Asked when the timer fires: a number means "still holding -- check again
+ * in that many ms" (no re-drive, no cycle), null means re-drive now. Used by
+ * the wait on live workers (completion/completion-event/worker-wait.ts), so a worker that keeps
+ * reporting costs the lead no completion cycles at all.
+ */
+recheck) {
+    const { teamState } = ctx;
+    const reDrive = teamState;
+    // Deferral resets the completion detector so a genuine future completion is
+    // still observed; the two halves of "defer" (reset + schedule) live together
+    // here so the caller's branch stays a single statement.
+    ctx.completionDetector.reset();
+    // Supersede any prior pending re-drive; the latest deferral owns the timer.
+    teamState.reDriveCancel?.();
+    reDrive.reDriveCancel = undefined;
+    reDrive.reDriveCancel = deps.scheduleReDrive(() => {
+        // The timer fired: clear our own canceller first so the re-driven
+        // handleCompletionEvent (which also cancels) sees a clean slate.
+        reDrive.reDriveCancel = undefined;
+        // Only re-drive a team still live and still executing. A terminated /
+        // shutting-down team, or one whose lead process has died, must not be woken.
+        if (teamState.phase !== 'executing')
+            return;
+        if (teamState.leadPid != null && !deps.isLeadAlive(teamState.leadPid))
+            return;
+        void (async () => {
+            const again = recheck ? await recheck() : null;
+            if (again !== null) {
+                scheduleDeferredReDrive(ctx, deps, again, recheck);
+                return;
+            }
+            await deps.reDrive(ctx, deps);
+        })().catch(err => {
+            log.warn(`Deferred re-drive for "${ctx.focusName}" failed: ${err.message}`);
+        });
+    }, delayMs);
+}
+//# sourceMappingURL=reengagement-redrive.js.map

package/dist/completion/completion-event/reengagement-redrive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reengagement-redrive.js","sourceRoot":"","sources":["../../../src/completion/completion-event/reengagement-redrive.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0FAA0F;AAC1F,gBAAgB;AAwBhB,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAyB;IAC5D,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC;IACvC,IAAI,MAAM,EAAE,CAAC;QACX,MAAM,OAAO,GAAkC,SAAS,CAAC;QACzD,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;QAClC,MAAM,EAAE,CAAC;IACX,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CACrC,GAA2B,EAC3B,IAAyB,EACzB,OAAe;AACf;;;;;GAKG;AACH,OAAsD;IAEtD,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC;IAC1B,MAAM,OAAO,GAAkC,SAAS,CAAC;IACzD,4EAA4E;IAC5E,6EAA6E;IAC7E,wDAAwD;IACxD,GAAG,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IAC/B,4EAA4E;IAC5E,SAAS,CAAC,aAAa,EAAE,EAAE,CAAC;IAC5B,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;IAElC,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE;QAChD,kEAAkE;QAClE,iEAAiE;QACjE,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC;QAClC,sEAAsE;QACtE,6EAA6E;QAC7E,IAAI,SAAS,CAAC,KAAK,KAAK,WAAW;YAAE,OAAO;QAC5C,IAAI,SAAS,CAAC,OAAO,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC;YAAE,OAAO;QAC9E,KAAK,CAAC,KAAK,IAAI,EAAE;YACf,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YAC/C,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,uBAAuB,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACnD,OAAO;YACT,CAAC;YACD,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QAChC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;YACf,GAAG,CAAC,IAAI,CACN,0BAA0B,GAAG,CAAC,SAAS,aAAc,GAAa,CAAC,OAAO,EAAE,CAC7E,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,OAAO,CAAC,CAAC;AACd,CAAC"}

package/dist/completion/completion-event/review-window.d.ts

@@ -0,0 +1,3 @@
+import type { FocusDeliveryInfo } from '../../types/index.js';
+export declare function isInReviewWindow(reviewRequestedAt: string | null, deliveries: readonly FocusDeliveryInfo[]): boolean;
+//# sourceMappingURL=review-window.d.ts.map

package/dist/completion/completion-event/review-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-window.d.ts","sourceRoot":"","sources":["../../../src/completion/completion-event/review-window.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,wBAAgB,gBAAgB,CAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,EAChC,UAAU,EAAE,SAAS,iBAAiB,EAAE,GACvC,OAAO,CAGT"}

package/dist/completion/completion-event/review-window.js

@@ -0,0 +1,23 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: none -- no test imports this module directly (baselined; see lint:pinned-by)
+// PINNED-BY-END
+/**
+ * Whether a focus is in its review window: a review has been requested AND at
+ * least one delivery still sits in verify. Inside it every delivery is
+ * cascadable (verify counts as terminal-for-the-team), so the all-terminal and
+ * no-actionable-work teardowns would end a freshly spawned REVIEW team before
+ * it completes the review -- the teardown race that strands a focus in
+ * `reviewing`.
+ *
+ * Pure and dependency-light on purpose: the team-exit decide() table reads it,
+ * and nothing decide() reaches may do I/O.
+ *
+ * @module completion/completion-event/review-window
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+export function isInReviewWindow(reviewRequestedAt, deliveries) {
+    if (!reviewRequestedAt)
+        return false;
+    return deliveries.some(d => d.executionStatus === DELIVERY_STATUS.VERIFY);
+}
+//# sourceMappingURL=review-window.js.map

package/dist/completion/completion-event/review-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-window.js","sourceRoot":"","sources":["../../../src/completion/completion-event/review-window.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0FAA0F;AAC1F,gBAAgB;AAEhB;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,MAAM,UAAU,gBAAgB,CAC9B,iBAAgC,EAChC,UAAwC;IAExC,IAAI,CAAC,iBAAiB;QAAE,OAAO,KAAK,CAAC;IACrC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,KAAK,eAAe,CAAC,MAAM,CAAC,CAAC;AAC5E,CAAC"}

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

@@ -0,0 +1,38 @@
+import type { Writable } from 'node:stream';
+/**
+ * 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';
+/**
+ * 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` -- and reading a
+ * failed write to it as `write_failed` would keep the team and retry a write
+ * that can never succeed until the hold expired into the teardown it held back.
+ *
+ * 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: decide() delivers the notice
+ * only to a coding pass (a review pass cannot claim or remove the file), so the
+ * only team this ever composes for is a coding team.
+ */
+export declare function buildUnclaimedNoticeMessage(record: string): string;
+//# sourceMappingURL=unclaimed-migration-notice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unclaimed-migration-notice.d.ts","sourceRoot":"","sources":["../../../src/completion/completion-event/unclaimed-migration-notice.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,cAAc,GAAG,cAAc,CAAC;AAE3E;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAIjG;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE"}

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

@@ -0,0 +1,52 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/completion-event/unclaimed-migration-notice.test.ts
+// PINNED-BY-END
+/**
+ * The unclaimed-migration notice's EFFECTS: the message, and its write to the
+ * live team's stdin. Whether and when the notice is delivered -- ahead of every
+ * teardown, only to a coding pass, keeping the team for that turn, retrying a
+ * failed read or write -- is decided by the turn-complete rows of decide()
+ * (completion/team-outcome/decide-turn-entry-rows.ts) and carried out by the
+ * applier (completion/team-outcome/apply-turn.ts).
+ *
+ * Why the notice is delivered this way: docs/daemon/team-exit-pipeline.md.
+ * History: docs/daemon/history-team-lifecycle.md (completion/completion-event/unclaimed-migration-notice.ts).
+ *
+ * @module completion/completion-event/unclaimed-migration-notice
+ */
+import { sendMessage } from '@telora/daemon-core';
+import { buildUnclaimedMigrationSection } from '../../prompt-sections/unclaimed-migration-section.js';
+/**
+ * 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` -- and reading a
+ * failed write to it as `write_failed` would keep the team and retry a write
+ * that can never succeed until the hold expired into the teardown it held back.
+ *
+ * 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: decide() delivers the notice
+ * only to a coding pass (a review pass cannot claim or remove the file), so the
+ * only team this ever composes for is a coding team.
+ */
+export function buildUnclaimedNoticeMessage(record) {
+    return buildUnclaimedMigrationSection(record, false).join('\n');
+}
+//# sourceMappingURL=unclaimed-migration-notice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unclaimed-migration-notice.js","sourceRoot":"","sources":["../../../src/completion/completion-event/unclaimed-migration-notice.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,gGAAgG;AAChG,gBAAgB;AAEhB;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAE,8BAA8B,EAAE,MAAM,sDAAsD,CAAC;AActG;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,aAAa,CAAC,KAAkC,EAAE,OAAe;IAC/E,IAAI,CAAC,KAAK;QAAE,OAAO,cAAc,CAAC;IAClC,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,aAAa,IAAI,CAAC,KAAK,CAAC,QAAQ;QAAE,OAAO,cAAc,CAAC;IACrF,OAAO,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC;AACpE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,MAAc;IACxD,OAAO,8BAA8B,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClE,CAAC"}

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

@@ -0,0 +1,103 @@
+/**
+ * A lead waiting on its workers is left to wait.
+ *
+ * Re-waking a lead whose background workers are still editing produces empty
+ * completion cycles out of the daemon's own pokes, which the no-progress guards
+ * would count toward a team_failure.
+ *
+ * So while the team's workers are live (completion/team-progress/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 normally, 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).
+ *
+ * Owner of a team's `workerWait` sub-record (types/focus-team-state.ts,
+ * TEAM_STATE_OWNERS): waitingOnWorkersSince and shownIssueIds are written only
+ * here, through the WaitState writable view.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/completion-event/worker-wait.ts).
+ *
+ * @module completion/completion-event/worker-wait
+ */
+import type { FocusDeliveryInfo, FocusIssueInfo, FocusTeamState, WritableTeamRecord } from '../../types/index.js';
+/** The writable view of the team's worker-wait record (this module owns it). */
+type WaitState = WritableTeamRecord<'workerWait'>;
+/**
+ * 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>;
+/**
+ * The wake to the lead is held while its workers report: open the park episode
+ * (logged once per episode) and, the first time, record every issue that
+ * exists as shown -- only what appears after this is new work.
+ */
+export declare function beginWorkerWait(args: {
+    teamState: WaitState;
+    focusId: string;
+    focusName: string;
+    nowMs: number;
+    issues: Pick<FocusIssueInfo, 'id'>[];
+    /** What the held wake would have been, for the log line. */
+    wakeKind: string;
+}): void;
+/** A wake is let through: end the park episode, if one is open, so the next one logs again. */
+export declare function endWorkerWait(args: {
+    teamState: WaitState;
+    focusName: string;
+    nowMs: number;
+    hasUnshownWork: boolean;
+}): void;
+/**
+ * Decide whether to HOLD a wake to the lead because its workers are live.
+ * Returns true to hold (send nothing); the decision is the stop registry's
+ * worker_wait_hold row.
+ */
+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