@telora/daemon 0.22.245 → 0.22.290

package/dist/daemon-state/provider-window.js

@@ -0,0 +1,105 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/review-exit/model-unavailable-review-exit.test.ts,
+//   packages/daemon/src/daemon-state/provider-window.test.ts,
+//   packages/daemon/src/integration/engine-readiness-runtime.test.ts,
+//   packages/daemon/src/integration/model-reached-review-exit-effects.test.ts,
+//   packages/daemon/src/spawn/codex-auth.test.ts, packages/daemon/src/spawn/codex-limit.test.ts,
+//   packages/daemon/src/spawn/empty-directive-route.test.ts,
+//   packages/daemon/src/spawn/engine-not-ready-gate.test.ts,
+//   packages/daemon/src/supervision/spawn-cooldown.test.ts
+// PINNED-BY-END
+/**
+ * Per-provider rate-limit windows.
+ *
+ * A rate limit belongs to the ACCOUNT that reported it, and the daemon spawns on
+ * more than one account: the claude backend runs on Anthropic, the codex backend
+ * on OpenAI (or, when a local model is routed through it, on no hosted account
+ * at all). A single shared window would let a Claude limit hold Codex review
+ * spawns running on a separate OpenAI account, and a Codex limit hold Claude
+ * coding teams.
+ *
+ * So the window is keyed by provider. A limit opens only its own provider's
+ * window; a reader names the provider of the spawn it is about to make
+ * (providerForEngine, from the spawn's resolved engine and whether a local model
+ * is routed) and is held only by that provider's window. A limit on both holds
+ * both. Within one provider: a
+ * reset in the future opens it until then, the LATER of two open resets binds (a
+ * five_hour rejection inside a seven_day window does not shorten it), and a
+ * reset already in the past closes it. In-memory only: a restart re-learns it
+ * from the provider on the first attempt.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/provider-window.ts).
+ */
+import { createLogger } from '../log/daemon-log.js';
+const log = createLogger({ module: 'spawn-cooldown' });
+/** The provider of the claude backend -- the daemon's default engine (backends/registry.ts DEFAULT_BACKEND_ID). */
+export const CLAUDE_PROVIDER = 'anthropic';
+/** The provider of the codex backend on a hosted model. */
+export const CODEX_PROVIDER = 'openai';
+/**
+ * The provider a spawn will run on, from its resolved engine id and whether the
+ * pass routes a local model. Pure. An engine the daemon does not know as hosted
+ * is read as local: it reaches neither hosted account, so neither window may
+ * hold it.
+ */
+export function providerForEngine(engineId, localModelSelected = false) {
+    if (engineId === 'claude')
+        return CLAUDE_PROVIDER;
+    if (engineId === 'codex')
+        return localModelSelected ? 'local' : CODEX_PROVIDER;
+    return 'local';
+}
+const windows = new Map();
+/**
+ * Record a rate-limit signal on one provider. Returns true when that provider's
+ * window is now open (the reset is in the future), false when the signal closed
+ * it. Leaves every other provider's window untouched.
+ */
+export function openProviderWindow(provider, resetAtMs, nowMs = Date.now()) {
+    const current = windows.get(provider) ?? null;
+    if (!Number.isFinite(resetAtMs) || resetAtMs <= nowMs) {
+        if (current !== null) {
+            log.info(`Provider rate limit (${provider}): window closed (reset instant has passed); ${provider} spawns resume`);
+        }
+        windows.delete(provider);
+        return false;
+    }
+    const next = Math.max(current ?? 0, resetAtMs);
+    if (current !== next) {
+        log.warn(`Provider rate limit (${provider}): holding every ${provider} spawn (teams and one-shots) until ` +
+            `${new Date(next).toISOString()} -- spawns on other providers proceed`);
+    }
+    windows.set(provider, next);
+    return true;
+}
+/**
+ * The instant a provider's window closes, or null when it is not open. A window
+ * whose reset has passed reads as closed and is dropped.
+ */
+export function providerWindowHoldUntilMs(provider, nowMs = Date.now()) {
+    const until = windows.get(provider);
+    if (until === undefined)
+        return null;
+    if (until <= nowMs) {
+        windows.delete(provider);
+        return null;
+    }
+    return until;
+}
+/**
+ * True when any provider's window is open. The spawn gates resolve the provider
+ * of the spawn they are about to let through only then: with every window closed
+ * no provider holds anything, so the route needs no reading.
+ */
+export function anyProviderWindowOpen(nowMs = Date.now()) {
+    for (const provider of [...windows.keys()]) {
+        if (providerWindowHoldUntilMs(provider, nowMs) !== null)
+            return true;
+    }
+    return false;
+}
+/** Test-only: close every window, as a daemon re-exec starts with none. */
+export function __resetProviderWindowsForTests() {
+    windows.clear();
+}
+//# sourceMappingURL=provider-window.js.map

package/dist/daemon-state/provider-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-window.js","sourceRoot":"","sources":["../../src/daemon-state/provider-window.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,+FAA+F;AAC/F,8DAA8D;AAC9D,sEAAsE;AACtE,+EAA+E;AAC/E,iGAAiG;AACjG,6DAA6D;AAC7D,6DAA6D;AAC7D,2DAA2D;AAC3D,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGpD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAC;AAEvD,mHAAmH;AACnH,MAAM,CAAC,MAAM,eAAe,GAAkB,WAAW,CAAC;AAE1D,2DAA2D;AAC3D,MAAM,CAAC,MAAM,cAAc,GAAkB,QAAQ,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAgB,EAAE,kBAAkB,GAAG,KAAK;IAC5E,IAAI,QAAQ,KAAK,QAAQ;QAAE,OAAO,eAAe,CAAC;IAClD,IAAI,QAAQ,KAAK,OAAO;QAAE,OAAO,kBAAkB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC;IAC/E,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,MAAM,OAAO,GAAG,IAAI,GAAG,EAAyB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAAuB,EAAE,SAAiB,EAAE,QAAgB,IAAI,CAAC,GAAG,EAAE;IACvG,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC;IAC9C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,SAAS,IAAI,KAAK,EAAE,CAAC;QACtD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,GAAG,CAAC,IAAI,CAAC,wBAAwB,QAAQ,gDAAgD,QAAQ,gBAAgB,CAAC,CAAC;QACrH,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;IAC/C,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,GAAG,CAAC,IAAI,CACN,wBAAwB,QAAQ,oBAAoB,QAAQ,qCAAqC;YACjG,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,uCAAuC,CACvE,CAAC;IACJ,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC5B,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB,CAAC,QAAuB,EAAE,QAAgB,IAAI,CAAC,GAAG,EAAE;IAC3F,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACpC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IACrC,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;QACnB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAgB,IAAI,CAAC,GAAG,EAAE;IAC9D,KAAK,MAAM,QAAQ,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QAC3C,IAAI,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;IACvE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,8BAA8B;IAC5C,OAAO,CAAC,KAAK,EAAE,CAAC;AAClB,CAAC"}

package/dist/daemon-state/review-park-record.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The review parks standing now: which focus's queued review spawn the park gate
+ * (spawn/review-hold-park.ts) is withholding, why, and since when.
+ *
+ * A park is recorded here, not only logged, so a parked focus is visible
+ * between team sessions: this is the in-memory record the heartbeat's focus
+ * activity record reads
+ * (focus/focus-activity-producers.ts, kind `review_parked`). An episode begins
+ * the first poll the gate parks the focus and keeps that time on every later
+ * park; it ends the poll the gate reads `none` or `released`.
+ *
+ * A LEAF: it imports nothing, so the park gate (spawn/) and the heartbeat
+ * (focus/) both read it without a cycle.
+ *
+ * @module daemon-state/review-park-record
+ */
+/** One standing park episode. */
+export interface ReviewPark {
+    /** What the review waits on (the hold kinds holding every non-terminal delivery). */
+    reason: string;
+    /** Epoch ms the episode began. */
+    sinceMs: number;
+}
+/**
+ * Record that the focus's review is parked. Returns true when this begins a new
+ * episode (the caller logs once per episode). A standing episode keeps its start
+ * time and takes the latest reason.
+ */
+export declare function recordReviewPark(focusId: string, reason: string, now?: number): boolean;
+/** End the focus's park episode (the gate read `none` or `released`). */
+export declare function clearReviewPark(focusId: string): void;
+/** Every standing park episode, keyed by focusId. Read-only copy. */
+export declare function reviewParkSnapshot(): ReadonlyMap<string, ReviewPark>;
+/** Test-only: forget every episode. */
+export declare function __resetReviewParkRecordForTests(): void;
+//# sourceMappingURL=review-park-record.d.ts.map

package/dist/daemon-state/review-park-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-park-record.d.ts","sourceRoot":"","sources":["../../src/daemon-state/review-park-record.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AAEH,iCAAiC;AACjC,MAAM,WAAW,UAAU;IACzB,qFAAqF;IACrF,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;CACjB;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAE,MAAmB,GAAG,OAAO,CAInG;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAErD;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAEpE;AAED,uCAAuC;AACvC,wBAAgB,+BAA+B,IAAI,IAAI,CAEtD"}

package/dist/daemon-state/review-park-record.js

@@ -0,0 +1,27 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/focus/focus-activity-producers.test.ts
+// PINNED-BY-END
+const parks = new Map();
+/**
+ * Record that the focus's review is parked. Returns true when this begins a new
+ * episode (the caller logs once per episode). A standing episode keeps its start
+ * time and takes the latest reason.
+ */
+export function recordReviewPark(focusId, reason, now = Date.now()) {
+    const prior = parks.get(focusId);
+    parks.set(focusId, { reason, sinceMs: prior?.sinceMs ?? now });
+    return prior === undefined;
+}
+/** End the focus's park episode (the gate read `none` or `released`). */
+export function clearReviewPark(focusId) {
+    parks.delete(focusId);
+}
+/** Every standing park episode, keyed by focusId. Read-only copy. */
+export function reviewParkSnapshot() {
+    return new Map(parks);
+}
+/** Test-only: forget every episode. */
+export function __resetReviewParkRecordForTests() {
+    parks.clear();
+}
+//# sourceMappingURL=review-park-record.js.map

package/dist/daemon-state/review-park-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"review-park-record.js","sourceRoot":"","sources":["../../src/daemon-state/review-park-record.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,wEAAwE;AACxE,gBAAgB;AA2BhB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;AAE5C;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe,EAAE,MAAc,EAAE,MAAc,IAAI,CAAC,GAAG,EAAE;IACxF,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACjC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;IAC/D,OAAO,KAAK,KAAK,SAAS,CAAC;AAC7B,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AACxB,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,kBAAkB;IAChC,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,+BAA+B;IAC7C,KAAK,CAAC,KAAK,EAAE,CAAC;AAChB,CAAC"}

package/dist/daemon-state/shutdown-attribution.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Who ended this team lead, and how the answer reaches the exit line.
+ *
+ * WHY. Each teardown path logs its own intent only at the moment it acts, so an
+ * exit line that names no initiating cause forces attribution to be inferred
+ * from the ABSENCE of other log lines -- and absence cannot separate "no daemon
+ * path acted" from "a daemon path acted without logging". The exit line
+ * `handleTeamProcessClose` emits therefore carries the attribution this module
+ * derives.
+ *
+ * WHY THE REASON ENUM IS NOT THE ANSWER. `FocusTeamState.shutdownReason` is
+ * stamped by terminateTeam's callers, and the exit handler holds that same team
+ * state -- but 'teardown' is shared by the stalled-team backstop, three stall
+ * detectors, the session-hold sweep and the focus lifecycle, and most call sites
+ * (the completion event phases) pass no reason at all. Reading
+ * 'teardown' -- or null -- still does not name which path acted.
+ *
+ * WHY THE PATH IS DERIVED, NOT DECLARED. An optional `initiator` argument would
+ * attribute only the call sites someone remembered to update, and the next path
+ * added to the daemon would silently reintroduce the unattributable exit this
+ * module exists to end. Deriving the caller's frame at the single chokepoint
+ * every teardown already passes through attributes ALL of them, including ones
+ * not yet written: there is no argument to omit. The cost is one Error
+ * construction per teardown, which happens at most once per team.
+ *
+ * The daemon runs from `tsc` output, not a bundle, so a frame names a real
+ * module and line. When a frame cannot be read the attribution says so rather
+ * than guessing -- an honest "unknown daemon path" is still a statement that a
+ * daemon path acted, which is the distinction the exit line has to carry.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/shutdown-attribution.ts).
+ */
+import type { ShutdownAttribution } from '../types/shutdown-attribution.js';
+/** What `resolveTerminateInitiator` returns when no frame can be read. */
+export declare const UNKNOWN_INITIATOR = "an unknown daemon path";
+/**
+ * The caller of `terminateTeam`, read from a stack captured inside it.
+ *
+ * Pure and exported for testing. Takes the whole stack string, skips the
+ * `Error` header and the `terminateTeam` frame itself, and renders the next
+ * frame as `<file>.ts:<line>`. A stack that cannot be parsed yields
+ * UNKNOWN_INITIATOR rather than a wrong name.
+ */
+export declare function resolveTerminateInitiator(stack: string | undefined): string;
+/**
+ * Render the attribution clause for a team-lead exit line.
+ *
+ * The two readings this has to keep apart:
+ *   - a daemon path ended it  -> name the path (and the reason, when stamped);
+ *   - nothing in the daemon claimed it -> say so POSITIVELY. The absence of a
+ *     line is never the signal; that was the whole defect.
+ */
+export declare function describeExitAttribution(attribution: ShutdownAttribution | null | undefined): string;
+/**
+ * The whole team-lead exit line.
+ *
+ * Rendered here rather than at the call site so the exit handler -- already at
+ * its size floor -- does not grow, and so the line a reader will grep for is
+ * testable on its own.
+ *
+ * Exit code 143 is 128+15: a lead that HANDLED SIGTERM and exited itself, as
+ * opposed to a delivered unhandled signal (code null, signal 'SIGTERM'). Both
+ * are consistent with a daemon SIGTERM, so the code settles nothing on its own;
+ * the attribution clause is what separates a daemon teardown from a lead that
+ * ended externally.
+ */
+export declare function formatTeamExitLine(args: {
+    focusName: string;
+    code: number | null;
+    signal: string | null;
+    attribution: ShutdownAttribution | null | undefined;
+}): string;
+/**
+ * Stamp attribution on whichever registered team owns `pid`, if any.
+ *
+ * WHY THIS EXISTS ALONGSIDE terminateTeam's STAMP. terminateTeam is not the only
+ * way the daemon ends a lead: `spawn/lead-launch.ts` (a lead it could not
+ * record), `daemon-state/lead-process-ownership.ts` (a focus's untracked previous
+ * lead), `focus/session-process-reap.ts` (a reaped session) and
+ * `spawn/lifecycle.ts` (the teardown fleet reap) all end a lead's process group
+ * without going through it. Stamping only in terminateTeam would make the exit
+ * line report those as "no daemon path claimed this exit" -- a confident lie,
+ * which is worse than the silence it replaced.
+ *
+ * So the stamp also happens at `signalProcessGroup`, the ONE primitive every
+ * kill path funnels through (see the process-group invariant in the package
+ * CLAUDE.md). Recording a decision where it is actually made costs a little
+ * layering -- a signal primitive touching team state -- and buys the property
+ * that matters: a path added later cannot end a lead unattributed, because
+ * there is no second way to kill one.
+ *
+ * Keeps the FIRST stamp: terminateTeam records the deciding path before it
+ * signals, and the SIGKILL escalation that may follow must not overwrite it.
+ */
+export declare function recordTeamShutdownByPid(pid: number, initiator: string): void;
+//# sourceMappingURL=shutdown-attribution.d.ts.map

package/dist/daemon-state/shutdown-attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-attribution.d.ts","sourceRoot":"","sources":["../../src/daemon-state/shutdown-attribution.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAG5E,0EAA0E;AAC1E,eAAO,MAAM,iBAAiB,2BAA2B,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAsB3E;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAQnG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,mBAAmB,GAAG,IAAI,GAAG,SAAS,CAAC;CACrD,GAAG,MAAM,CAGT;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,GAChB,IAAI,CAMN"}

package/dist/daemon-state/shutdown-attribution.js

@@ -0,0 +1,105 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/daemon-state/shutdown-attribution.test.ts
+// PINNED-BY-END
+import { getActiveTeams, setShutdownAttribution } from './focus-team-state.js';
+/** What `resolveTerminateInitiator` returns when no frame can be read. */
+export const UNKNOWN_INITIATOR = 'an unknown daemon path';
+/**
+ * The caller of `terminateTeam`, read from a stack captured inside it.
+ *
+ * Pure and exported for testing. Takes the whole stack string, skips the
+ * `Error` header and the `terminateTeam` frame itself, and renders the next
+ * frame as `<file>.ts:<line>`. A stack that cannot be parsed yields
+ * UNKNOWN_INITIATOR rather than a wrong name.
+ */
+export function resolveTerminateInitiator(stack) {
+    if (!stack)
+        return UNKNOWN_INITIATOR;
+    const frames = stack.split('\n').filter(line => line.trimStart().startsWith('at '));
+    // "    at recoverTeam (/abs/path/src/supervision/stall-detectors.ts:493:24)" and the
+    // bare "    at /abs/path/src/x.ts:12:3" form both end in <path>:<line>:<col>.
+    const sites = frames.map(f => f.match(/([^/\\()\s]+\.[cm]?[jt]s):(\d+):\d+\)?\s*$/));
+    const capturedIn = sites[0]?.[1];
+    if (!capturedIn)
+        return UNKNOWN_INITIATOR;
+    // Frame 0 is the capture site itself, and every frame after it from the SAME
+    // MODULE is that module's own plumbing, not a decision. Skipping them is what
+    // makes the name a deciding PATH rather than the shared primitive it funnels
+    // through: `signalProcessGroup` is reached by `terminateProcessGroup` ->
+    // `startProcessGroupTermination`, both in process-group-kill.ts, so naming
+    // frame 1 attributed every bypassing kill (lead-launch, lead-process-ownership,
+    // session-process-reap, the fleet reap) to "process-group-kill.ts:<line>" --
+    // technically daemon-initiated, but naming no path that decided anything.
+    // An async boundary can leave no frame outside the capturing module (the
+    // ladder's SIGKILL escalation); that reads as an unknown daemon path, which is
+    // still the daemon claiming the exit.
+    const caller = sites.find((site, i) => i > 0 && site !== null && site[1] !== capturedIn);
+    if (!caller)
+        return UNKNOWN_INITIATOR;
+    return `${caller[1]}:${caller[2]}`;
+}
+/**
+ * Render the attribution clause for a team-lead exit line.
+ *
+ * The two readings this has to keep apart:
+ *   - a daemon path ended it  -> name the path (and the reason, when stamped);
+ *   - nothing in the daemon claimed it -> say so POSITIVELY. The absence of a
+ *     line is never the signal; that was the whole defect.
+ */
+export function describeExitAttribution(attribution) {
+    if (!attribution) {
+        return 'attribution: NONE -- no daemon path asked for this teardown, so the lead ended '
+            + 'externally or on its own (an unhandled signal, a crash, or an operator killing the process)';
+    }
+    const reason = attribution.reason ?? 'no reason stated';
+    return `attribution: daemon-initiated by ${attribution.initiator} (reason: ${reason}, `
+        + `requested ${attribution.at.toISOString()})`;
+}
+/**
+ * The whole team-lead exit line.
+ *
+ * Rendered here rather than at the call site so the exit handler -- already at
+ * its size floor -- does not grow, and so the line a reader will grep for is
+ * testable on its own.
+ *
+ * Exit code 143 is 128+15: a lead that HANDLED SIGTERM and exited itself, as
+ * opposed to a delivered unhandled signal (code null, signal 'SIGTERM'). Both
+ * are consistent with a daemon SIGTERM, so the code settles nothing on its own;
+ * the attribution clause is what separates a daemon teardown from a lead that
+ * ended externally.
+ */
+export function formatTeamExitLine(args) {
+    return `Team lead for "${args.focusName}" exited (code: ${args.code}, signal: ${args.signal}) -- `
+        + describeExitAttribution(args.attribution);
+}
+/**
+ * Stamp attribution on whichever registered team owns `pid`, if any.
+ *
+ * WHY THIS EXISTS ALONGSIDE terminateTeam's STAMP. terminateTeam is not the only
+ * way the daemon ends a lead: `spawn/lead-launch.ts` (a lead it could not
+ * record), `daemon-state/lead-process-ownership.ts` (a focus's untracked previous
+ * lead), `focus/session-process-reap.ts` (a reaped session) and
+ * `spawn/lifecycle.ts` (the teardown fleet reap) all end a lead's process group
+ * without going through it. Stamping only in terminateTeam would make the exit
+ * line report those as "no daemon path claimed this exit" -- a confident lie,
+ * which is worse than the silence it replaced.
+ *
+ * So the stamp also happens at `signalProcessGroup`, the ONE primitive every
+ * kill path funnels through (see the process-group invariant in the package
+ * CLAUDE.md). Recording a decision where it is actually made costs a little
+ * layering -- a signal primitive touching team state -- and buys the property
+ * that matters: a path added later cannot end a lead unattributed, because
+ * there is no second way to kill one.
+ *
+ * Keeps the FIRST stamp: terminateTeam records the deciding path before it
+ * signals, and the SIGKILL escalation that may follow must not overwrite it.
+ */
+export function recordTeamShutdownByPid(pid, initiator) {
+    for (const team of getActiveTeams().values()) {
+        if (team.leadPid !== pid || team.shutdownAttribution)
+            continue;
+        setShutdownAttribution(team, { reason: team.shutdownReason ?? null, initiator, at: new Date() });
+        return;
+    }
+}
+//# sourceMappingURL=shutdown-attribution.js.map

package/dist/daemon-state/shutdown-attribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-attribution.js","sourceRoot":"","sources":["../../src/daemon-state/shutdown-attribution.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,2EAA2E;AAC3E,gBAAgB;AAoChB,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,0EAA0E;AAC1E,MAAM,CAAC,MAAM,iBAAiB,GAAG,wBAAwB,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,UAAU,yBAAyB,CAAC,KAAyB;IACjE,IAAI,CAAC,KAAK;QAAE,OAAO,iBAAiB,CAAC;IACrC,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IACpF,qFAAqF;IACrF,8EAA8E;IAC9E,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC,CAAC;IACrF,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,IAAI,CAAC,UAAU;QAAE,OAAO,iBAAiB,CAAC;IAC1C,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,yEAAyE;IACzE,2EAA2E;IAC3E,gFAAgF;IAChF,6EAA6E;IAC7E,0EAA0E;IAC1E,yEAAyE;IACzE,+EAA+E;IAC/E,sCAAsC;IACtC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC;IACzF,IAAI,CAAC,MAAM;QAAE,OAAO,iBAAiB,CAAC;IACtC,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;AACrC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,uBAAuB,CAAC,WAAmD;IACzF,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,iFAAiF;cACpF,6FAA6F,CAAC;IACpG,CAAC;IACD,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,IAAI,kBAAkB,CAAC;IACxD,OAAO,oCAAoC,WAAW,CAAC,SAAS,aAAa,MAAM,IAAI;UACnF,aAAa,WAAW,CAAC,EAAE,CAAC,WAAW,EAAE,GAAG,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAKlC;IACC,OAAO,kBAAkB,IAAI,CAAC,SAAS,mBAAmB,IAAI,CAAC,IAAI,aAAa,IAAI,CAAC,MAAM,OAAO;UAC9F,uBAAuB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,uBAAuB,CACrC,GAAW,EACX,SAAiB;IAEjB,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC;QAC7C,IAAI,IAAI,CAAC,OAAO,KAAK,GAAG,IAAI,IAAI,CAAC,mBAAmB;YAAE,SAAS;QAC/D,sBAAsB,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,cAAc,IAAI,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC;QACjG,OAAO;IACT,CAAC;AACH,CAAC"}

package/dist/daemon-state/shutdown-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-state.d.ts","sourceRoot":"","sources":["../../src/daemon-state/shutdown-state.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/daemon-state/shutdown-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown-state.js","sourceRoot":"","sources":["../../src/daemon-state/shutdown-state.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0FAA0F;AAC1F,gBAAgB;AAEhB;;;;;;GAMG;AAEH,IAAI,YAAY,GAAG,KAAK,CAAC;AAEzB;;GAEG;AACH,MAAM,UAAU,oBAAoB;IAClC,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB;IACnC,YAAY,GAAG,IAAI,CAAC;AACtB,CAAC"}

package/dist/daemon-state/stdin-turn-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-turn-tracker.d.ts","sourceRoot":"","sources":["../../src/daemon-state/stdin-turn-tracker.ts"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAE7E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wFAAwF;AACxF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE5D;AAED,qCAAqC;AACrC,wBAAgB,kCAAkC,IAAI,IAAI,CAEzD"}

package/dist/daemon-state/stdin-turn-tracker.js

@@ -0,0 +1,82 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/daemon-state/stdin-turn-tracker.test.ts,
+//   packages/daemon/src/spawn/spawn-compact-turn.test.ts
+// PINNED-BY-END
+/**
+ * Stdin-turn tracker -- orders team teardown after queued directive delivery.
+ *
+ * The completion detector fires `complete` when the lead finishes a turn (a
+ * `result` event) with no active subagents, and the completion handler tears the
+ * team down. But the daemon may have WRITTEN more stdin user messages to the team
+ * than the CLI has resulted yet: a coding-stage /compact + content injected ~0.4s
+ * after spawn sit queued BEHIND the long kickoff turn, and the kickoff's result
+ * would trigger teardown before they run.
+ *
+ * This tracks stdin user messages SENT per focus. The completion detector reads
+ * it (pendingStdinTurns) and SUPPRESSES `complete` while more messages have been
+ * written than the CLI has resulted (turnCount, one result event per turn -- see
+ * CompletionDetector). So a team with queued stdin turns is not classified done
+ * until it has processed them.
+ *
+ * It only DELAYS completion (never kills early) and is INERT for a normal spawn
+ * (kickoff alone -> sent === turnCount).
+ *
+ * BOUNDED, but NOT "by construction": the count is monotone until teardown, so a
+ * write the CLI NEVER results (a silently-dropped /compact on a resume spawn, a
+ * write that coincides with the CLI's own auto-compaction) leaves sent >
+ * turnCount forever. For a lead that keeps working that self-balances as it
+ * results the queued turn; for a PARKED lead it does not -- turnCount never
+ * catches up, and the only clear site is a teardown that the suppressed
+ * `complete` was supposed to drive. The CompletionDetector logs the sent/turnCount
+ * pair on every suppression so a leaking write is named.
+ *
+ * The bound lives in the detector, not here: CompletionDetector arms a grace
+ * timer when it suppresses and every agent event resets it, so a lead working the
+ * queued turn keeps completion suppressed while a SILENT lead lets the suppression
+ * expire and `complete` fire. The regression this tracker exists to prevent (a
+ * /compact + content queued behind a long kickoff turn dropped at teardown) still
+ * holds: that queued turn emits events as it runs, which keep the grace timer
+ * alive until it results -- only a turn the CLI genuinely never runs expires.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/stdin-turn-tracker.ts).
+ *
+ * @module daemon-state/stdin-turn-tracker
+ */
+/** stdin user messages the daemon has written to each focus's live team. */
+const sentByFocus = new Map();
+/**
+ * Record one stdin user message written to a focus's team (the spawn kickoff
+ * write, and each executeInjectDirective sendMessage). One write == one CLI turn
+ * == one eventual `result` event.
+ */
+export function recordStdinMessageSent(focusId) {
+    sentByFocus.set(focusId, (sentByFocus.get(focusId) ?? 0) + 1);
+}
+/**
+ * Whether the focus has stdin turns queued but not yet resulted: the daemon has
+ * written more user messages than the CLI has completed (`turnCount`). The
+ * completion detector suppresses `complete` while this is true so a queued
+ * directive is delivered before teardown. False when nothing was written (the map
+ * has no entry) -- so a team with no injected directive completes normally.
+ */
+export function pendingStdinTurns(focusId, turnCount) {
+    return (sentByFocus.get(focusId) ?? 0) > turnCount;
+}
+/**
+ * The raw count of stdin user messages sent to a focus's team (the `sent` side of
+ * the sent > turnCount skew). Exposed so the completion detector can LOG both
+ * counters when it suppresses `complete`, making a skew visible in the daemon log
+ * when it occurs. 0 when nothing was written.
+ */
+export function sentStdinCount(focusId) {
+    return sentByFocus.get(focusId) ?? 0;
+}
+/** Clear a focus's tracking on teardown (a respawn starts a fresh count / detector). */
+export function clearStdinTurnTracking(focusId) {
+    sentByFocus.delete(focusId);
+}
+/** Test-only: reset all tracking. */
+export function __resetStdinTurnTrackingForTesting() {
+    sentByFocus.clear();
+}
+//# sourceMappingURL=stdin-turn-tracker.js.map

package/dist/daemon-state/stdin-turn-tracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdin-turn-tracker.js","sourceRoot":"","sources":["../../src/daemon-state/stdin-turn-tracker.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0EAA0E;AAC1E,yDAAyD;AACzD,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,4EAA4E;AAC5E,MAAM,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;AAE9C;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAe;IACpD,WAAW,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAe,EAAE,SAAiB;IAClE,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;AACrD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,OAAO,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,sBAAsB,CAAC,OAAe;IACpD,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAC9B,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,kCAAkC;IAChD,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC"}

package/dist/daemon-state/stop-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-request.d.ts","sourceRoot":"","sources":["../../src/daemon-state/stop-request.ts"],"names":[],"mappings":"AAiCA,oEAAoE;AACpE,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;AAEvC,6DAA6D;AAC7D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,6DAA6D;IAC7D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,+EAA+E;AAC/E,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,EACd,WAAW,CAAC,EAAE,MAAM,EACpB,IAAI,GAAE,MAAiC,GACtC,IAAI,CAQN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,GAAE,MAAiC,GAAG,WAAW,GAAG,IAAI,CAY3F;AAED,uDAAuD;AACvD,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,MAAiC,GAAG,IAAI,CAO9E;AAED,oFAAoF;AACpF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC;AAE/C;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,UAAU,EAAE,OAAO,GAClB,UAAU,CAKZ"}

package/dist/daemon-state/stop-request.js

@@ -0,0 +1,97 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/daemon-state/stop-request.test.ts,
+//   packages/daemon/src/shell/graceful-shutdown.test.ts
+// PINNED-BY-END
+/**
+ * Stop-request channel between the `telora-daemon` CLI and the running daemon.
+ *
+ * The CLI is a separate short-lived process; it can only signal the daemon.
+ * SIGTERM alone cannot say "drain to idle first" vs "stop now", so the CLI
+ * drops a tiny request file in the global state dir BEFORE it sends SIGTERM,
+ * and the daemon's stop handler reads it to choose:
+ *
+ *   - `drain` -- defer teardown until the fleet reaches a zero-team boundary
+ *     (arm intake drain meanwhile); the running fleet is never killed mid-work.
+ *   - `now`   -- tear down immediately (today's behavior; the `--now` escape).
+ *
+ * An external SIGTERM with NO request file (systemd stop, a bare `kill`) reads
+ * as `now` -- so infra-driven stops keep their immediate semantics. A second
+ * stop signal during a drain upgrades it to immediate (see decideStopAction).
+ *
+ * The file is best-effort and self-clearing: the daemon consumes+clears it on
+ * receipt; a missing/corrupt file is treated as absent.
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { resolveGlobalStateDir } from './daemon-process.js';
+import { createLogger } from '../log/daemon-log.js';
+const log = createLogger({ module: 'stop-request' });
+/** Resolve the stop-request file path in the global state dir (~/.telora/). */
+export function resolveStopRequestPath() {
+    return resolve(resolveGlobalStateDir(), 'daemon.stop-request.json');
+}
+/** Write a stop request (CLI side). Best-effort; swallows write errors. */
+export function writeStopRequest(mode, requestedAt, path = resolveStopRequestPath()) {
+    try {
+        const payload = requestedAt ? { mode, requestedAt } : { mode };
+        writeFileSync(path, JSON.stringify(payload), { mode: 0o600 });
+    }
+    catch (err) {
+        // A stop that cannot write the hint degrades to immediate (no file => now).
+        log.debug('A stop that cannot write the hint degrades to immediate (no file => now)', { error: String(err?.message ?? err) });
+    }
+}
+/**
+ * Read the stop request (daemon side). Tolerant: a missing/unreadable/malformed
+ * file, or an unrecognized mode, returns null (which the daemon reads as `now`).
+ */
+export function readStopRequest(path = resolveStopRequestPath()) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        if (typeof raw !== 'object' || raw === null)
+            return null;
+        const mode = raw.mode;
+        if (mode !== 'drain' && mode !== 'now')
+            return null;
+        const requestedAt = raw.requestedAt;
+        return typeof requestedAt === 'string' ? { mode, requestedAt } : { mode };
+    }
+    catch {
+        return null;
+    }
+}
+/** Delete the stop-request file. No-op when absent. */
+export function clearStopRequest(path = resolveStopRequestPath()) {
+    try {
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    catch (err) {
+        // Best effort.
+        log.debug('Best effort', { error: String(err?.message ?? err) });
+    }
+}
+/**
+ * Decide how to respond to a stop signal. Pure -- the daemon's signal handler
+ * wires this to the real request file + drain flag.
+ *
+ *   - SIGINT (Ctrl+C, interactive) always tears down immediately.
+ *   - A SIGTERM with no request, or a `now` request, tears down immediately
+ *     (external/systemd stop, or the `--now` escape).
+ *   - A SIGTERM with a `drain` request defers to the zero-team boundary...
+ *   - ...UNLESS a drain is already in progress: a second stop signal then
+ *     upgrades to immediate teardown (so `stop --now` -- or a repeat `stop` --
+ *     during a drain forces it).
+ */
+export function decideStopAction(signal, request, isDraining) {
+    if (signal !== 'SIGTERM')
+        return 'immediate';
+    if (isDraining)
+        return 'immediate';
+    if (!request || request.mode === 'now')
+        return 'immediate';
+    return 'drain';
+}
+//# sourceMappingURL=stop-request.js.map

package/dist/daemon-state/stop-request.js.map

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

package/dist/daemon-state/team-delivery-tracking.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Owner of a team's `deliveryTracking` sub-record (types/focus-team-state.ts,
+ * TEAM_STATE_OWNERS): the deliveries the team knows about, each delivery's
+ * workflow-stage cursor, which deliveries merged mid-flight, and whether the
+ * team was spawned to plan (no deliveries yet).
+ *
+ * Every write of knownDeliveryIds, deliveryStageIds, mergedDeliveryIds and
+ * planningPhase goes through a writer here; the spawn decision, the turn
+ * completion, the exit status-advance and the mid-flight merge call them. The
+ * collections are readonly on the team, so each write REPLACES the Set/Map with
+ * an extended copy; a reader holding the previous one keeps a stable snapshot.
+ */
+import type { FocusTeamState } from '../types/index.js';
+/** The team now knows `deliveryId`, sitting at workflow stage `stageId`. */
+export declare function admitDelivery(team: FocusTeamState, deliveryId: string, stageId: string | null): void;
+/** Move the team's stage cursor for `deliveryId` to `stageId`. */
+export declare function setDeliveryStage(team: FocusTeamState, deliveryId: string, stageId: string | null): void;
+/** Record that `deliveryId` has merged (or was already complete when the team spawned). */
+export declare function markDeliveryMerged(team: FocusTeamState, deliveryId: string): void;
+/** The team is spawned to plan: its focus has no deliveries yet. */
+export declare function startPlanningPhase(team: FocusTeamState): void;
+/** The planning team's deliveries have appeared: it is no longer planning. */
+export declare function endPlanningPhase(team: FocusTeamState): void;
+//# sourceMappingURL=team-delivery-tracking.d.ts.map

package/dist/daemon-state/team-delivery-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"team-delivery-tracking.d.ts","sourceRoot":"","sources":["../../src/daemon-state/team-delivery-tracking.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAsB,MAAM,mBAAmB,CAAC;AAE5E,4EAA4E;AAC5E,wBAAgB,aAAa,CAAC,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAIpG;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAGvG;AAED,2FAA2F;AAC3F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAGjF;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAG7D;AAED,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAG3D"}