@telora/daemon 0.22.245 → 0.22.289

package/dist/completion/team-outcome/work-facts.js

@@ -0,0 +1,234 @@
+// 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/team-progress/progress-guards-recorded-intent.test.ts
+// PINNED-BY-END
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { isStatusCascadable, isStatusAgentActionable } from '../../workflow/stage-classifier.js';
+import { armFactsFromTeamState } from '../../supervision/recorded-new-intent.js';
+import { armVisibleProgressInputs } from '../team-progress/arm-visible-progress-inputs.js';
+import { isAuditPhaseFocus } from '../../audit/audit-shape.js';
+import { advancementReadFailsOpen } from '../../workflow/gate-failure-policy.js';
+import { shouldCheckNonAdvanceable } from '../completion-event/completion-decision.js';
+import { takeProgressSnapshot, snapshotsEqual } from '../team-progress/progress-snapshot.js';
+import { findNonAdvanceableDelivery } from '../completion-event/advanceability.js';
+import { resolveTeamActionableWork } from '../../worktree/verify-hold-facts.js';
+import { deliveriesWithTeamWork } from '../../supervision/team-work.js';
+import { resolveFocusHead, readUnnamedUnclaimedMigration } from '../completion-event/completion-fact-readers.js';
+import { NO_PROGRESS_CYCLE_FLOOR_MS, NO_PROGRESS_STALL_WINDOW_MS } from './exit-limits.js';
+import { DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT, SCOPE_COVERAGE_NO_PROGRESS_LIMIT } from './exit-limit-config.js';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'focus-executor' });
+/**
+ * Recompute the picture on the post-advance state. The team owns exactly two
+ * kinds of non-terminal work: planning deliveries (it scopes them) and
+ * agent-actionable deliveries that still carry open issues (it codes them).
+ * See the inline notes for the audit-phase, verify_failed-pending-requeue,
+ * and advancedThisCycle subtleties -- each guards a specific production
+ * failure mode and is preserved exactly.
+ */
+/**
+ * Resolve whether the focus is in the human-ratify audit phase, so its held
+ * `planning` deliveries are NOT counted as team-actionable.
+ *
+ * A read_only focus is awaiting the ratify gate: counting its planning
+ * deliveries as actionable made a not-yet-ratified audit focus accrue
+ * no-progress cycles it could never clear -> a spurious no-progress team_failure
+ * (escalation aa58d9c3). Resolve FRESH: an explicit read_only=true OR the second
+ * structural signal (audit-origin AND not-yet-ratified), so a flag-absent audit
+ * focus still degrades gracefully (injection #7). FAIL OPEN to not-audit-phase so
+ * a lookup failure preserves the prior (escalate-eligible) behavior rather than
+ * silently muting the guard. Extracted from computeCompletionFacts (size ratchet).
+ */
+export async function resolveFocusAuditPhase(ctx, deps) {
+    try {
+        const st = await deps.getFocusRatificationState(ctx.config, ctx.focusId);
+        return isAuditPhaseFocus({
+            readOnly: st.readOnly,
+            auditOrigin: st.auditOrigin ?? false,
+            ratified: st.ratifiedAt != null,
+        });
+    }
+    catch (err) {
+        // ADVANCEMENT/LIVENESS read -> FAIL OPEN: treat as not-audit-phase so the team
+        // keeps working on a transient read error rather than being parked.
+        return advancementReadFailsOpen(`work-facts ratification "${ctx.focusName}"`, err, false);
+    }
+}
+async function resolveTeamOwnedWork(ctx, deps, effectiveDeliveries, currentIssues) {
+    const { focusId, teamState } = ctx;
+    // Every fact below judges what the RUNNING ARM owes, so it is derived from
+    // the arm-visible set (see supervision/recorded-new-intent.ts) -- deliveries AND
+    // the issues that belong to them, narrowed together so the no-progress
+    // measurements below cannot count work the team was never shown.
+    const { deliveries: armVisibleDeliveries, issues: armVisibleIssues } = armVisibleProgressInputs(effectiveDeliveries, currentIssues, armFactsFromTeamState(teamState));
+    const postNonTerminal = armVisibleDeliveries.filter(d => !isStatusCascadable(d.executionStatus ?? ''));
+    const focusAuditPhase = await resolveFocusAuditPhase(ctx, deps);
+    // The ONE team-work predicate (worktree/verify-hold-facts.ts
+    // deliveriesWithTeamWork), which the continuation stamp and the spawn gate
+    // read too: an open work issue on an agent-actionable delivery, or a planning
+    // delivery to scope. Planning counts ONLY on a non-audit-phase focus (where the
+    // team is expected to scope it); on an audit-phase focus it awaits
+    // ratification, so it does not keep the team on the no-progress path. A
+    // genuinely stuck planning delivery on a NORMAL focus still escalates
+    // (true-positive preserved). A queued delivery with zero open issues
+    // contributes nothing, so a not-yet-started queued delivery does not, on its
+    // own, accrue no-progress cycles.
+    const workDeliveries = deliveriesWithTeamWork(armVisibleDeliveries, currentIssues, {
+        planningIsWork: !focusAuditPhase,
+    });
+    const hasPlanning = workDeliveries.some(d => d.executionStatus === DELIVERY_STATUS.PLANNING);
+    const postHasActionableOpen = workDeliveries.some(d => d.executionStatus !== DELIVERY_STATUS.PLANNING);
+    // Raw actionable-work fact; folded through the shared verify-hold predicate below.
+    const rawTeamHasActionableWork = hasPlanning || postHasActionableOpen;
+    // A non-terminal delivery the team has never been told about (id absent from
+    // knownDeliveryIds) is work to HAND OFF, not work the team is failing to
+    // advance. A delivery added to a running focus defaults to `queued` with zero
+    // issues, so it satisfies neither hasPlanning nor postHasActionableOpen --
+    // teamHasActionableWork is false and, before this fact existed, the completion
+    // decision terminated the team before the delivery was ever handed over. This
+    // separates the two questions the single predicate could not: knownDeliveryIds
+    // carries the "has the team seen it?" signal, so a not-yet-started delivery is
+    // handoff-eligible (this fact) WITHOUT counting toward the no-progress guard
+    // (teamHasActionableWork, unchanged -- the load-bearing 2026-07-03 constraint).
+    // Scoped to AGENT-ACTIONABLE (queued / coding / verify_failed) so it matches
+    // exactly the set buildWakeMessage renders: an unknown but non-actionable
+    // delivery (paused / in_review, owned by another subsystem) is NOT something to
+    // hand a coding team, and routing to a handoff that produced an empty wake
+    // message would just spin the detector. Planning deliveries are already carried
+    // by hasPlanning (non-audit) or deliberately held (audit), so they are not
+    // double-counted here.
+    const hasNewlyAppearedDelivery = armVisibleDeliveries.some(d => isStatusAgentActionable(d.executionStatus ?? '') && !teamState.knownDeliveryIds.has(d.id));
+    const { focusWorktreePath, focusHeadSha } = resolveFocusHead(focusId, deps);
+    // Fold the verify-interlock hold into actionable-work through the ONE shared
+    // predicate (worktree/verify-hold-facts.ts) the spawn gate also reads. The hold
+    // withholds only the verified delivery: a sibling's open work keeps the team.
+    const { underVerifyHold, teamHasActionableWork } = resolveTeamActionableWork({
+        focusWorktreePath,
+        hasUnheldActionableWork: rawTeamHasActionableWork,
+        isWorktreeUnderVerify: deps.isWorktreeUnderVerify,
+        outsideHold: { deliveries: armVisibleDeliveries, issues: currentIssues, verifyHeldDeliveryIds: deps.verifyHeldDeliveryIds },
+        // An outstanding merge-conflict resolution request is actionable work through
+        // the one shared predicate, agreeing with the merge-resolution-hold phase (61ee33eb).
+        mergeResolutionOutstanding: teamState.resolvingMergeConflict,
+        unclaimedMigrationUnnamed: await readUnnamedUnclaimedMigration(focusId, deps),
+    });
+    return {
+        armVisibleDeliveries, armVisibleIssues, postNonTerminal, postHasActionableOpen,
+        teamHasActionableWork, underVerifyHold, hasNewlyAppearedDelivery, focusWorktreePath, focusHeadSha,
+    };
+}
+/** The no-progress counter after this cycle's reset, sub-floor hold, or increment. */
+function advanceNoProgressCounter(teamState, focusName, madeProgress, nowMs) {
+    // The no-progress counter value AFTER this cycle's reset-or-increment.
+    // Only committed to teamState on the actionable-work paths in
+    // executeCompletionAction -- the no-actionable-work terminations deliberately
+    // do not touch the counter. A team can no longer file a directed hold (an
+    // armed focus never waits on a human mid-flight), so there is no blocked-team
+    // freeze: no progress this cycle is a plain increment toward the stall guard.
+    //
+    // TIME FLOOR (the leverage of this focus): a counted cycle must cost real
+    // time. A no-progress completion arriving less than NO_PROGRESS_CYCLE_FLOOR_MS
+    // after the last COUNTED cycle is a burst artifact, not a genuine opportunity
+    // to work, so it HOLDS the counter (does not increment) rather than climbing
+    // toward the limit. This bounds EVERY cause of a fast cycle -- present and
+    // future -- not just the handoff spin the sibling delivery removes. The
+    // first-cycle rule above (priorSnapshot===null => madeProgress) is untouched:
+    // a fresh/respawned team still resets to 0 here.
+    const lastCountedCycleAt = teamState.lastNoProgressCycleAt ?? null;
+    let updatedNoProgressCycles;
+    let noProgressCycleCounted;
+    let updatedLastNoProgressCycleAt;
+    if (madeProgress) {
+        updatedNoProgressCycles = 0;
+        noProgressCycleCounted = false;
+        updatedLastNoProgressCycleAt = undefined; // progress ends the dirty episode
+    }
+    else if (lastCountedCycleAt !== null &&
+        nowMs - lastCountedCycleAt < NO_PROGRESS_CYCLE_FLOOR_MS) {
+        // Sub-floor: arrived too fast to be a real chance to work. Deliberate
+        // non-count -- never silently dropped, never reported as progress (AC3).
+        updatedNoProgressCycles = teamState.noProgressCycles ?? 0;
+        noProgressCycleCounted = false;
+        updatedLastNoProgressCycleAt = lastCountedCycleAt; // floor from last COUNTED cycle
+        log.info(`No-progress cycle for "${focusName}" arrived ${nowMs - lastCountedCycleAt}ms after ` +
+            `the last counted cycle (< ${NO_PROGRESS_CYCLE_FLOOR_MS}ms floor) -- deliberately NOT ` +
+            `counted (held at ${updatedNoProgressCycles}); a counted cycle must cost real time.`);
+    }
+    else {
+        updatedNoProgressCycles = (teamState.noProgressCycles ?? 0) + 1;
+        noProgressCycleCounted = true;
+        updatedLastNoProgressCycleAt = nowMs;
+    }
+    return { updatedNoProgressCycles, noProgressCycleCounted, updatedLastNoProgressCycleAt };
+}
+export async function buildTeamWorkFacts(ctx, deps, currentDeliveries, effectiveDeliveries, currentIssues) {
+    const { focusId, focusName, teamState } = ctx;
+    const owned = await resolveTeamOwnedWork(ctx, deps, effectiveDeliveries, currentIssues);
+    const { armVisibleDeliveries, armVisibleIssues, postNonTerminal, teamHasActionableWork, focusWorktreePath, focusHeadSha, } = owned;
+    // Capture the (post-advance) snapshot for progress detection. Treat both null
+    // and undefined as "no prior snapshot" -- legacy test fixtures may not set
+    // the field, and a fresh team has lastProgressSnapshot=null.
+    // Measured over the arm-visible pair: an issue on a RECORDED delivery is not
+    // a progress axis, because the running team cannot see or move it.
+    // The team-activity axes of the ONE progress measure: agent activity since the
+    // previous cycle and the worktree's uncommitted diff (team-progress-measure.ts).
+    const activity = deps.readTeamActivityMarks(focusId, focusWorktreePath);
+    const snapshot = takeProgressSnapshot(armVisibleDeliveries, armVisibleIssues, focusHeadSha, activity);
+    const priorSnapshot = teamState.lastProgressSnapshot ?? null;
+    // verify_failed-pending-requeue is daemon-owned advancement: a delivery left
+    // in verify_failed is waiting on the daemon's transparent requeue
+    // (focus-poller-auto-advance); the TEAM cannot move it. It resets the no-progress
+    // counter (madeProgress) but is deliberately NOT folded into
+    // advancedThisCycle -- a NULL-stage verify_failed is wedged, not pending, and
+    // must remain eligible for the non-advanceable dead-end escalation.
+    const verifyFailedPendingRequeue = armVisibleDeliveries.some(d => (d.executionStatus ?? '') === 'verify_failed');
+    const madeProgress = verifyFailedPendingRequeue || priorSnapshot === null
+        ? true
+        : !snapshotsEqual(priorSnapshot, snapshot);
+    // Did the team *positively advance* state this cycle? Distinct from
+    // madeProgress: a null prior snapshot (a FRESH or RESPAWNED team) is NOT
+    // evidence of advancement. The daemon respawns a wedged focus's team every
+    // poll, so the handler always sees priorSnapshot === null there -- gating the
+    // dead-end guard on !madeProgress made it unreachable and the focus churned
+    // forever; !advancedThisCycle keeps it reachable.
+    const advancedThisCycle = priorSnapshot !== null && !snapshotsEqual(priorSnapshot, snapshot);
+    // Non-advanceability lookup, gated by shouldCheckNonAdvanceable: scoped to
+    // agent-actionable deliveries (queued / coding / verify_failed) -- the states
+    // the team is *expected* to move. Daemon/review-managed states (in_review,
+    // paused) are deliberately excluded: another subsystem owns advancing them.
+    let stuck = null;
+    if (shouldCheckNonAdvanceable({ teamHasActionableWork, advancedThisCycle })) {
+        const candidates = postNonTerminal.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
+        stuck = await findNonAdvanceableDelivery(candidates, deps.fetchEffectiveWorkflow);
+    }
+    const nowMs = deps.now();
+    const counter = advanceNoProgressCounter(teamState, focusName, madeProgress, nowMs);
+    // The real-time window: measured from the last cycle the measure read as
+    // progress (or the team's start), so a count of the daemon's own wake-ups can
+    // never stand in for a team that has actually been still.
+    const updatedLastProgressAt = madeProgress
+        ? nowMs
+        : teamState.lastProgressAt ?? teamState.startedAtMs;
+    const stallWindowElapsed = nowMs - updatedLastProgressAt >= NO_PROGRESS_STALL_WINDOW_MS;
+    return {
+        ...owned,
+        currentDeliveries,
+        effectiveDeliveries,
+        currentIssues,
+        snapshot,
+        priorSnapshot,
+        madeProgress,
+        advancedThisCycle,
+        stuck,
+        ...counter,
+        nowMs,
+        updatedLastProgressAt,
+        stallWindowElapsed,
+        noProgressLimits: {
+            scopeCoverage: SCOPE_COVERAGE_NO_PROGRESS_LIMIT,
+            deliveryAdvancement: DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT,
+        },
+    };
+}
+//# sourceMappingURL=work-facts.js.map

package/dist/completion/team-outcome/work-facts.js.map

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

package/dist/completion/team-progress/arm-visible-progress-inputs.d.ts

@@ -0,0 +1,53 @@
+/**
+ * What the progress guards are allowed to MEASURE: the deliveries the running
+ * arm covers, and the issues that belong to them.
+ *
+ * WHY BOTH HALVES, AND WHY IN ONE PLACE. The completion path narrows its
+ * DELIVERY list to the arm (`deliveriesVisibleToArm`), and the two no-progress
+ * watchdogs read the ISSUE list too:
+ *
+ *   - `takeProgressSnapshot` (completion/team-progress/progress-snapshot.ts) counts
+ *     `issues.length` as a progress axis, and
+ *   - `recordDeliveryAdvancementCycle` (completion/team-progress/delivery-advancement-guard.ts)
+ *     fingerprints `{issueId -> status}` as its cross-respawn progress axis.
+ *
+ * A half-narrowed input is worse than an un-narrowed one, because the two
+ * halves then disagree about what the arm owes. The issues of a RECORDED
+ * delivery are work the running team cannot see, cannot start and cannot
+ * advance -- it is invisible to it by construction -- so, left un-narrowed, they
+ * would sit inside both measurements: a frozen block that never moves on the one hand, and, whenever
+ * an agent files or edits an issue on that recorded delivery, a change on a
+ * dimension the team did not move on the other. Either way the guard is reading
+ * a signal that does not answer its own question ("did the team advance the
+ * work the arm gave it?"), and the worse direction files a `team_failure`
+ * against a team that was never shown the work -- the exact wedge the
+ * record/queue rule exists to prevent.
+ *
+ * So the narrowing is done ONCE, here, over the ONE predicate
+ * (`supervision/recorded-new-intent.ts`), and both guards read the result. A delivery
+ * and its issues enter or leave the measurement together.
+ *
+ * FAIL-CLOSED DEFAULT: unknown/absent arm facts yield an empty recorded set, so
+ * both lists pass through untouched and every guard measures the whole focus.
+ * An issue whose
+ * `deliveryId` matches no delivery in the list is KEPT for the same reason --
+ * nothing proves it belongs to recorded intent.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/team-progress/arm-visible-progress-inputs.ts).
+ */
+import type { FocusDeliveryInfo, FocusIssueInfo } from '../../types/index.js';
+import { type ArmFacts } from '../../supervision/recorded-new-intent.js';
+/** The delivery + issue pair every no-progress measurement is taken over. */
+export interface ArmVisibleProgressInputs {
+    /** `deliveries` minus anything recorded as new intent under the live arm. */
+    deliveries: FocusDeliveryInfo[];
+    /** `issues` minus every issue belonging to one of those recorded deliveries. */
+    issues: FocusIssueInfo[];
+}
+/**
+ * Narrow a focus's deliveries AND its issues to what the running arm covers.
+ *
+ * `armFacts` null/undefined => both lists are returned unchanged.
+ */
+export declare function armVisibleProgressInputs(deliveries: FocusDeliveryInfo[], issues: FocusIssueInfo[], armFacts: ArmFacts | null | undefined): ArmVisibleProgressInputs;
+//# sourceMappingURL=arm-visible-progress-inputs.d.ts.map

package/dist/completion/team-progress/arm-visible-progress-inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arm-visible-progress-inputs.d.ts","sourceRoot":"","sources":["../../../src/completion/team-progress/arm-visible-progress-inputs.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAEL,KAAK,QAAQ,EACd,MAAM,0CAA0C,CAAC;AAElD,6EAA6E;AAC7E,MAAM,WAAW,wBAAwB;IACvC,6EAA6E;IAC7E,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,gFAAgF;IAChF,MAAM,EAAE,cAAc,EAAE,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,iBAAiB,EAAE,EAC/B,MAAM,EAAE,cAAc,EAAE,EACxB,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,GACpC,wBAAwB,CAO1B"}

package/dist/completion/team-progress/arm-visible-progress-inputs.js

@@ -0,0 +1,19 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/team-progress/progress-guards-recorded-intent.test.ts
+// PINNED-BY-END
+import { recordedNewIntentDeliveryIds, } from '../../supervision/recorded-new-intent.js';
+/**
+ * Narrow a focus's deliveries AND its issues to what the running arm covers.
+ *
+ * `armFacts` null/undefined => both lists are returned unchanged.
+ */
+export function armVisibleProgressInputs(deliveries, issues, armFacts) {
+    const recordedIds = recordedNewIntentDeliveryIds(deliveries, armFacts);
+    if (recordedIds.size === 0)
+        return { deliveries, issues };
+    return {
+        deliveries: deliveries.filter(d => !recordedIds.has(d.id)),
+        issues: issues.filter(i => !recordedIds.has(i.deliveryId)),
+    };
+}
+//# sourceMappingURL=arm-visible-progress-inputs.js.map

package/dist/completion/team-progress/arm-visible-progress-inputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arm-visible-progress-inputs.js","sourceRoot":"","sources":["../../../src/completion/team-progress/arm-visible-progress-inputs.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,kGAAkG;AAClG,gBAAgB;AAyChB,OAAO,EACL,4BAA4B,GAE7B,MAAM,0CAA0C,CAAC;AAUlD;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,UAA+B,EAC/B,MAAwB,EACxB,QAAqC;IAErC,MAAM,WAAW,GAAG,4BAA4B,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IACvE,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC;QAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAC1D,OAAO;QACL,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1D,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;KAC3D,CAAC;AACJ,CAAC"}

package/dist/completion/team-progress/codex-activity.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Codex work, read as work.
+ *
+ * The daemon-core Codex parser turns only `mcp_tool_call` items into the neutral
+ * `tool_activity` event. Codex team streams also carry `command_execution`,
+ * `file_change` and `web_search` items -- a Codex agent's shell reads, its edits
+ * and its searches -- which that parser does not surface. Unread, a Codex review
+ * that inspected the code through the shell counts as having inspected nothing,
+ * and a Codex lead's shell work is not agent activity to the team-progress
+ * measure.
+ *
+ * codexToolActivityEvent turns each completed item of those kinds into the SAME
+ * `tool_activity` event a Claude tool call produces, so the review inspection
+ * signal and the progress measure read it under their existing rules (the
+ * lead's events on a daemon-started turn still do not count).
+ *
+ * Codex also sends no heartbeats, and a delegation (`collab_tool_call`) reports
+ * only its start and its end. noteCodexDelegation records an open delegation so
+ * the progress measure keeps its worker live without events, up to
+ * CODEX_DELEGATION_LIVE_MS (completion/team-progress/team-progress-measure.ts).
+ *
+ * Read off the parser's `raw` channel, in the daemon, rather than by changing
+ * the registry-installed daemon-core parser -- the choice the Codex limit reader
+ * (spawn/codex-limit.ts) made and records.
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/team-progress/codex-activity.ts).
+ */
+import type { AgentToolActivityEvent } from '@telora/daemon-core';
+/**
+ * The neutral tool_activity event a completed Codex shell, file-change or
+ * web-search item is, or null for any other line. Surfaced on completion, like
+ * the parser's mcp_tool_call, so one call counts once. Pure.
+ */
+export declare function codexToolActivityEvent(raw: unknown): AgentToolActivityEvent | null;
+/**
+ * Record a Codex delegation opening or closing on the focus (a collab_tool_call
+ * item started / completed, keyed by its item id -- the id the parser's
+ * subagent_activity event carries). No-op for any other line.
+ */
+export declare function noteCodexDelegation(focusId: string, raw: unknown, nowMs?: number): void;
+//# sourceMappingURL=codex-activity.d.ts.map

package/dist/completion/team-progress/codex-activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-activity.d.ts","sourceRoot":"","sources":["../../../src/completion/team-progress/codex-activity.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAuBlE;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,OAAO,GAAG,sBAAsB,GAAG,IAAI,CAwBlF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,KAAK,GAAE,MAAmB,GAAG,IAAI,CAKnG"}

package/dist/completion/team-progress/codex-activity.js

@@ -0,0 +1,69 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/team-progress/codex-activity.test.ts
+// PINNED-BY-END
+import { noteWorkerDelegation } from './team-progress-measure.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** The item of an item.started / item.completed line, with its phase; null for any other line. */
+function codexItem(raw) {
+    if (!isRecord(raw) || !isRecord(raw['item']))
+        return null;
+    if (raw['type'] === 'item.started')
+        return { phase: 'started', item: raw['item'] };
+    if (raw['type'] === 'item.completed')
+        return { phase: 'completed', item: raw['item'] };
+    return null;
+}
+/** The first path a file_change item changed, or null. */
+function firstChangedPath(item) {
+    const changes = item['changes'];
+    if (!Array.isArray(changes))
+        return null;
+    const first = changes[0];
+    return isRecord(first) && typeof first['path'] === 'string' ? first['path'] : null;
+}
+/**
+ * The neutral tool_activity event a completed Codex shell, file-change or
+ * web-search item is, or null for any other line. Surfaced on completion, like
+ * the parser's mcp_tool_call, so one call counts once. Pure.
+ */
+export function codexToolActivityEvent(raw) {
+    const line = codexItem(raw);
+    if (!line || line.phase !== 'completed')
+        return null;
+    const { item } = line;
+    switch (item['type']) {
+        case 'command_execution':
+            return {
+                kind: 'tool_activity',
+                tool: 'shell',
+                file: null,
+                input: typeof item['command'] === 'string' ? { command: item['command'] } : {},
+            };
+        case 'file_change':
+            return { kind: 'tool_activity', tool: 'file_change', file: firstChangedPath(item), input: { changes: item['changes'] } };
+        case 'web_search':
+            return {
+                kind: 'tool_activity',
+                tool: 'web_search',
+                file: null,
+                input: typeof item['query'] === 'string' ? { query: item['query'] } : {},
+            };
+        default:
+            return null;
+    }
+}
+/**
+ * Record a Codex delegation opening or closing on the focus (a collab_tool_call
+ * item started / completed, keyed by its item id -- the id the parser's
+ * subagent_activity event carries). No-op for any other line.
+ */
+export function noteCodexDelegation(focusId, raw, nowMs = Date.now()) {
+    const line = codexItem(raw);
+    if (!line || line.item['type'] !== 'collab_tool_call')
+        return;
+    const id = typeof line.item['id'] === 'string' ? line.item['id'] : 'codex-subagent';
+    noteWorkerDelegation(focusId, id, line.phase, nowMs);
+}
+//# sourceMappingURL=codex-activity.js.map

package/dist/completion/team-progress/codex-activity.js.map

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

package/dist/completion/team-progress/delivery-advancement-guard.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Delivery-advancement thrash guard.
+ *
+ * Tracks a per-focus progress snapshot across successful team cycles and
+ * escalates only when NONE of the real progress axes moved for `threshold`
+ * consecutive cycles (the genuine respawn-thrash wedge). The snapshot lives in
+ * a module-scope Map keyed by focusId so it SURVIVES the respawn boundary --
+ * unlike the team-local `lastProgressSnapshot`, which resets to null every time
+ * the daemon terminates and respawns the team. That persistence is the whole
+ * reason this guard exists as a separate structure.
+ *
+ * Progress axes -- the ONE progress measure (team-progress-measure.ts); a cycle
+ * "advanced" when ANY moved since the prior cycle (4 and 5: the team's agent
+ * activity and its uncommitted diff, so a team whose workers are editing is not
+ * read as thrashing):
+ *   1. delivery execution_status per delivery (the original, coarse axis),
+ *   2. a work-issue fingerprint -- a canonical hash of {issueId -> status} --
+ *      so ANY issue transition (To Do -> In Progress -> Done, or a new issue)
+ *      counts as advancement even when execution_status is frozen,
+ *   3. the focus-branch commit head sha -- so a team that landed a commit this
+ *      cycle counts as advancement even when no DB state moved.
+ *
+ * WHY axes 2 and 3 count: a done delivery pinned at `coding` by the active-team
+ * auto-advance skip, combined with a freshly-added queued sibling, freezes the
+ * execution_status snapshot. On the respawn path the completion handler always
+ * sees a null team-local prior, so this guard is the ONLY watchdog measuring
+ * cross-respawn progress; an execution_status-only snapshot would read "no
+ * advancement" while real commits and issue transitions land and escalate a
+ * spurious team_failure. A focus flat on ALL axes across the threshold still
+ * escalates.
+ *
+ * Reconciliation with completion/completion-event/event.ts madeProgress: the values fed
+ * here (`issues`, `focusHeadSha`) are the SAME values event.ts already computed
+ * for its `takeProgressSnapshot` / `madeProgress` calculation -- they are passed
+ * through, never re-derived (no extra issue fetch, no extra git read). This
+ * guard keeps its OWN persistent snapshot because `madeProgress` is forced
+ * `true` on the respawn path (null prior) and so cannot carry cross-respawn
+ * signal; the two do not double-count -- they measure different windows (this
+ * guard: cross-respawn; madeProgress: within a single keep-alive team).
+ *
+ * History: docs/daemon/history-team-lifecycle.md (completion/team-progress/delivery-advancement-guard.ts).
+ */
+import type { FocusDeliveryInfo, FocusIssueInfo, TeamActivityMarks, TeamProgressAxes } from '../../types/index.js';
+/**
+ * The guard's persisted reading IS the one progress measure's axes
+ * (completion/team-progress/team-progress-measure.ts): delivery statuses (whose keys also
+ * encode the delivery SET), the issue fingerprint, the focus HEAD, and the team
+ * activity axes (agent activity, uncommitted diff) -- so a respawned team whose
+ * workers are editing is not counted as thrashing.
+ */
+export type DeliveryAdvancementSnapshot = TeamProgressAxes;
+export interface DeliveryAdvancementState {
+    snapshot: DeliveryAdvancementSnapshot;
+    noAdvancementCycles: number;
+    /**
+     * Epoch ms of the last COUNTED (incremented or baseline) cycle. Backs the
+     * real-time floor: a no-advancement cycle arriving within `floorMs` of this is
+     * a burst artifact and is HELD (not counted), so this cross-respawn watchdog
+     * -- a cycle-counter exactly like the scope-coverage guard -- cannot be tripped
+     * by a burst of completion events either. Optional so the pre-floor callers
+     * (floorMs=0) behave identically.
+     */
+    lastRecordedAt?: number;
+    /**
+     * Epoch ms the focus last ADVANCED (or was baselined). The stall window is
+     * measured from it, so it spans respawns: a thrashing focus whose teams each
+     * live a minute still reaches the threshold once the window has passed.
+     */
+    lastAdvancedAt?: number;
+}
+export interface DeliveryAdvancementDecision {
+    advanced: boolean;
+    noAdvancementCycles: number;
+    thresholdReached: boolean;
+}
+/**
+ * Durable write-through seam for the cross-respawn no-progress state. Registered
+ * once at daemon boot (setDeliveryAdvancementPersister); called best-effort
+ * (fire-and-forget) whenever the state changes, and with null when the guard is
+ * reset for a focus. Unset in tests -> the guard stays pure in-memory. This is
+ * what makes a spent no-advancement budget survive the auto-updater's re-exec
+ * (module-scope state alone reset noAdvancementCycles to 0 every restart, handing
+ * a focus about to trip its team_failure halt a fresh budget).
+ */
+export type DeliveryAdvancementPersister = (focusId: string, state: DeliveryAdvancementState | null) => void;
+/** Register (or clear, with null) the durable write-through persister at boot. */
+export declare function setDeliveryAdvancementPersister(fn: DeliveryAdvancementPersister | null): void;
+/**
+ * Restore a focus's no-progress watchdog state from its persisted column, the
+ * FIRST time the daemon sees the focus after a (re-)start. Non-clobbering: a
+ * state already tracked in memory this run wins (hydrate never overwrites a live
+ * cycle). Restoring the SNAPSHOT alongside the counter is essential -- a bare
+ * counter would rebase to 0 on the first post-restart cycle for lack of a prior
+ * to compare against, silently forgiving the streak.
+ */
+export declare function hydrateDeliveryAdvancementState(focusId: string, state: DeliveryAdvancementState | null): void;
+export declare function takeDeliveryAdvancementSnapshot(deliveries: Pick<FocusDeliveryInfo, 'id' | 'executionStatus'>[], issues?: Pick<FocusIssueInfo, 'id' | 'status'>[], focusHeadSha?: string | null, activity?: TeamActivityMarks | null): DeliveryAdvancementSnapshot;
+/** Equal when the one progress measure reads no movement between them. */
+export declare function deliveryAdvancementSnapshotsEqual(a: DeliveryAdvancementSnapshot, b: DeliveryAdvancementSnapshot): boolean;
+export declare function recordDeliveryAdvancementCycle(focusId: string, deliveries: Pick<FocusDeliveryInfo, 'id' | 'executionStatus'>[], issues: Pick<FocusIssueInfo, 'id' | 'status'>[], focusHeadSha: string | null, threshold: number, 
+/** Clock value for the time floor (default Date.now for pre-floor callers). */
+nowMs?: number, 
+/**
+ * Minimum real time between two COUNTED no-advancement cycles. Default 0 = no
+ * floor (identical to the pre-floor behavior every existing caller/test
+ * expects). The completion handler passes NO_PROGRESS_CYCLE_FLOOR_MS so this
+ * watchdog can no longer be tripped by a burst of completion events.
+ */
+floorMs?: number, opts?: {
+    /** The team-activity axes of the measure, read this cycle (null: not compared). */
+    activity?: TeamActivityMarks | null;
+    /**
+     * Real time the focus must have gone without advancing (measured across
+     * respawns from lastAdvancedAt) before the threshold may be reached. 0 = no
+     * window (the pre-window callers).
+     */
+    stallWindowMs?: number;
+}): DeliveryAdvancementDecision;
+export declare function resetDeliveryAdvancementGuard(focusId?: string): void;
+//# sourceMappingURL=delivery-advancement-guard.d.ts.map

package/dist/completion/team-progress/delivery-advancement-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-advancement-guard.d.ts","sourceRoot":"","sources":["../../../src/completion/team-progress/delivery-advancement-guard.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAInH;;;;;;GAMG;AACH,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,CAAC;AAE3D,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,2BAA2B,CAAC;IACtC,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,OAAO,CAAC;IAClB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAID;;;;;;;;GAQG;AACH,MAAM,MAAM,4BAA4B,GAAG,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,wBAAwB,GAAG,IAAI,KACnC,IAAI,CAAC;AAIV,kFAAkF;AAClF,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,4BAA4B,GAAG,IAAI,GAAG,IAAI,CAE7F;AAQD;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,wBAAwB,GAAG,IAAI,GACrC,IAAI,CAIN;AAED,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,iBAAiB,CAAC,EAAE,EAC/D,MAAM,GAAE,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAO,EACpD,YAAY,GAAE,MAAM,GAAG,IAAW,EAClC,QAAQ,GAAE,iBAAiB,GAAG,IAAW,GACxC,2BAA2B,CAW7B;AAED,0EAA0E;AAC1E,wBAAgB,iCAAiC,CAC/C,CAAC,EAAE,2BAA2B,EAC9B,CAAC,EAAE,2BAA2B,GAC7B,OAAO,CAET;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,iBAAiB,CAAC,EAAE,EAC/D,MAAM,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,QAAQ,CAAC,EAAE,EAC/C,YAAY,EAAE,MAAM,GAAG,IAAI,EAC3B,SAAS,EAAE,MAAM;AACjB,+EAA+E;AAC/E,KAAK,GAAE,MAAmB;AAC1B;;;;;GAKG;AACH,OAAO,SAAI,EACX,IAAI,GAAE;IACJ,mFAAmF;IACnF,QAAQ,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACpC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,GACL,2BAA2B,CAkD7B;AAED,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CASpE"}