@telora/daemon 0.22.245 → 0.22.289

package/dist/completion/completion-decision.js

@@ -1,43 +0,0 @@
-// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
-// Pinned by: packages/daemon/src/completion/completion-decision.test.ts
-// PINNED-BY-END
-/**
- * Whether the (async, workflow-fetching) non-advanceability lookup should run
- * at all this cycle. Pure gate so the handler does not pay the lookup -- and
- * cannot accidentally escalate -- on cycles where the team has its own work
- * or demonstrably moved state.
- */
-export function shouldCheckNonAdvanceable(facts) {
-    return !facts.teamHasActionableWork && !facts.advancedThisCycle;
-}
-/**
- * Decide the completion action for this cycle. Pure; precedence is exactly
- * the order documented in the module header.
- */
-export function decideCompletionAction(facts) {
-    if (!facts.teamHasActionableWork) {
-        // A delivery that appeared since the team was last engaged is handoff-
-        // eligible work in its own right -- hand it off BEFORE any terminate or
-        // structural-dead-end branch, so a delivery added to a running focus reaches
-        // the team instead of the team exiting with the work unstarted. It does not
-        // count as work the team is failing to advance (teamHasActionableWork stays
-        // false), so we reach here without touching the no-progress guard; the
-        // handoff side effect adds it to knownDeliveryIds, so it hands off at most
-        // once and never accrues a no-progress cycle.
-        if (facts.hasNewlyAppearedDelivery) {
-            return { kind: 'handoff_new_work' };
-        }
-        if (!facts.advancedThisCycle && facts.hasNonAdvanceableStuck) {
-            return { kind: 'escalate_non_advanceable_and_terminate' };
-        }
-        return { kind: 'terminate_no_actionable_work' };
-    }
-    if (facts.noProgressCycles >= facts.noProgressLimit && facts.stallWindowElapsed !== false) {
-        return { kind: 'escalate_no_progress_and_terminate' };
-    }
-    if (facts.hasActionableOpenIssues) {
-        return { kind: 'handoff_new_work' };
-    }
-    return { kind: 'reengage' };
-}
-//# sourceMappingURL=completion-decision.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"completion-decision.js","sourceRoot":"","sources":["../../src/completion/completion-decision.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,wEAAwE;AACxE,gBAAgB;AA0FhB;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAmF;IAEnF,OAAO,CAAC,KAAK,CAAC,qBAAqB,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC;AAClE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAA8B;IACnE,IAAI,CAAC,KAAK,CAAC,qBAAqB,EAAE,CAAC;QACjC,uEAAuE;QACvE,wEAAwE;QACxE,6EAA6E;QAC7E,4EAA4E;QAC5E,4EAA4E;QAC5E,uEAAuE;QACvE,2EAA2E;QAC3E,8CAA8C;QAC9C,IAAI,KAAK,CAAC,wBAAwB,EAAE,CAAC;YACnC,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,iBAAiB,IAAI,KAAK,CAAC,sBAAsB,EAAE,CAAC;YAC7D,OAAO,EAAE,IAAI,EAAE,wCAAwC,EAAE,CAAC;QAC5D,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,8BAA8B,EAAE,CAAC;IAClD,CAAC;IACD,IAAI,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,eAAe,IAAI,KAAK,CAAC,kBAAkB,KAAK,KAAK,EAAE,CAAC;QAC1F,OAAO,EAAE,IAAI,EAAE,oCAAoC,EAAE,CAAC;IACxD,CAAC;IACD,IAAI,KAAK,CAAC,uBAAuB,EAAE,CAAC;QAClC,OAAO,EAAE,IAAI,EAAE,kBAAkB,EAAE,CAAC;IACtC,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AAC9B,CAAC"}

package/dist/completion/completion-fact-readers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"completion-fact-readers.d.ts","sourceRoot":"","sources":["../../src/completion/completion-fact-readers.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,GACxB;IAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAQnE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,OAAO,CAAC,CAUlB"}

package/dist/completion/completion-fact-readers.js

@@ -1,70 +0,0 @@
-// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
-// Pinned by: packages/daemon/src/completion/exit-unclaimed-migration-hold.test.ts,
-//   packages/daemon/src/migrations/claim-production-wiring.test.ts
-// PINNED-BY-END
-/**
- * The IO-backed facts the completion decision gathers, each behind its own
- * deps-defaulted reader.
- *
- * WHY THEY SIT HERE. `computeCompletionFacts` decides; these two go and look.
- * Both follow the same pattern -- an injectable seam with a production default,
- * so a test drives the decision without a worktree or an API, and production
- * needs no wiring at the call site. Kept out of the decision module because
- * they are the only IO in it and because that module is at the file-size
- * ceiling, where every future fact would have to displace an old one.
- *
- * @module completion/completion-fact-readers
- */
-import { getFocusWorktree as defaultGetFocusWorktree } from '../focus/focus-worktree-state.js';
-import { readWorktreeHeadSha as defaultReadWorktreeHeadSha } from '../git/index.js';
-import { parseUnclaimedNamedAt, readUnclaimedMigrationRecordStrict, } from '../queries/focus-unclaimed-migration.js';
-/**
- * The focus worktree and the sha its HEAD is at, resolved once for BOTH the
- * git-activity snapshot dimension and the dirty re-wake guard.
- *
- * A team that wrote AND committed code this cycle moved the focus branch HEAD
- * even when no DB state moved; feeding that sha into the snapshot makes the
- * commit reset the no-progress counter through the EXISTING
- * madeProgress/snapshotsEqual machinery. Null when no worktree is registered or
- * git could not be read.
- */
-export function resolveFocusHead(focusId, deps) {
-    const resolveWorktree = deps.getFocusWorktree ?? defaultGetFocusWorktree;
-    const readHeadSha = deps.readWorktreeHeadSha ?? defaultReadWorktreeHeadSha;
-    const focusWorktreePath = resolveWorktree(focusId)?.worktreePath ?? null;
-    return {
-        focusWorktreePath,
-        focusHeadSha: focusWorktreePath !== null ? readHeadSha(focusWorktreePath) : null,
-    };
-}
-/**
- * Whether this focus holds an unclaimed-migration record the team has NOT been
- * shown yet.
- *
- * Actionable work for exactly one turn (see
- * TeamActionableWorkInput.unclaimedMigrationUnnamed): the file on the branch
- * carries a migration number no claim knows about, and the team that wrote it
- * is the only one that can claim or remove it.
- *
- * A FAILED READ ANSWERS FALSE HERE, and that is deliberate -- the fail-closed
- * posture lives one layer up, in the phase that actually DELIVERS the notice.
- * That phase runs first, holds the team on an unreadable record and marks
- * nothing, so the state is retained and retried either way. This fact, by
- * contrast, is folded into the shared actionable-work predicate AHEAD of the
- * verify interlock: answering true on a failed artifact read would let an API
- * outage override an unrelated hold and keep a team the verify interlock had
- * just withheld. One place fails closed; this one stays out of the way.
- */
-export async function readUnnamedUnclaimedMigration(focusId, deps) {
-    try {
-        // Strict, for the same reason the notice phase uses it: the lenient read
-        // swallows a failure into null, and null here means "nothing to tell".
-        const readRecord = deps.readUnclaimedMigrationRecord ?? readUnclaimedMigrationRecordStrict;
-        const record = await readRecord(focusId);
-        return record !== null && parseUnclaimedNamedAt(record) === null;
-    }
-    catch {
-        return false; // the notice phase already held on this; see above
-    }
-}
-//# sourceMappingURL=completion-fact-readers.js.map

package/dist/completion/completion-fact-readers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"completion-fact-readers.js","sourceRoot":"","sources":["../../src/completion/completion-fact-readers.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,mFAAmF;AACnF,mEAAmE;AACnE,gBAAgB;AAEhB;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,IAAI,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAC/F,OAAO,EAAE,mBAAmB,IAAI,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EACL,qBAAqB,EACrB,kCAAkC,GACnC,MAAM,yCAAyC,CAAC;AAGjD;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAe,EACf,IAAyB;IAEzB,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,IAAI,uBAAuB,CAAC;IACzE,MAAM,WAAW,GAAG,IAAI,CAAC,mBAAmB,IAAI,0BAA0B,CAAC;IAC3E,MAAM,iBAAiB,GAAG,eAAe,CAAC,OAAO,CAAC,EAAE,YAAY,IAAI,IAAI,CAAC;IACzE,OAAO;QACL,iBAAiB;QACjB,YAAY,EAAE,iBAAiB,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,IAAI;KACjF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,OAAe,EACf,IAAyB;IAEzB,IAAI,CAAC;QACH,yEAAyE;QACzE,uEAAuE;QACvE,MAAM,UAAU,GAAG,IAAI,CAAC,4BAA4B,IAAI,kCAAkC,CAAC;QAC3F,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,OAAO,CAAC,CAAC;QACzC,OAAO,MAAM,KAAK,IAAI,IAAI,qBAAqB,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC;IACnE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC,CAAC,mDAAmD;IACnE,CAAC;AACH,CAAC"}

package/dist/completion/completion-phase-registry.d.ts

@@ -1,226 +0,0 @@
-/**
- * COMPLETION_PHASE_REGISTRY -- the team-completion flow as a declarative table.
- *
- * `handleTeamCompletion` (team-completion.ts) used to carry the whole exit
- * sequence as one ~280-line imperative body whose phase order lived only in
- * comments. This registry lifts that sequence into an ordered array of
- * `CompletionPhaseDescriptor`s that the sequencer iterates, exactly as
- * `LOOP_REGISTRY` (focus/focus-loop-registry.ts) did for the engine's
- * start() loops. The phase bodies are extracted VERBATIM into named
- * functions; order, gating, and short-circuit semantics are preserved
- * exactly and pinned by completion-phase-registry.test.ts.
- *
- * Control-flow semantics are declared, not ad-hoc:
- *   - `gate`     -- when the phase runs relative to the exit classification
- *                   ('always' | 'succeeded' | 'not-succeeded'); enforced by
- *                   the sequencer's iterator.
- *   - `canHalt`  -- whether run() may return 'halt', ending the whole
- *                   completion flow (only the read-only guard does).
- *   - `accumulatesExitReason` -- whether the phase appends to
- *                   ctx.exitReason (merge + CI merge-to-main).
- *
- * Phases communicate through a single mutable `CompletionPhaseContext`
- * threaded by the sequencer: classify writes the classification + initial
- * exit reason; report-git-state derives workedDeliveryIds; merge records
- * mergeSucceeded; session-finalize records finalizedPassId + exitCategory
- * for pass-close.
- */
-import type { DaemonConfig, FocusTeamState, ExitCategory } from '../types/index.js';
-import { type LeadOwnershipDeps } from '../spawn/lead-process-ownership.js';
-import { type TeamExitClassification } from './exit-classification.js';
-import { type FocusMergeAttemptDeps } from './merge-phase.js';
-import { runReviewExitHandler } from './review-exit-phase.js';
-/**
- * The mutable state threaded through every completion phase. Inputs are
- * readonly; derived facts are written by the phase that owns them and read
- * by later phases.
- */
-export interface CompletionPhaseContext {
-    readonly config: DaemonConfig;
-    readonly teamState: FocusTeamState;
-    readonly sessionId: string;
-    readonly code: number | null;
-    readonly signal: string | null;
-    /** Written by 'classify'; every later phase reads it via requireClassification. */
-    classification: TeamExitClassification | undefined;
-    /** Initialized by 'classify'; appended to by 'merge' + 'ci-merge-to-main'. */
-    exitReason: string;
-    /** Written by 'report-git-state'. */
-    workedDeliveryIds: string[];
-    /** Written by 'merge'. */
-    mergeSucceeded: boolean;
-    /** Written by 'session-finalize'; read by 'pass-close'. */
-    finalizedPassId: string | null;
-    /** Written by 'session-finalize'; read by 'pass-close'. */
-    /** Null until the session-finalize phase derives it; every close then carries one. */
-    exitCategory: ExitCategory | null;
-    /** Process-ownership seams for the team's process-tree cleanup; real OS when absent. */
-    readonly ownershipDeps?: LeadOwnershipDeps;
-}
-/** Build the initial (pre-classify) phase context from the sequencer params. */
-export declare function createCompletionPhaseContext(params: {
-    config: DaemonConfig;
-    teamState: FocusTeamState;
-    sessionId: string;
-    code: number | null;
-    signal: string | null;
-    ownershipDeps?: LeadOwnershipDeps;
-}): CompletionPhaseContext;
-/** 'halt' ends the whole completion flow; 'continue' proceeds to the next phase. */
-export type CompletionPhaseOutcome = 'continue' | 'halt';
-/** When a phase runs relative to the exit classification's `succeeded`. */
-export type CompletionPhaseGate = 'always' | 'succeeded' | 'not-succeeded';
-export interface CompletionPhaseDescriptor {
-    /** Stable phase name; order + names pinned by the structure test. */
-    name: string;
-    /** Enforced by the sequencer's iterator (see runCompletionPhases). */
-    gate: CompletionPhaseGate;
-    /** True only for phases whose run() may return 'halt'. */
-    canHalt: boolean;
-    /** True for phases that append to ctx.exitReason. */
-    accumulatesExitReason: boolean;
-    run(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-}
-/** Build the initial exit reason from the exit classification. */
-export declare function buildInitialExitReason(teamState: FocusTeamState, classification: {
-    exitCode: number;
-    proactivelyTerminated: boolean;
-    succeeded: boolean;
-    controlledStop: boolean;
-}, signal: string | null): string;
-/**
- * Phase: classify exit.
- * A lifecycle teardown (shutdownReason='work_complete') SIGTERM is treated
- * as a success, NOT a review failure -- see classifyTeamExit.
- */
-export declare function runClassifyPhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: report git state.
- * Report git state for deliveries the team plausibly worked on or finished.
- * See REPORTABLE_DELIVERY_STATUSES — including 'done' ensures focuses whose
- * deliveries all reached done before the team exit still attempt the merge.
- */
-export declare function runReportGitStatePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: read-only guard (the one halting phase).
- * Read-only audit safety net: revert any uncommitted modifications, and if
- * the agent somehow committed despite the pre-commit hook, mark the session
- * failed and tear the team down WITHOUT merging.
- *
- * Returns 'halt' when the completion flow must abort (violation handled).
- */
-export declare function runReadOnlyGuardPhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: WIP preserve (gate: not-succeeded).
- * Commit any uncommitted WIP changes left by the agent (crash, kill, timeout).
- * Only needed when the agent didn't exit cleanly — a clean exit means the
- * agent committed its own work.
- */
-export declare function runWipPreservePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: status advance (gate: succeeded).
- * Advance delivery statuses based on issue completion.
- */
-export declare function runStatusAdvancePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: reality-pole capture (gate: succeeded).
- * Anchor the focus's assertional loop items to the code footprint the
- * focus branch touched (files = churn-clock scope, reality embedding = the
- * pole). Runs BEFORE the merge below, while the branch still diverges from
- * the integration base, so the footprint is non-empty. NOT gated behind the
- * LLM opt-in -- anchoring is cheap and feeds the per-item tripwire. Wrapped
- * so a failure never breaks completion.
- */
-export declare function runRealityPoleCapturePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: merge (accumulates exitReason).
- * Merge focus branch to integration if the branch has committed work AND every
- * commit the merge would add has passed the focus's review or verify gate.
- * Decoupled from team-exit success: the exit shape (review SIGTERM, role-clear,
- * daemon crash, manual termination) decides nothing, but the WIP capture the
- * 'wip-preserve' phase just made for a not-succeeded exit is ungated, so it
- * holds the merge and stays on the focus branch (merge/merge-gate-coverage.ts;
- * the hold reason is appended to the exit reason).
- *
- * For proactive terminations, this is typically a no-op merge since all
- * deliveries were already merged mid-flight. The merge still runs for
- * safety (handles any commits the team lead made after the last
- * incremental merge).
- *
- * Passes workedDeliveryIds so git state is only reported for deliveries
- * that were plausibly worked on (coding/verify/done — see
- * REPORTABLE_DELIVERY_STATUSES), not queued or planning deliveries that
- * never started.
- *
- * Planning-phase and read-only audit guards stay in shouldAttemptMerge.
- */
-export declare function runMergePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/** The merge phase body over injected merge collaborators; undefined = the real ones. */
-export declare function runMergePhaseWithDeps(ctx: CompletionPhaseContext, deps: FocusMergeAttemptDeps | undefined): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: CI merge-to-main (accumulates exitReason).
- * CI: merge integration -> main (CD optionally pushes).
- */
-export declare function runCiMergeToMainPhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: session finalize.
- * Compute git output from all commits on this branch since the integration
- * tip AT SPAWN. The lines added/removed AND the changed-file list + commit
- * SHAs are persisted on the session row so the Usage analytics work-output
- * cards (Files Modified / Commits) reflect real git output.
- *
- * The base MUST be the spawn-time integration SHA (teamState.integrationBaseSha),
- * not the live integration ref: by finalize the focus branch has been merged
- * into integration (here AND mid-flight per delivery), and real merges preserve
- * ancestry, so `integration..branch` is empty and the cards would read 0.
- * Falls back to the live ref only when the spawn-time SHA is unavailable.
- */
-export declare function runSessionFinalizePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: pass close.
- * Close this (focus, lineage) pass only when the lineage genuinely ends, so a
- * later re-code opens a FRESH pass while a same-lineage respawn keeps appending
- * segments to the still-open pass. The deciding signal is the queued respawn:
- *  - a pending spawn for a DIFFERENT lineage (e.g. coding -> review) ends this
- *    lineage -> close.
- *  - a pending spawn for the SAME lineage (a continuation handoff) -> keep open
- *    so find-or-open reattaches the next segment.
- *  - no pending spawn + a terminal disposition (work done / teardown /
- *    deactivated / user stopped) -> close.
- *  - no pending spawn + a benign handoff/error (the poll loop or
- *    --resume-failure will respawn the same lineage) -> keep open.
- */
-export declare function runPassClosePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: review exit (escalate / handoff).
- * See runReviewExitHandler for the routing rules.
- *
- * Coverage evidence for the review-exit gate. The SPAWN-tip (what the review
- * actually saw, carried on the team state from spawn) is what gets stamped as
- * the coverage watermark; the EXIT-tip (resolved now) is compared against it
- * to detect mid-review drift. Equal => clean coverage (auto-approve may fire);
- * unequal => the branch advanced during the review (below coverage). Exit-tip
- * is best-effort; on failure the handler falls back to spawn-tip for the stamp
- * and withholds auto-approve (the safe direction).
- */
-export declare function runReviewExitPhase(ctx: CompletionPhaseContext, runExitHandler?: typeof runReviewExitHandler): Promise<CompletionPhaseOutcome>;
-/**
- * Phase: terminate.
- * Heartbeat, team-state cleanup, model-host release, re-poll trigger.
- */
-export declare function runTerminatePhase(ctx: CompletionPhaseContext): Promise<CompletionPhaseOutcome>;
-/**
- * The team-completion flow, in execution order. The sequencer
- * (handleTeamCompletion) iterates this table; the structure test pins its
- * length, names, order, and declared control-flow shape.
- */
-export declare const COMPLETION_PHASE_REGISTRY: CompletionPhaseDescriptor[];
-/**
- * Iterate the registry over a phase context: apply each phase's declared
- * gate, run it, and stop the whole flow on 'halt'. The classification is
- * written by the first phase; gates before it evaluate against
- * "not yet classified" = not succeeded (only 'classify' itself runs there,
- * and it is 'always').
- */
-export declare function runCompletionPhases(ctx: CompletionPhaseContext, registry?: CompletionPhaseDescriptor[]): Promise<void>;
-//# sourceMappingURL=completion-phase-registry.d.ts.map

package/dist/completion/completion-phase-registry.d.ts.map

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