@telora/daemon 0.21.12 → 0.21.81

package/dist/focus/focus-team-state.js

@@ -0,0 +1,195 @@
+/**
+ * Focus team state management.
+ *
+ * Tracks active focus teams in memory and provides query/mutation helpers for
+ * the active teams map. All per-team state lives on the FocusTeamState record
+ * in the ONE `activeTeams` map (adding a team dimension is one field on that
+ * record, not a new parallel Map): the shutting-down clock (shuttingDownAt) and
+ * the last-activity clock (lastActivityAt) are fields, set via the mutation
+ * helpers below.
+ *
+ * The ONE intentional side-table is `slotTokens`. It is deliberately NOT folded
+ * onto the record because its lifecycle must OUTLIVE activeTeams membership: a
+ * governor slot must stay releasable after its team is removed, and
+ * recordSlotToken self-heals a stale token a previous team never released.
+ * Folding the token onto the record would drop that unreleased-slot safety net
+ * when the record is deleted -- a resilience regression -- so it stays separate.
+ *
+ * Test reset hatch: `__resetTeamStateForTesting()` clears the module's in-memory
+ * state (activeTeams + slotTokens).
+ */
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'focus-executor' });
+// ── Active teams tracking ────────────────────────────────────────────
+/** Active focus teams: focusId -> FocusTeamState */
+const activeTeams = new Map();
+/**
+ * Record that the team for `focusId` just produced an agent event. Advances the
+ * per-team last-activity clock (a field on the team record); called on every
+ * agent_event so an actively working team's timestamp keeps moving forward
+ * (silence is measured as the gap between now and this value, not from spawn).
+ * No-op when the focus has no active team (e.g. an event arriving after reap):
+ * the clock lives on the record, so there is nothing to advance and no orphan
+ * entry accumulates.
+ *
+ * @param focusId Focus whose team produced the event.
+ * @param now     Epoch ms of the event (default Date.now()).
+ */
+export function recordTeamActivity(focusId, now = Date.now()) {
+    const team = activeTeams.get(focusId);
+    if (team)
+        team.lastActivityAt = now;
+}
+/**
+ * Epoch ms of the team's last recorded agent event, or null when nothing has
+ * been recorded yet (e.g. a team still initializing before its first event, or
+ * no active team). A liveness watchdog treats null as "not yet stalled", never
+ * as "stalled since epoch".
+ */
+export function getTeamLastActivityAt(focusId) {
+    return activeTeams.get(focusId)?.lastActivityAt ?? null;
+}
+/**
+ * Clear the recorded last-activity timestamp for a focus. Called on team reap
+ * (next to clearShuttingDown); the record deletion at reap already drops the
+ * clock, so this is a defensive clear for a still-present record.
+ */
+export function clearTeamActivity(focusId) {
+    const team = activeTeams.get(focusId);
+    if (team)
+        team.lastActivityAt = undefined;
+}
+/**
+ * The ONE intentional side-table: live governor slot tokens (focusId ->
+ * SlotToken). The token minted by acquireSlot at team spawn is recorded here;
+ * releaseFocusSlot consumes it. Taking the token IS the release claim, so every
+ * release path (natural close, error, sandbox refusal, resume retry,
+ * stuck-shutdown watchdog) is exactly-once per team regardless of firing order.
+ *
+ * NOT folded onto the FocusTeamState record (unlike the two timestamp clocks
+ * above): its lifecycle must OUTLIVE activeTeams membership. A slot must stay
+ * releasable after its team leaves the map, and recordSlotToken self-heals a
+ * token a previous team never released -- both impossible if the token vanished
+ * with the deleted record. Keeping it separate preserves that unreleased-slot
+ * safety net.
+ */
+const slotTokens = new Map();
+/**
+ * Get all active focus teams.
+ */
+export function getActiveTeams() {
+    return activeTeams;
+}
+/**
+ * Record that a team entered the `shutting_down` phase at the given time.
+ * Idempotent on the FIRST transition: a repeat call does NOT overwrite the
+ * original timestamp, so the watchdog measures from when shutdown actually
+ * began (re-entering terminateTeam must not keep resetting the clock).
+ *
+ * @param focusId Focus whose team is shutting down.
+ * @param now     Epoch ms the team entered shutting_down (default Date.now()).
+ */
+export function markShuttingDown(focusId, now = Date.now()) {
+    const team = activeTeams.get(focusId);
+    if (team && team.shuttingDownAt === undefined) {
+        team.shuttingDownAt = now;
+    }
+}
+/**
+ * Epoch ms when the team for `focusId` entered `shutting_down`, or null if it
+ * has no recorded shutdown start (or no active team).
+ */
+export function getShuttingDownAt(focusId) {
+    return activeTeams.get(focusId)?.shuttingDownAt ?? null;
+}
+/**
+ * Clear the recorded shutting-down timestamp for a focus. Called when a team
+ * is reaped or otherwise leaves activeTeams; the record deletion at reap already
+ * drops the clock, so this is a defensive clear for a still-present record.
+ * Deliberately does NOT touch the slot token: an unreleased slot must stay
+ * releasable (or be self-healed on the next recordSlotToken), never silently
+ * dropped -- which is exactly why the slot token stays a side-table.
+ */
+export function clearShuttingDown(focusId) {
+    const team = activeTeams.get(focusId);
+    if (team)
+        team.shuttingDownAt = undefined;
+}
+/**
+ * Record the governor slot token minted for a focus team's spawn. If a stale
+ * token from a defunct team is still recorded (its release path never ran),
+ * release it now -- only one team per focus can exist, so a lingering token
+ * here is a wedged slot, not a live one.
+ */
+export function recordSlotToken(focusId, token, governor) {
+    const stale = slotTokens.get(focusId);
+    if (stale) {
+        log.warn(`[focus-executor] Releasing stale governor slot for focus ${focusId} (previous team never released it)`);
+        governor?.releaseSlot(stale);
+    }
+    slotTokens.set(focusId, token);
+}
+/**
+ * Release the governor slot for a focus, exactly once. Consumes the recorded
+ * token; a call with no recorded token (already released, or the spawn never
+ * acquired one) is a no-op. Returns true if a slot was actually released.
+ */
+export function releaseFocusSlot(focusId, governor) {
+    const token = slotTokens.get(focusId);
+    if (!token)
+        return false;
+    slotTokens.delete(focusId);
+    governor?.releaseSlot(token);
+    return true;
+}
+/**
+ * Test-only: THE reset hatch for this module's in-memory state. Clears the one
+ * team map (activeTeams -- which carries the shuttingDownAt / lastActivityAt
+ * clocks as fields) and the one side-table (slotTokens). Call it in a
+ * beforeEach/afterEach so team state never leaks across serial test files.
+ */
+export function __resetTeamStateForTesting() {
+    activeTeams.clear();
+    slotTokens.clear();
+}
+/**
+ * Check if a focus already has an active team.
+ */
+export function hasActiveTeam(focusId) {
+    return activeTeams.has(focusId);
+}
+/**
+ * Get count of active teams.
+ */
+export function getActiveTeamCount() {
+    return activeTeams.size;
+}
+/**
+ * Test-only helper: toggle hasActiveTeam(focusId) without instantiating
+ * a real FocusTeamState. Tests use this to gate behavior that depends on
+ * whether a team is in flight.
+ */
+export function __setActiveTeamForTesting(focusId, active) {
+    if (active) {
+        activeTeams.set(focusId, {});
+    }
+    else {
+        activeTeams.delete(focusId);
+    }
+}
+// ── Default execution config ─────────────────────────────────────────
+const DEFAULT_EXECUTION_CONFIG = {
+    maxWorkers: 3,
+    idlePollIntervalMs: 30000,
+    activePollIntervalMs: 60000,
+};
+/**
+ * Derive execution config from focus pipeline config.
+ */
+export function deriveExecutionConfig(_pipelineConfig) {
+    // For now, use defaults. The teams.enabled flag in pipelineConfig
+    // is deprecated — teams are always the execution model.
+    // Future: pipelineConfig could specify maxWorkers or parallelism level.
+    return { ...DEFAULT_EXECUTION_CONFIG };
+}
+//# sourceMappingURL=focus-team-state.js.map

package/dist/focus/focus-team-state.js.map

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

package/dist/focus/focus-worktree-state.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Focus worktree state management — write-through cache.
+ *
+ * Tracks persistent focus worktrees using a local Map as the
+ * synchronous read cache, backed by the focus_worktrees DB table.
+ *
+ * Read path: all get/has/getAll calls are synchronous (Map lookup).
+ * Write path: update Map immediately, then fire async DB write.
+ * Startup: hydrateFromDb() loads all records from DB into the Map.
+ *
+ * The Map is authoritative during runtime. The DB is authoritative
+ * across restarts. Async DB writes are fire-and-forget with logging.
+ *
+ * The Map spans ALL products a multi-product daemon manages. Product
+ * identity is carried on each entry (FocusWorktreeInfo.productId /
+ * .repoPath), never in module state: every write-through stamps the
+ * owning product from the entry itself, so a hydrate/rebuild pass for
+ * one product cannot misattribute another product's worktrees.
+ */
+import type { FocusWorktreeInfo } from '../types/index.js';
+import { upsertWorktreeRecord, removeWorktreeRecord, listWorktreeRecords } from '../queries/worktrees.js';
+/**
+ * The focus_worktrees query functions the write-through path reaches into,
+ * injectable for tests. Each defaults to the real query-layer import; a test
+ * supplies fakes through this seam instead of registering `mock.module` (which
+ * would poison the daemon-core loader -- see packages/daemon/CLAUDE.md).
+ */
+export interface WorktreeStateDeps {
+    upsertWorktreeRecord?: typeof upsertWorktreeRecord;
+    removeWorktreeRecord?: typeof removeWorktreeRecord;
+    listWorktreeRecords?: typeof listWorktreeRecords;
+}
+/**
+ * Hydrate the in-memory cache from the database for one product.
+ *
+ * Call once per configured product during daemon startup, BEFORE
+ * rebuildFocusWorktreeState. Each hydrated entry is stamped with the
+ * product identity it was hydrated under; rebuildFocusWorktreeState
+ * later re-stamps entries whose stored product_id was wrong (rows
+ * written under the historical last-write-wins bug) once it can prove
+ * ownership against the product's active focuses.
+ */
+export declare function hydrateFromDb(productId: string, repoPath: string, deps?: WorktreeStateDeps): Promise<void>;
+/**
+ * Get a single focus worktree by focus ID.
+ */
+export declare function getFocusWorktree(focusId: string): FocusWorktreeInfo | undefined;
+/**
+ * Add or update a focus worktree entry.
+ *
+ * Updates the Map synchronously, then fires an async DB upsert stamped
+ * with the entry's own product identity.
+ */
+export declare function setFocusWorktree(focusId: string, info: FocusWorktreeInfo, deps?: WorktreeStateDeps): void;
+/**
+ * Remove a focus worktree entry.
+ * Returns whether the entry existed.
+ *
+ * Deletes from Map synchronously, then fires an async DB remove.
+ */
+export declare function removeFocusWorktree(focusId: string, deps?: WorktreeStateDeps): boolean;
+/**
+ * Get all focus worktrees (spans all products; scope by entry.productId).
+ */
+export declare function getAllFocusWorktrees(): Map<string, FocusWorktreeInfo>;
+/**
+ * Check if a focus has a persistent worktree.
+ */
+export declare function hasFocusWorktree(focusId: string): boolean;
+//# sourceMappingURL=focus-worktree-state.d.ts.map

package/dist/focus/focus-worktree-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-worktree-state.d.ts","sourceRoot":"","sources":["../../src/focus/focus-worktree-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAKjC;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;IACnD,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;IACnD,mBAAmB,CAAC,EAAE,OAAO,mBAAmB,CAAC;CAClD;AAQD;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BpH;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,GAAE,iBAAsB,GAAG,IAAI,CAiB7G;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,iBAAsB,GAAG,OAAO,CAe1F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAErE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/focus/focus-worktree-state.js

@@ -0,0 +1,118 @@
+/**
+ * Focus worktree state management — write-through cache.
+ *
+ * Tracks persistent focus worktrees using a local Map as the
+ * synchronous read cache, backed by the focus_worktrees DB table.
+ *
+ * Read path: all get/has/getAll calls are synchronous (Map lookup).
+ * Write path: update Map immediately, then fire async DB write.
+ * Startup: hydrateFromDb() loads all records from DB into the Map.
+ *
+ * The Map is authoritative during runtime. The DB is authoritative
+ * across restarts. Async DB writes are fire-and-forget with logging.
+ *
+ * The Map spans ALL products a multi-product daemon manages. Product
+ * identity is carried on each entry (FocusWorktreeInfo.productId /
+ * .repoPath), never in module state: every write-through stamps the
+ * owning product from the entry itself, so a hydrate/rebuild pass for
+ * one product cannot misattribute another product's worktrees.
+ */
+import { upsertWorktreeRecord, removeWorktreeRecord, listWorktreeRecords, } from '../queries/worktrees.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'worktree-state' });
+// ── Persistent worktree tracking ─────────────────────────────────────
+/** Persistent focus worktrees: focusId -> FocusWorktreeInfo */
+const focusWorktrees = new Map();
+/**
+ * Hydrate the in-memory cache from the database for one product.
+ *
+ * Call once per configured product during daemon startup, BEFORE
+ * rebuildFocusWorktreeState. Each hydrated entry is stamped with the
+ * product identity it was hydrated under; rebuildFocusWorktreeState
+ * later re-stamps entries whose stored product_id was wrong (rows
+ * written under the historical last-write-wins bug) once it can prove
+ * ownership against the product's active focuses.
+ */
+export async function hydrateFromDb(productId, repoPath, deps = {}) {
+    const listWorktreeRecordsFn = deps.listWorktreeRecords ?? listWorktreeRecords;
+    let records;
+    try {
+        records = await listWorktreeRecordsFn(productId);
+    }
+    catch (err) {
+        log.warn(`[worktree-state] Failed to hydrate from DB, starting with empty cache:`, err.message);
+        return;
+    }
+    let hydrated = 0;
+    for (const record of records) {
+        focusWorktrees.set(record.focusId, {
+            focusId: record.focusId,
+            focusName: '', // Not stored in DB — rebuilt by callers
+            worktreePath: record.worktreePath,
+            branchName: record.branchName,
+            createdAt: new Date(record.createdAt),
+            productId,
+            repoPath,
+        });
+        hydrated++;
+    }
+    if (hydrated > 0) {
+        log.info(`Hydrated ${hydrated} worktree(s) from DB for product ${productId}`);
+    }
+}
+/**
+ * Get a single focus worktree by focus ID.
+ */
+export function getFocusWorktree(focusId) {
+    return focusWorktrees.get(focusId);
+}
+/**
+ * Add or update a focus worktree entry.
+ *
+ * Updates the Map synchronously, then fires an async DB upsert stamped
+ * with the entry's own product identity.
+ */
+export function setFocusWorktree(focusId, info, deps = {}) {
+    focusWorktrees.set(focusId, info);
+    const upsertWorktreeRecordFn = deps.upsertWorktreeRecord ?? upsertWorktreeRecord;
+    // Write-through: async DB upsert (fire-and-forget)
+    upsertWorktreeRecordFn({
+        focusId,
+        productId: info.productId,
+        worktreePath: info.worktreePath,
+        branchName: info.branchName,
+        status: 'active',
+    }).catch((err) => {
+        log.warn(`[worktree-state] DB upsert failed for focus ${focusId}:`, err.message);
+    });
+}
+/**
+ * Remove a focus worktree entry.
+ * Returns whether the entry existed.
+ *
+ * Deletes from Map synchronously, then fires an async DB remove.
+ */
+export function removeFocusWorktree(focusId, deps = {}) {
+    const existed = focusWorktrees.delete(focusId);
+    if (existed) {
+        const removeWorktreeRecordFn = deps.removeWorktreeRecord ?? removeWorktreeRecord;
+        // Write-through: async DB remove (fire-and-forget)
+        removeWorktreeRecordFn(focusId).catch((err) => {
+            log.warn(`[worktree-state] DB remove failed for focus ${focusId}:`, err.message);
+        });
+    }
+    return existed;
+}
+/**
+ * Get all focus worktrees (spans all products; scope by entry.productId).
+ */
+export function getAllFocusWorktrees() {
+    return focusWorktrees;
+}
+/**
+ * Check if a focus has a persistent worktree.
+ */
+export function hasFocusWorktree(focusId) {
+    return focusWorktrees.has(focusId);
+}
+//# sourceMappingURL=focus-worktree-state.js.map

package/dist/focus/focus-worktree-state.js.map

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

package/dist/focus/listener-auto-advance.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Delivery auto-advancement logic.
+ *
+ * Auto-advances deliveries to verify when all issues are Done,
+ * and transitions verify deliveries back to verify_failed when new
+ * open issues are found (e.g., from review agents).
+ */
+import type { DaemonConfig } from '../types/index.js';
+import { getActiveFocuses, updateDeliveryStatus } from '../queries/deliveries.js';
+import { getFocusDeliveries } from '../queries/focuses.js';
+import { fetchEffectiveWorkflow } from '../queries/workflows.js';
+import { getActiveTeams } from './focus-executor.js';
+import { hasFocusWorktree } from './focus-worktree-state.js';
+import { ensureWorktreeCommittedBeforeAdvance } from '../delivery/delivery-lifecycle.js';
+import { createEscalation as defaultCreateEscalation, findOpenOperatorHoldForDelivery, getDeliveryIssues, updateIssueStatus } from '../queries/issues.js';
+/**
+ * Escalation kind used when the bounded retry cap is hit. The dashboard
+ * and merge-back loop scan for this kind to surface schema drift to humans.
+ */
+export declare const SCHEMA_DRIFT_BLOCKED_KIND = "schema_drift_blocked";
+/**
+ * Reset internal violation-attempt state. Test-only.
+ */
+export declare function __resetSchemaViolationStateForTests(): void;
+/**
+ * Snapshot of the violation counter. Test-only.
+ */
+export declare function __getSchemaViolationAttemptsForTests(): ReadonlyMap<string, number>;
+/**
+ * Auto-advance deliveries to verify when all issues are Done.
+ *
+ * For each active team's focus, checks deliveries in coding/queued status.
+ * If ALL issues for such a delivery are Done (0 open), advances it to verify
+ * via the workflow transition. This prevents keep-alive churn where the agent
+ * is woken with "actionable" deliveries that have no remaining work.
+ *
+ * Also checks teamless focuses (after daemon restart) where deliveries
+ * may be stuck in coding with all issues Done.
+ */
+/**
+ * Dependency seam for checkDeliveryAutoAdvance. The real implementation imports
+ * these eagerly; tests inject stubs to avoid the fragile bare-specifier
+ * `mock.module` path under tsx (same rationale as CheckDeliveryWorkStartDeps).
+ */
+export interface CheckDeliveryAutoAdvanceDeps {
+    getActiveTeams?: typeof getActiveTeams;
+    getActiveFocuses?: typeof getActiveFocuses;
+    hasFocusWorktree?: typeof hasFocusWorktree;
+    getFocusDeliveries?: typeof getFocusDeliveries;
+    getDeliveryIssues?: typeof getDeliveryIssues;
+    updateIssueStatus?: typeof updateIssueStatus;
+    ensureWorktreeCommittedBeforeAdvance?: typeof ensureWorktreeCommittedBeforeAdvance;
+    fetchEffectiveWorkflow?: typeof fetchEffectiveWorkflow;
+    updateDeliveryStatus?: typeof updateDeliveryStatus;
+    findOpenOperatorHoldForDelivery?: typeof findOpenOperatorHoldForDelivery;
+}
+export declare function checkDeliveryAutoAdvance(config: DaemonConfig, deps?: CheckDeliveryAutoAdvanceDeps): Promise<void>;
+/**
+ * Dependency seam for checkDeliveryWorkStart. The real implementation imports
+ * the query/mutation functions eagerly from ./supabase.js; tests inject stubs
+ * to avoid the fragile bare-specifier mock path under tsx.
+ */
+export interface CheckDeliveryWorkStartDeps {
+    getActiveFocuses?: typeof getActiveFocuses;
+    getFocusDeliveries?: typeof getFocusDeliveries;
+    getDeliveryIssues?: typeof getDeliveryIssues;
+    fetchEffectiveWorkflow?: typeof fetchEffectiveWorkflow;
+    updateDeliveryStatus?: typeof updateDeliveryStatus;
+}
+/**
+ * Cross queued -> coding the moment a work issue is In Progress (the work-START
+ * edge), during ACTIVE execution -- not only at team exit.
+ *
+ * This restores the advancement the deleted auto_advance_delivery_on_issue_active
+ * PG trigger used to provide (migration 20260614172757), now routed through the
+ * single-writer reconciler. The completion path (status-advance-phase.ts) crosses
+ * this edge when a team exits; this live tick crosses it WHILE the team runs, so a
+ * delivery is never wedged in queued waiting for its team to drive every issue to
+ * terminal in one pass.
+ *
+ * Deliberately NOT folded into checkDeliveryAutoAdvance: that path skips
+ * active-team focuses and skips deliveries with open work (advancing all-done ->
+ * verify while a team executes causes coding->verify->verify_failed churn). The
+ * work-start crossing is the inverse -- it is SAFE during active execution (it is
+ * literally what should happen when a team starts working) and so runs for ALL
+ * active focuses, including those with a live team.
+ *
+ * Only queued deliveries are candidates; the reconciler returns coding for
+ * queued + In-Progress work and stays queued for not-started open work (To Do /
+ * Blocked only) or no work issues (scoping gate). A status write is not
+ * git-touching, so there is no worktree-commit precheck. Idempotent: once a
+ * delivery is coding it is no longer a candidate, so the divergence line logs at
+ * most once per crossing.
+ */
+export declare function checkDeliveryWorkStart(config: DaemonConfig, deps?: CheckDeliveryWorkStartDeps): Promise<void>;
+/**
+ * Check verify deliveries for open issues and transition them back to verify_failed.
+ *
+ * When the review agent creates new issues on a verify delivery, this poll
+ * step detects the open issues and moves the delivery back to verify_failed
+ * so the normal wake/work flow picks it up.
+ *
+ * IMPORTANT: Must be called with a product-scoped config so that only teams
+ * belonging to the current product are checked. Without product scoping,
+ * Product A's poll cycle would operate on Product B's deliveries/issues.
+ */
+/**
+ * Dependency seam for tests. The real implementation imports these functions
+ * eagerly; tests inject stubs via the optional deps parameter so the whole
+ * check can run with NO `mock.module` registered -- which is what keeps the
+ * daemon-core mock-loader quirk (a registered mock poisons bare @telora/* value
+ * imports from unmocked modules) from ever biting this test. Each field
+ * defaults to the real import, so production callers pass nothing.
+ */
+export interface CheckVerifyDeliveriesDeps {
+    createEscalation?: typeof defaultCreateEscalation;
+    getActiveTeams?: typeof getActiveTeams;
+    getActiveFocuses?: typeof getActiveFocuses;
+    getFocusDeliveries?: typeof getFocusDeliveries;
+    getDeliveryIssues?: typeof getDeliveryIssues;
+    fetchEffectiveWorkflow?: typeof fetchEffectiveWorkflow;
+    updateDeliveryStatus?: typeof updateDeliveryStatus;
+    updateIssueStatus?: typeof updateIssueStatus;
+}
+export declare function checkVerifyDeliveriesForOpenIssues(config: DaemonConfig, deps?: CheckVerifyDeliveriesDeps): Promise<void>;
+//# sourceMappingURL=listener-auto-advance.d.ts.map

package/dist/focus/listener-auto-advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener-auto-advance.d.ts","sourceRoot":"","sources":["../../src/focus/listener-auto-advance.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAO7D,OAAO,EAAE,oCAAoC,EAAE,MAAM,mCAAmC,CAAC;AACzF,OAAO,EAAE,gBAAgB,IAAI,uBAAuB,EAAE,+BAA+B,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AA+E1J;;;GAGG;AACH,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAQhE;;GAEG;AACH,wBAAgB,mCAAmC,IAAI,IAAI,CAE1D;AAED;;GAEG;AACH,wBAAgB,oCAAoC,IAAI,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAElF;AAED;;;;;;;;;;GAUG;AACH;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,cAAc,CAAC,EAAE,OAAO,cAAc,CAAC;IACvC,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAC;IAC/C,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAC7C,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAC7C,oCAAoC,CAAC,EAAE,OAAO,oCAAoC,CAAC;IACnF,sBAAsB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IACvD,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;IACnD,+BAA+B,CAAC,EAAE,OAAO,+BAA+B,CAAC;CAC1E;AAED,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,4BAAiC,GACtC,OAAO,CAAC,IAAI,CAAC,CAiTf;AAED;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAC;IAC/C,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAC7C,sBAAsB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IACvD,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,0BAA+B,GACpC,OAAO,CAAC,IAAI,CAAC,CAiEf;AAED;;;;;;;;;;GAUG;AACH;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACxC,gBAAgB,CAAC,EAAE,OAAO,uBAAuB,CAAC;IAClD,cAAc,CAAC,EAAE,OAAO,cAAc,CAAC;IACvC,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;IAC3C,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAC;IAC/C,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAC;IAC7C,sBAAsB,CAAC,EAAE,OAAO,sBAAsB,CAAC;IACvD,oBAAoB,CAAC,EAAE,OAAO,oBAAoB,CAAC;IACnD,iBAAiB,CAAC,EAAE,OAAO,iBAAiB,CAAC;CAC9C;AAED,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,yBAA8B,GACnC,OAAO,CAAC,IAAI,CAAC,CA2Nf"}