@telora/daemon 0.22.245 → 0.22.289

package/dist/daemon-state/activity-clock-registry.js

@@ -0,0 +1,171 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/daemon-state/activity-clock-registry.test.ts,
+//   packages/daemon/src/focus/heartbeat-team-liveness-phases.test.ts
+// PINNED-BY-END
+/**
+ * Activity-clock observability registry.
+ *
+ * The daemon acts on an in-memory per-team activity clock (focus-team-state's
+ * `lastActivityAt`, advanced on every agent event) while the product surface
+ * reads a SEPARATELY flushed clock (`agent_sessions.activity_summary.updatedAt`,
+ * written by ActivityTracker.flush). When those two clocks disagree an operator
+ * cannot tell WHICH one stalled, because every daemon-API projection strips
+ * activity_summary. This module makes the write chain state a fact the daemon
+ * states in its OWN output (the heartbeat healthEvents channel), distinguishable
+ * from a healthy advancing clock:
+ *
+ *   - activity.write_failed      a flush write errored or timed out
+ *   - activity.write_skipped     a flush short-circuited (re-entry / dirty-check)
+ *                                persistently past a bounded window
+ *   - activity.clock_divergence  the in-memory clock advanced while the last
+ *                                successfully-published clock stayed frozen
+ *                                (i.e. the write chain stalled)
+ *
+ * daemon-core stays env-free and behaviorless: ActivityTracker only REPORTS what
+ * its flush loop did (onFlushError / onFlushSkip / getLastPublishedClockMs); all
+ * logging, thresholding, and health-event emission live here. The thresholds are
+ * module constants (they govern only WHEN an already-observable fact surfaces,
+ * never correctness), so no new env knob is introduced.
+ *
+ * A single successful/quiet flush emits nothing; only a failure, a persistent
+ * skip, or a sustained divergence surfaces -- never per-tick noise.
+ */
+import { healthEvents } from '@telora/daemon-core';
+import { createLogger } from '../log/daemon-log.js';
+const log = createLogger({ module: 'activity-clock' });
+const SOURCE = 'activity-clock';
+export const ACTIVITY_WRITE_FAILED_CODE = 'activity.write_failed';
+export const ACTIVITY_WRITE_SKIPPED_CODE = 'activity.write_skipped';
+export const ACTIVITY_CLOCK_DIVERGENCE_CODE = 'activity.clock_divergence';
+/**
+ * A skip streak (consecutive flushes that short-circuited without writing)
+ * lasting longer than this surfaces as a persistent-skip health fact. Below it,
+ * a one-off skip / healthy quiet chain stays quiet. A successful publish resets
+ * the streak.
+ */
+const SKIP_PERSIST_THRESHOLD_MS = 90_000;
+/**
+ * The in-memory clock leading the last-published clock by more than this is a
+ * stalled write chain and surfaces as a divergence health fact. Within it the
+ * two clocks are considered reconciled (normal flush lag) and stay quiet.
+ */
+const CLOCK_DIVERGENCE_THRESHOLD_MS = 90_000;
+const byFocus = new Map();
+function ensure(focusId, sessionId) {
+    const existing = byFocus.get(focusId);
+    if (existing) {
+        existing.sessionId = sessionId;
+        return existing;
+    }
+    const created = { sessionId, skipEmitted: false, divergenceActive: false };
+    byFocus.set(focusId, created);
+    return created;
+}
+/**
+ * Record a SUCCESSFUL publish of the focus's activity clock. Advances the last
+ * published value and resets the skip streak (a real write ends any skip run).
+ */
+export function recordPublishedClock(focusId, sessionId, clockMs) {
+    const state = ensure(focusId, sessionId);
+    state.lastPublishedClockMs = clockMs;
+    state.skipStreakStartMs = undefined;
+    state.skipEmitted = false;
+}
+/**
+ * A flush write FAILED or TIMED OUT. Surfaces the failure as a log line + a
+ * healthEvents entry naming the session, whether it timed out, and the error.
+ * Quiet on success by construction -- only the failure path calls this.
+ */
+export function recordFlushFailure(focusId, ctx) {
+    const kind = ctx.timedOut ? 'timed out' : 'failed';
+    const message = `activity-clock write ${kind} for session ${ctx.sessionId}: ${ctx.error.message}`;
+    log.warn(`[activity-clock] ${message} (focus ${focusId})`);
+    healthEvents.emit({
+        severity: 'warn',
+        source: SOURCE,
+        code: ACTIVITY_WRITE_FAILED_CODE,
+        message,
+    });
+}
+/**
+ * A flush was SKIPPED (re-entry guard or dirty-check). Tracks the streak and
+ * surfaces a persistent-skip health fact only when the streak outlasts the
+ * bounded window -- a one-off skip or a healthy quiet chain stays quiet.
+ */
+export function recordFlushSkip(focusId, ctx, now = Date.now()) {
+    const state = ensure(focusId, ctx.sessionId);
+    if (state.skipStreakStartMs === undefined) {
+        state.skipStreakStartMs = now;
+        return;
+    }
+    const streakMs = now - state.skipStreakStartMs;
+    if (streakMs <= SKIP_PERSIST_THRESHOLD_MS || state.skipEmitted)
+        return;
+    state.skipEmitted = true;
+    const message = `activity-clock write persistently skipped (${ctx.reason}) for ` +
+        `session ${ctx.sessionId} for ${streakMs}ms -- the published liveness clock ` +
+        `is not advancing though the session has not failed`;
+    log.warn(`[activity-clock] ${message} (focus ${focusId})`);
+    healthEvents.emit({
+        severity: 'warn',
+        source: SOURCE,
+        code: ACTIVITY_WRITE_SKIPPED_CODE,
+        message,
+    });
+}
+/**
+ * Compare the daemon's in-memory activity clock (per focus) against the last
+ * successfully-published clock and surface a divergence health fact when the
+ * in-memory clock leads the published one past the threshold -- i.e. the team is
+ * producing events but the write chain has stalled. Called at the heartbeat,
+ * where the in-memory clocks are assembled.
+ *
+ * Edge-triggered: emits once when a focus crosses into divergence and clears
+ * (silently) when it reconciles, so a sustained stall is not re-emitted per beat
+ * and a healthy chain within the threshold stays quiet.
+ *
+ * @param inMemoryByFocus focusId -> epoch ms of the in-memory activity clock.
+ */
+export function checkClockDivergence(inMemoryByFocus) {
+    for (const [focusId, state] of byFocus) {
+        const inMemory = inMemoryByFocus[focusId];
+        const published = state.lastPublishedClockMs;
+        if (inMemory === undefined || published === undefined)
+            continue;
+        const gapMs = inMemory - published;
+        if (gapMs > CLOCK_DIVERGENCE_THRESHOLD_MS) {
+            if (state.divergenceActive)
+                continue;
+            state.divergenceActive = true;
+            const message = `activity-clock divergence for session ${state.sessionId}: the in-memory ` +
+                `clock leads the last published clock by ${gapMs}ms -- the write chain has ` +
+                `stalled (the team is active but its published liveness clock is frozen)`;
+            log.warn(`[activity-clock] ${message} (focus ${focusId})`);
+            healthEvents.emit({
+                // 'warn', not 'error': the daemon is still functioning -- only the
+                // liveness surface has gone stale -- so this surfaces the stall without
+                // falsely flipping the whole daemon health badge to red.
+                severity: 'warn',
+                source: SOURCE,
+                code: ACTIVITY_CLOCK_DIVERGENCE_CODE,
+                message,
+            });
+        }
+        else if (state.divergenceActive) {
+            // Reconciled: clear the episode so a later divergence surfaces afresh.
+            state.divergenceActive = false;
+        }
+    }
+}
+/**
+ * Drop a focus's clock state on team reap (called beside clearTeamActivity), so
+ * a respawn of the same focus starts clean and no stale published clock lingers.
+ */
+export function clearFocusClock(focusId) {
+    byFocus.delete(focusId);
+}
+/** Test hatch: clear all registry state. */
+export function __resetActivityClockRegistryForTesting() {
+    byFocus.clear();
+}
+//# sourceMappingURL=activity-clock-registry.js.map

package/dist/daemon-state/activity-clock-registry.js.map

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent-state.d.ts","sourceRoot":"","sources":["../../src/daemon-state/agent-state.ts"],"names":[],"mappings":"AA0BA;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAIzE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI;IACpC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB,CAEA;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,qBAAqB,EAAE,MAAM,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,IAAI,CAIP;AAMD;;;GAGG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/dist/daemon-state/agent-state.js

@@ -0,0 +1,61 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/focus/activity-watchdog.test.ts
+// PINNED-BY-END
+/**
+ * Shared agent state module -- breaks the circular dependency between
+ * heartbeat.ts and the spawn/completion modules by centralizing state that both
+ * sides need.
+ *
+ * Contains:
+ * - Session completion counters (written by the completion path, read by heartbeat)
+ * - Activity tracking (written by the poll focus-poller pass, read by heartbeat)
+ *
+ * Team leads are tracked by the only live spawn path (`spawnFocusTeam`) in
+ * `activeTeams`, reaped by the single `reapWorkerFleet` teardown. See
+ * packages/daemon/CLAUDE.md.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/agent-state.ts).
+ */
+// ── Session completion counters ─────────────────────────────────────
+let completedSessionCount = 0;
+let totalTokensUsed = 0;
+let totalCost = 0;
+/**
+ * Record a completed session (called by spawner when an agent finishes).
+ */
+export function recordSessionCompleted(tokens, cost) {
+    completedSessionCount++;
+    totalTokensUsed += tokens;
+    totalCost += cost;
+}
+/**
+ * Get current session completion counters (read by heartbeat).
+ */
+export function getSessionCounters() {
+    return { completedSessionCount, totalTokensUsed, totalCost };
+}
+/**
+ * Bootstrap session counters from database values.
+ * Called by heartbeat on startup to reflect cumulative history.
+ */
+export function setSessionCounters(counters) {
+    completedSessionCount = counters.completedSessionCount;
+    totalTokensUsed = counters.totalTokensUsed;
+    totalCost = counters.totalCost;
+}
+// ── Activity tracking ───────────────────────────────────────────────
+let lastActivityAt = new Date();
+/**
+ * Record daemon activity. Call this whenever meaningful work occurs
+ * (spawning agents, completing sessions, polling, merges, etc.).
+ */
+export function recordActivity() {
+    lastActivityAt = new Date();
+}
+/**
+ * Get the last activity timestamp (for diagnostics/testing).
+ */
+export function getLastActivityAt() {
+    return lastActivityAt;
+}
+//# sourceMappingURL=agent-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent-state.js","sourceRoot":"","sources":["../../src/daemon-state/agent-state.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,iEAAiE;AACjE,gBAAgB;AAEhB;;;;;;;;;;;;;;GAcG;AAEH,uEAAuE;AAEvE,IAAI,qBAAqB,GAAG,CAAC,CAAC;AAC9B,IAAI,eAAe,GAAG,CAAC,CAAC;AACxB,IAAI,SAAS,GAAG,CAAC,CAAC;AAElB;;GAEG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAc,EAAE,IAAY;IACjE,qBAAqB,EAAE,CAAC;IACxB,eAAe,IAAI,MAAM,CAAC;IAC1B,SAAS,IAAI,IAAI,CAAC;AACpB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB;IAKhC,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC;AAC/D,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,QAIlC;IACC,qBAAqB,GAAG,QAAQ,CAAC,qBAAqB,CAAC;IACvD,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC;IAC3C,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;AACjC,CAAC;AAED,uEAAuE;AAEvE,IAAI,cAAc,GAAG,IAAI,IAAI,EAAE,CAAC;AAEhC;;;GAGG;AACH,MAAM,UAAU,cAAc;IAC5B,cAAc,GAAG,IAAI,IAAI,EAAE,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/daemon-state/auth-liveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-liveness.d.ts","sourceRoot":"","sources":["../../src/daemon-state/auth-liveness.ts"],"names":[],"mappings":"AAgCA,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,mEAAmE;IACnE,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AAKD,gDAAgD;AAChD,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAGnD;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2BpF"}

package/dist/daemon-state/auth-liveness.js

@@ -0,0 +1,75 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/daemon-state/auth-liveness.test.ts
+// PINNED-BY-END
+/**
+ * Tracker-auth liveness: halt the daemon when the tracker token is revoked.
+ *
+ * Startup validates the tracker token once (FocusEngine.init -> validateTrackerAuth),
+ * so the daemon refuses to start with a dead token. A token revoked WHILE the
+ * daemon is running would otherwise leave the 30s poll loop hitting 401/403
+ * forever (those statuses are non-retryable, so withRetry gives up per call,
+ * but the focus poller re-polls indefinitely). That "indefinite backoff-retry
+ * against a dead token" is what this module closes.
+ *
+ * A periodic tick re-validates the token. On a revoked/invalid token (HTTP
+ * 401/403) it halts the daemon ONCE via a graceful SIGTERM to self (the unified
+ * shell's signal handler runs the normal graceful shutdown). Transient failures
+ * (network unreachable, 5xx) are logged and ignored so a blip does not kill the
+ * daemon.
+ *
+ * Deps are injected so the tick is unit-testable without real network/process
+ * side effects.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/auth-liveness.ts).
+ */
+import { healthEvents } from '@telora/daemon-core';
+import { createLogger } from '../log/daemon-log.js';
+const log = createLogger({ module: 'auth-liveness' });
+/** One-shot guard so a revoked token triggers exactly one halt. */
+let haltRequested = false;
+/** Reset the one-shot halt guard. Test-only. */
+export function resetAuthLivenessGuard() {
+    haltRequested = false;
+}
+/**
+ * Classify an error from validateTrackerAuth: true => revoked/invalid token
+ * (HTTP 401/403), false => transient (network unreachable / 5xx). validateTrackerAuth
+ * uses the phrase "authentication failed" only for the 401/403 case, and a
+ * distinct message for unreachable/5xx, so we key off that.
+ */
+export function isAuthFailure(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /authentication failed/i.test(msg);
+}
+/**
+ * Run one auth-liveness tick. On a revoked/invalid token, emit a loud,
+ * actionable error + health event and halt the daemon exactly once. Transient
+ * errors are logged and ignored.
+ */
+export async function checkTrackerAuthLiveness(deps) {
+    try {
+        await deps.validate();
+    }
+    catch (err) {
+        if (!isAuthFailure(err)) {
+            log.warn('[auth-liveness] tracker auth re-check failed (transient -- not halting):', err.message);
+            return;
+        }
+        if (haltRequested)
+            return;
+        haltRequested = true;
+        const message = 'Tracker token is revoked or invalid -- halting daemon. ' +
+            'The daemon will not keep polling with a dead token. ' +
+            'Re-issue or replace the tracker in Telora Settings > AI Work Trackers, ' +
+            'update TELORA_TRACKER_ID, and restart the daemon.';
+        log.error(`${message}`);
+        healthEvents.emit({
+            severity: 'error',
+            source: 'auth-liveness',
+            code: 'auth.token_revoked_halt',
+            message,
+        });
+        deps.halt();
+    }
+}
+//# sourceMappingURL=auth-liveness.js.map

package/dist/daemon-state/auth-liveness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-liveness.js","sourceRoot":"","sources":["../../src/daemon-state/auth-liveness.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,oEAAoE;AACpE,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;AAUtD,mEAAmE;AACnE,IAAI,aAAa,GAAG,KAAK,CAAC;AAE1B,gDAAgD;AAChD,MAAM,UAAU,sBAAsB;IACpC,aAAa,GAAG,KAAK,CAAC;AACxB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY;IACxC,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC7D,OAAO,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,IAAsB;IACnE,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;IACxB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;YACxB,GAAG,CAAC,IAAI,CACN,0EAA0E,EACzE,GAAa,CAAC,OAAO,CACvB,CAAC;YACF,OAAO;QACT,CAAC;QACD,IAAI,aAAa;YAAE,OAAO;QAC1B,aAAa,GAAG,IAAI,CAAC;QACrB,MAAM,OAAO,GACX,yDAAyD;YACzD,sDAAsD;YACtD,yEAAyE;YACzE,mDAAmD,CAAC;QACtD,GAAG,CAAC,KAAK,CAAC,GAAG,OAAO,EAAE,CAAC,CAAC;QACxB,YAAY,CAAC,IAAI,CAAC;YAChB,QAAQ,EAAE,OAAO;YACjB,MAAM,EAAE,eAAe;YACvB,IAAI,EAAE,yBAAyB;YAC/B,OAAO;SACR,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/daemon-state/awaiting-slot.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Focuses the spawn passes left waiting for a session slot.
+ *
+ * When every session slot is in use (active teams >= maxTotalSessions) the spawn
+ * passes (focus/focus-poller-spawn.ts) start no further team. A focus they would
+ * otherwise have spawned a team for would then have no in-memory trace at all --
+ * no team, no queued directive it can act on, no cooldown, no completion latch --
+ * so team-liveness-phase publication (completion/team-liveness/team-liveness-phase.ts) would have nothing to
+ * publish. This module is that trace: the set the passes record, which
+ * team-liveness-phase publishes as `awaiting_slot`.
+ *
+ * Each pass (the ready-focus pass and the pending-spawn pass) owns its own set and
+ * REPLACES it wholesale every time it evaluates, so a focus that stops being
+ * spawnable -- or whose team starts -- drops out on that pass's next run with no
+ * per-transition clear wiring (the same pull-model shape as the rest of
+ * team-liveness-phase). A pass records only a focus that cleared every non-capacity gate
+ * (known role, no active team, not held by a verify hold, not in spawn cooldown),
+ * so a held, cooling-down or never-armed focus is never recorded here.
+ *
+ * A LEAF: it imports nothing, so both the spawn passes and team-liveness-phase read it
+ * without a cycle.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (daemon-state/awaiting-slot.ts).
+ */
+/** The spawn pass that recorded a set: processReadyFocuses or processPendingSpawnFocuses. */
+export type SpawnPass = 'ready' | 'pending';
+/** Replace one pass's awaiting-slot set with the focuses it left waiting this run (empty clears it). */
+export declare function setAwaitingSlotFocuses(pass: SpawnPass, focusIds: Iterable<string>): void;
+/** Every focus some pass left waiting for a slot (the union of both passes, deduplicated). */
+export declare function getAwaitingSlotFocusIds(): string[];
+/** Whether some pass left this focus waiting for a slot on its latest run. */
+export declare function isAwaitingSlot(focusId: string): boolean;
+/** Test-only: clear both passes' sets so state never leaks across tests. */
+export declare function __resetAwaitingSlotForTesting(): void;
+//# sourceMappingURL=awaiting-slot.d.ts.map

package/dist/daemon-state/awaiting-slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaiting-slot.d.ts","sourceRoot":"","sources":["../../src/daemon-state/awaiting-slot.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,6FAA6F;AAC7F,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAO5C,wGAAwG;AACxG,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAExF;AAED,8FAA8F;AAC9F,wBAAgB,uBAAuB,IAAI,MAAM,EAAE,CAElD;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED,4EAA4E;AAC5E,wBAAgB,6BAA6B,IAAI,IAAI,CAGpD"}

package/dist/daemon-state/awaiting-slot.js

@@ -0,0 +1,26 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/focus/awaiting-slot.test.ts,
+//   packages/daemon/src/focus/heartbeat-team-liveness-phases.test.ts
+// PINNED-BY-END
+const awaitingSlotByPass = {
+    ready: new Set(),
+    pending: new Set(),
+};
+/** Replace one pass's awaiting-slot set with the focuses it left waiting this run (empty clears it). */
+export function setAwaitingSlotFocuses(pass, focusIds) {
+    awaitingSlotByPass[pass] = new Set(focusIds);
+}
+/** Every focus some pass left waiting for a slot (the union of both passes, deduplicated). */
+export function getAwaitingSlotFocusIds() {
+    return [...new Set([...awaitingSlotByPass.ready, ...awaitingSlotByPass.pending])];
+}
+/** Whether some pass left this focus waiting for a slot on its latest run. */
+export function isAwaitingSlot(focusId) {
+    return awaitingSlotByPass.ready.has(focusId) || awaitingSlotByPass.pending.has(focusId);
+}
+/** Test-only: clear both passes' sets so state never leaks across tests. */
+export function __resetAwaitingSlotForTesting() {
+    awaitingSlotByPass.ready = new Set();
+    awaitingSlotByPass.pending = new Set();
+}
+//# sourceMappingURL=awaiting-slot.js.map

package/dist/daemon-state/awaiting-slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaiting-slot.js","sourceRoot":"","sources":["../../src/daemon-state/awaiting-slot.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,8DAA8D;AAC9D,qEAAqE;AACrE,gBAAgB;AA8BhB,MAAM,kBAAkB,GAA2C;IACjE,KAAK,EAAE,IAAI,GAAG,EAAE;IAChB,OAAO,EAAE,IAAI,GAAG,EAAE;CACnB,CAAC;AAEF,wGAAwG;AACxG,MAAM,UAAU,sBAAsB,CAAC,IAAe,EAAE,QAA0B;IAChF,kBAAkB,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;AAC/C,CAAC;AAED,8FAA8F;AAC9F,MAAM,UAAU,uBAAuB;IACrC,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,kBAAkB,CAAC,KAAK,EAAE,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACpF,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,cAAc,CAAC,OAAe;IAC5C,OAAO,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,kBAAkB,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC1F,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,6BAA6B;IAC3C,kBAAkB,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC;IACrC,kBAAkB,CAAC,OAAO,GAAG,IAAI,GAAG,EAAE,CAAC;AACzC,CAAC"}

package/dist/daemon-state/daemon-instance.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Daemon INSTANCE ownership of a session row -- the SESSION half.
+ *
+ * The instance-IDENTITY half (`daemonInstanceId`, `parseDaemonInstanceId`,
+ * `classifyOwningInstance` and friends) lives in daemon-state/instance-liveness.ts;
+ * import it from there. The two halves are separate modules because THIS module imports
+ * daemon-state/worker-pidfile.ts, so the pidfile could not ask the identity question
+ * back; see that module's header for the whole reason.
+ *
+ * What is left here is the question recovery actually has to answer before it
+ * writes `failed`: has the team this row represents actually stopped? An
+ * instance id answers "is the daemon that wrote this row still running?", and a
+ * row whose owner is alive, or whose owner cannot be determined, is left alone.
+ *
+ * A dead owner is NOT on its own proof that the row's team stopped. Team leads
+ * are spawned DETACHED, so they survive a hard-killed daemon; the boot reap
+ * that ends them (`reapAndClearWorkerPidfile`, unified-shell) is explicitly
+ * best-effort -- a missing or malformed pidfile yields no entries and a failed
+ * kill is swallowed. So the destructive pass needs a SECOND proof, about the
+ * session's own process: `classifySessionProcess`. Both must agree before a row
+ * is closed.
+ *
+ * @module daemon-state/daemon-instance
+ */
+import type { AgentSession } from '../types/index.js';
+import { type InstanceProbeDeps } from './instance-liveness.js';
+/**
+ * What the SESSION's own process is doing -- the second proof, about the team
+ * rather than the daemon that spawned it.
+ *
+ * - `alive`               -- this session's recorded lead is still running.
+ * - `stopped`             -- it is not: gone, or its pid was recycled onto an
+ *                            unrelated process.
+ * - `no_process_recorded` -- the host's lead record is readable and names no
+ *                            lead for this session, so none was ever spawned.
+ * - `unprovable`          -- nothing can be shown: the record could not be read,
+ *                            or it names a process whose identity cannot be
+ *                            verified (a reservation still in flight, a pid with
+ *                            no recorded or no readable start identity). An
+ *                            anonymous live pid is NOT an alive team.
+ *
+ * A RESERVATION used to land in `unprovable` unconditionally, and permanently:
+ * see `classifyRecordedProcess` for why one whose reserving instance is provably
+ * gone now answers `stopped` instead.
+ */
+export type SessionProcessLiveness = 'alive' | 'stopped' | 'no_process_recorded' | 'unprovable';
+/** Process probes for the session-liveness check, injectable for tests. */
+export interface SessionProcessProbes {
+    isProcessAlive: (pid: number) => boolean;
+    isProcessGroupAlive: (pgid: number) => boolean;
+    readStartIdentity: (pid: number) => string | null;
+    /**
+     * The host's durable lead records by session id, or null when they cannot be
+     * read. Null is UNKNOWN, never "nothing is running".
+     */
+    leadRecordsBySession: () => Map<string, RecordedProcess> | null;
+    /**
+     * Is a reservation's reserving daemon instance still running? The ONE
+     * definition lives in daemon-state/instance-liveness.ts
+     * (`isReservationInFlight`); the host probes bind to it at the composition
+     * root. Absent/empty `reservedBy` is in flight -- see there
+     * for the direction-of-failure argument.
+     */
+    reservationInFlight: (reservedBy: string | undefined) => boolean;
+}
+/**
+ * The shape `classifyRecordedProcess` reads out of the lead record: a
+ * `WorkerPidEntry`, narrowed to the fields the verdict depends on.
+ * `readLeadRecordsBySession` already hands back whole entries, so `reservedBy`
+ * arrives with no read change -- it simply had no reader.
+ */
+export interface RecordedProcess {
+    pid: number;
+    startIdentity?: string;
+    pending?: true;
+    /** The daemon instance that made a reservation. Only meaningful with `pending`. */
+    reservedBy?: string;
+}
+/**
+ * What this record's process is doing: running, gone, or not decidable.
+ *
+ * The third answer is the one that was missing. A live pid ALONE does not
+ * identify our lead, so treating "alive" as proof let an identity-less record
+ * -- or one whose identity could not be read -- nominate whatever process
+ * happens to hold that number as the session's writer. That is how a stale row
+ * keeps reading `running` and invents a writer for a quiescent worktree.
+ *
+ * So: alive AND verifiably ours -> `alive`. Provably absent -> `gone`. Anything
+ * in between -- no recorded identity, an unreadable live identity, a pid we
+ * cannot probe -- is `indeterminate`, and each caller applies its OWN safe
+ * direction to it rather than inheriting one that only suits recovery.
+ *
+ * A RESERVATION is the fourth case, and it is a JUDGEMENT rather than a shrug.
+ * The retention passes (`reapAndClearWorkerPidfile`,
+ * `clearWorkerPidfileIfAllGone`) run only at boot, hard stop and shutdown; in
+ * between, a LIVE daemon's sweeps read the record through here. While this
+ * branch answered `indeterminate` unconditionally, a reservation stranded by a
+ * hard kill between `reserveLeadRecord` and the pid write made its session
+ * undecidable FOREVER: session-health skipped the row `unprovable_process`,
+ * abandoned-merge recovery refused to restore its worktree, and the worktree
+ * write signal answered `provable: false`. Nothing could ever improve that read,
+ * because the instance that would have resolved the reservation no longer
+ * exists. So the reservation is judged by its `reservedBy`: in flight ->
+ * `indeterminate` exactly as before; provably gone -> `gone`. The full argument
+ * for why `gone` is sound HERE while this module refuses that inference
+ * everywhere else -- in short, a pid-0 row is already unnameable by every kill
+ * path, so retiring it forfeits no capability -- is at
+ * `isReservationInFlight` (daemon-state/instance-liveness.ts).
+ */
+export type RecordedProcessState = 'alive' | 'gone' | 'indeterminate';
+export declare function classifyRecordedProcess(record: RecordedProcess, probes: SessionProcessProbes): RecordedProcessState;
+/**
+ * Classify the session's own process, from the host's DURABLE LEAD RECORD rather
+ * than from the session row's pid.
+ *
+ * The row's pid cannot answer this, for two reasons found in review:
+ *
+ * 1. It arrives TOO LATE. `launchLeadProcess` spawns the detached lead and
+ *    records it, and only afterwards does `spawnTeamProcess` persist
+ *    `{ status: 'running', pid }`. A hard kill or a failed API write in that
+ *    window leaves a `starting` row with a null pid AND a live team. Reading
+ *    that as "no process was spawned" closes a row whose team is running.
+ *
+ * 2. It is UNVERIFIABLE. A bare pid says nothing about WHICH process holds it
+ *    now, so an unrelated process that recycled the number would keep a stale
+ *    row `running` -- and `isWorktreeBeingWritten` would report a writer that
+ *    does not exist.
+ *
+ * The lead record fixes both: it is written BEFORE the row's pid, and it carries
+ * the spawn-time start identity. Its absence is only evidence when the record
+ * itself is readable; an unreadable record is `unprovable`, never `stopped`.
+ */
+export declare function classifySessionProcess(sessionId: string, probes: SessionProcessProbes): SessionProcessLiveness;
+/**
+ * Split the scoped candidates into the ones recovery may close and the ones it
+ * must leave alone, with the reason it spared each group.
+ *
+ * TWO proofs are required, and a row is closed only when both agree.
+ *
+ * 1. Its OWNER is gone. The host scope answers "whose machine", but a machine
+ *    is not an owner: two daemon instances share a host. Our own live session,
+ *    a peer instance still running, an unattributable or remote id -- all spared.
+ *
+ * 2. Its own PROCESS is gone. A dead owner does NOT imply a stopped team: team
+ *    leads are spawned detached and survive a hard-killed daemon, and the boot
+ *    reap that ends them is best-effort by design (a missing or malformed
+ *    pidfile yields no entries; a failed kill is swallowed). So a live team
+ *    whose daemon was `kill -9`ed reaches this pass, and closing its row is
+ *    exactly the falsification the criterion forbids.
+ *
+ * The asymmetry is deliberate. A stale `running` row is visible and the next
+ * sweep re-examines it. A LIVE session marked `failed` is invisible and wrong:
+ * it tells every reader -- the dashboard, and `isWorktreeBeingWritten` -- that a
+ * running team is not there, which is how a worktree under active write comes to
+ * read as quiescent. This pass never kills anything to make its own proof true;
+ * ending a surviving orphan belongs to the identity-verified reap paths
+ * (`reapAndClearWorkerPidfile`, the untracked-lead sweep), and once they do, the
+ * next sweep reads the process as stopped and closes the row.
+ */
+export declare function partitionReapableSessions(sessions: readonly AgentSession[], probes: InstanceProbeDeps, processProbes: SessionProcessProbes): {
+    reapable: AgentSession[];
+    spared: Map<string, string[]>;
+};
+/**
+ * Where the two probe families come from. Factories, not probe objects: each
+ * sweep takes a fresh session-probe object, whose lead-record read is memoized
+ * for that sweep only. Bound at the composition root
+ * (composition/execution-process-context.ts).
+ */
+export interface RecoveryProbeSource {
+    instanceProbes: () => InstanceProbeDeps;
+    sessionProcessProbes: () => SessionProcessProbes;
+}
+/**
+ * The subset of `sessions` crash recovery may close, logging what it spared and
+ * why. The one call recovery makes: everything it returns has a provably
+ * stopped owner, and everything it withheld is named in the log rather than
+ * silently dropped.
+ */
+export declare function reconcileOwnedSessions(sessions: readonly AgentSession[], probeSource: RecoveryProbeSource): AgentSession[];
+//# sourceMappingURL=daemon-instance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-instance.d.ts","sourceRoot":"","sources":["../../src/daemon-state/daemon-instance.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAC;AAIhC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,SAAS,GAAG,qBAAqB,GAAG,YAAY,CAAC;AAEhG,2EAA2E;AAC3E,MAAM,WAAW,oBAAoB;IACnC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACzC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;IAClD;;;OAGG;IACH,oBAAoB,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,IAAI,CAAC;IAChE;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;CAClE;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,MAAM,GAAG,eAAe,CAAC;AAEtE,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,CAuBtB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,oBAAoB,GAC3B,sBAAsB,CAUxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,MAAM,EAAE,iBAAiB,EACzB,aAAa,EAAE,oBAAoB,GAClC;IAAE,QAAQ,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CAAE,CAqC7D;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,MAAM,iBAAiB,CAAC;IACxC,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,WAAW,EAAE,mBAAmB,GAC/B,YAAY,EAAE,CAUhB"}