@telora/daemon 0.21.26 → 0.21.82

package/dist/listener-auto-advance.js

@@ -1,621 +0,0 @@
-/**
- * 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 { getActiveFocuses, getFocusDeliveries, getDeliveryIssues, updateDeliveryStatus, fetchEffectiveWorkflow, updateIssueStatus } from './supabase.js';
-import { getActiveTeams } from './focus-executor.js';
-import { isStatusAgentActionable } from './stage-classifier.js';
-import { OPEN_ISSUE_STATUSES, filterWorkIssues, filterContextGroups } from './constants.js';
-import { autoCloseContextGroups, sweepDeliveryCloseIssues } from './delivery-close-actions.js';
-import { resolveReconciledWrite } from './delivery-reconciler-apply.js';
-import { isAuditPhaseFocus } from './audit-shape.js';
-import { ensureWorktreeCommittedBeforeAdvance } from './delivery-lifecycle.js';
-import { createEscalation as defaultCreateEscalation, findOpenOperatorHoldForDelivery } from './queries/issues.js';
-import { resolveOperatorHold, writeOperatorHoldGateState, describeOperatorHold } from './operator-hold.js';
-import { resolveExternalHold, makeRequestClosureEvaluator, describeExternalHold } from './external-hold.js';
-import { createLogger } from './log.js';
-const log = createLogger({ module: 'listener' });
-/**
- * Constants mirroring @telora/daemon-core values. Inlined because this module
- * avoids a runtime import of @telora/daemon-core so tests can stub transitive
- * dependencies without fighting tsx's bare-specifier resolution under
- * --experimental-test-module-mocks. Values must stay in sync with the
- * canonical enums in packages/daemon-core/src/execution-status.ts and
- * packages/daemon-core/src/escalation-types.ts.
- */
-const ESCALATION_REASON_ERROR_ENCOUNTERED = 'error_encountered';
-// Mirror of ESCALATION_DISPOSITIONS.NEEDS_OPERATOR (daemon-core disposition.ts);
-// inlined for the same no-runtime-import reason as the reason constant above.
-const ESCALATION_DISPOSITION_NEEDS_OPERATOR = 'needs_operator';
-const DELIVERY_STATUS_QUEUED = 'queued';
-const DELIVERY_STATUS_VERIFY = 'verify';
-const DELIVERY_STATUS_VERIFY_FAILED = 'verify_failed';
-function isSchemaConstraintViolation(err) {
-    return (typeof err === 'object' &&
-        err !== null &&
-        err.name === 'SchemaConstraintViolation');
-}
-function isReadOnlyModeError(err) {
-    return (typeof err === 'object' &&
-        err !== null &&
-        err.name === 'ReadOnlyModeError');
-}
-/** Synthetic constraint name used to key ReadOnlyModeError into the violation counter. */
-const READ_ONLY_MODE_CONSTRAINT = 'read_only_mode';
-/**
- * Cap on consecutive SchemaConstraintViolation attempts for the same
- * (deliveryId, constraintName, rejectedValue) combo before filing a
- * terminal schema_drift_blocked escalation. Tuned for the 2026-05-21
- * incident profile (listener ran ~17 silent retries before discovery).
- */
-const SCHEMA_VIOLATION_RETRY_CAP = 3;
-/**
- * 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 const SCHEMA_DRIFT_BLOCKED_KIND = 'schema_drift_blocked';
-const violationAttempts = new Map();
-function violationKey(deliveryId, constraintName, rejectedValue) {
-    return `${deliveryId}::${constraintName ?? '<unknown>'}::${rejectedValue ?? '<null>'}`;
-}
-/**
- * Reset internal violation-attempt state. Test-only.
- */
-export function __resetSchemaViolationStateForTests() {
-    violationAttempts.clear();
-}
-/**
- * Snapshot of the violation counter. Test-only.
- */
-export function __getSchemaViolationAttemptsForTests() {
-    return violationAttempts;
-}
-export async function checkDeliveryAutoAdvance(config, deps = {}) {
-    const _getActiveTeams = deps.getActiveTeams ?? getActiveTeams;
-    const _getActiveFocuses = deps.getActiveFocuses ?? getActiveFocuses;
-    // NOTE: hasFocusWorktree is intentionally no longer consulted for focus
-    // SELECTION (the 2026-07-27 wedge fix). The deps field + import are retained
-    // for back-compat with existing test call sites; the worktree requirement now
-    // lives only at the write point (ensureWorktreeCommittedBeforeAdvance).
-    const _getFocusDeliveries = deps.getFocusDeliveries ?? getFocusDeliveries;
-    const _getDeliveryIssues = deps.getDeliveryIssues ?? getDeliveryIssues;
-    const _updateIssueStatus = deps.updateIssueStatus ?? updateIssueStatus;
-    const _ensureWorktreeCommittedBeforeAdvance = deps.ensureWorktreeCommittedBeforeAdvance ?? ensureWorktreeCommittedBeforeAdvance;
-    const _fetchEffectiveWorkflow = deps.fetchEffectiveWorkflow ?? fetchEffectiveWorkflow;
-    const _updateDeliveryStatus = deps.updateDeliveryStatus ?? updateDeliveryStatus;
-    const _findOpenOperatorHoldForDelivery = deps.findOpenOperatorHoldForDelivery ?? findOpenOperatorHoldForDelivery;
-    // Only auto-advance for teamless focuses (e.g., after daemon restart where
-    // deliveries are stuck in coding with all issues Done and no team will ever
-    // run advanceDeliveryStatuses). Active teams handle their own advancement
-    // via focus-completion.ts -- auto-advancing while a team is executing
-    // causes coding->verify->verify_failed churn.
-    const activeTeams = _getActiveTeams();
-    // focusId -> audit-phase (isAuditPhaseFocus). A focus is in the audit phase
-    // either explicitly (read_only===true) OR structurally (audit-origin AND not
-    // yet ratified) -- the second signal (injection #7) so a flag-absent audit
-    // focus is still handled as discovery-only instead of wedging the
-    // queued->coding scoping gate. An audit-phase focus's deliveries are
-    // DISCOVERY-ONLY: their contract is Context Group findings, never Task/Bug
-    // issues, so they terminalize without work issues.
-    const focusAuditPhase = new Map();
-    try {
-        const activeFocuses = await _getActiveFocuses(config.organizationId, config.productId);
-        for (const focus of activeFocuses) {
-            // Skip focuses with active teams -- they manage their own advancement
-            if (activeTeams.has(focus.focus_id))
-                continue;
-            // Evaluate EVERY active teamless focus, whether or not it holds a
-            // registered worktree. Focus SELECTION must be independent of worktree
-            // registration: previously this set was populated only when
-            // _hasFocusWorktree was true, so a teamless, worktree-less focus was
-            // never reconciled at all -- a delivery sitting there in verify_failed or
-            // coding had no invoker and was silently unreachable (2026-07-27 wedge:
-            // delivery c42c1db1 cleared only by a manual MCP re-queue). The worktree
-            // requirement did not disappear; it moved to the point of the write --
-            // git-touching advances stay gated by ensureWorktreeCommittedBeforeAdvance
-            // below, while status-only re-queues (verify_failed -> queued) need no disk.
-            focusAuditPhase.set(focus.focus_id, isAuditPhaseFocus({
-                readOnly: focus.read_only === true,
-                auditOrigin: focus.audit_origin === true,
-                ratified: focus.ratified_at != null,
-            }));
-        }
-    }
-    catch (err) {
-        log.warn('Auto-advance: failed to fetch active focuses:', err.message);
-    }
-    for (const [focusId, auditPhase] of focusAuditPhase) {
-        try {
-            const deliveries = await _getFocusDeliveries(focusId);
-            for (const delivery of deliveries) {
-                if (!isStatusAgentActionable(delivery.executionStatus ?? ''))
-                    continue;
-                try {
-                    const issues = await _getDeliveryIssues(delivery.id);
-                    // Context Groups are reference material, not actionable work
-                    const workIssues = filterWorkIssues(issues);
-                    const contextGroups = filterContextGroups(issues);
-                    // A discovery-only delivery (audit-phase focus, no Task/Bug issues) is
-                    // exempt from the scoping gate: it terminalizes once its Context Group
-                    // findings are all resolved (>=1 CG, none open). An un-run audit (no
-                    // CGs yet) is NOT swept -- requiring resolved findings is the
-                    // "discovery complete" signal that prevents killing a pending audit.
-                    // `auditPhase` covers both read_only=true and the second structural
-                    // signal (audit-origin + unratified), so a flag-absent audit focus
-                    // terminalizes too; a NORMAL focus (auditPhase=false) is unaffected.
-                    const discoveryComplete = auditPhase &&
-                        workIssues.length === 0 &&
-                        contextGroups.length > 0 &&
-                        contextGroups.every(cg => !OPEN_ISSUE_STATUSES.has(cg.status));
-                    // Skip deliveries with no work issues (nothing to check), unless this
-                    // is a completed discovery-only delivery that must walk to terminal.
-                    if (workIssues.length === 0 && !discoveryComplete)
-                        continue;
-                    // Single shared open-work predicate (OPEN_ISSUE_STATUSES, the same set
-                    // the reconciler's areDeliveryIssuesDone uses).
-                    const openWork = workIssues.filter(i => OPEN_ISSUE_STATUSES.has(i.status));
-                    if (openWork.length > 0) {
-                        // A delivery with open work never advances FORWARD here. But the
-                        // re-queue edge verify_failed -> queued (delivery-reconciler.ts) is
-                        // the one this teamless pass MUST drive: a verify_failed delivery
-                        // with open work on a teamless focus otherwise has NO invoker and
-                        // sits wedged forever (2026-07-27 incident). checkVerifyDeliveries-
-                        // ForOpenIssues covers only TEAMED focuses; checkDeliveryWorkStart
-                        // owns queued -> coding. So ONLY verify_failed is re-queued here --
-                        // re-queueing `coding` would oscillate against checkDeliveryWorkStart
-                        // (In-Progress work re-advances queued -> coding every tick). The
-                        // re-queue is a STATUS-ONLY write (no git), so no worktree precheck.
-                        if ((delivery.executionStatus ?? '') === DELIVERY_STATUS_VERIFY_FAILED) {
-                            const requeueStatus = (delivery.executionStatus ?? '');
-                            const requeueWorkflow = await _fetchEffectiveWorkflow(delivery.id);
-                            const requeueDecision = resolveReconciledWrite({
-                                site: 'auto-advance',
-                                deliveryId: delivery.id,
-                                deliveryName: delivery.name,
-                                // legacyTarget = current status: pre-fix behavior was "no
-                                // invoker, stay put", so any move is a [reconciler-divergence].
-                                legacyTarget: requeueStatus,
-                                input: {
-                                    currentStatus: requeueStatus,
-                                    issues: issues.map(i => ({ status: i.status, issueType: i.issueType })),
-                                    gitState: { worktreeCommitted: true },
-                                    guardVerdict: null,
-                                    reviewState: null,
-                                    discoveryOnly: false,
-                                },
-                            });
-                            if (requeueDecision.target !== requeueStatus) {
-                                const requeueStage = requeueWorkflow.stages.find(s => s.name === requeueDecision.target);
-                                await _updateDeliveryStatus(delivery.id, requeueDecision.target, requeueStage?.id, undefined, undefined, { organizationId: config.organizationId, fromStatus: requeueStatus });
-                                log.info(`[listener] Re-queued delivery "${delivery.name}" from ${requeueStatus} to ${requeueDecision.target}: ` +
-                                    `${openWork.length} open issue(s) on a teamless focus (no other invoker).`);
-                            }
-                        }
-                        continue;
-                    }
-                    // Auto-close Context Groups + sweep Verified/In-Review issues to Done
-                    // via the shared close actions (single definition).
-                    await autoCloseContextGroups(contextGroups, _updateIssueStatus, log);
-                    await sweepDeliveryCloseIssues(workIssues, _updateIssueStatus, log);
-                    // All work issues are Done (or swept to Done) -- advance
-                    // to verify, but only if the focus worktree has no uncommitted
-                    // changes. Otherwise the agent left work uncommitted and advancing
-                    // risks losing it on focus merge.
-                    const precheck = await _ensureWorktreeCommittedBeforeAdvance({
-                        deliveryId: delivery.id,
-                        deliveryName: delivery.name,
-                        focusId,
-                        organizationId: config.organizationId,
-                        sessionId: null,
-                    });
-                    if (!precheck.ok) {
-                        log.info(`Skip auto-advance of "${delivery.name}": ${precheck.reason}`);
-                        continue;
-                    }
-                    // Advance via the single-writer reconciler. The teamless path has no
-                    // exiting team, so the worktree-commit gate is the precheck above
-                    // (committed === true here), there is no guard verdict, and no review
-                    // session. The reconciler is single-step, so we walk queued -> coding
-                    // -> verify by re-keying currentStatus to each actual write.
-                    // (workflow doesn't allow queued -> verify directly.) A completed
-                    // discovery-only delivery walks one step further, verify -> done, since
-                    // its findings ARE the output and there is no review to await.
-                    const workflow = await _fetchEffectiveWorkflow(delivery.id);
-                    const reconcilerIssues = issues.map(i => ({ status: i.status, issueType: i.issueType }));
-                    let currentStatus = (delivery.executionStatus ?? '');
-                    if (currentStatus === DELIVERY_STATUS_QUEUED) {
-                        const decision = resolveReconciledWrite({
-                            site: 'auto-advance',
-                            deliveryId: delivery.id,
-                            deliveryName: delivery.name,
-                            legacyTarget: 'coding',
-                            input: {
-                                currentStatus,
-                                issues: reconcilerIssues,
-                                gitState: { worktreeCommitted: true },
-                                guardVerdict: null,
-                                reviewState: null,
-                                discoveryOnly: discoveryComplete,
-                            },
-                        });
-                        const stage = workflow.stages.find(s => s.name === decision.target);
-                        await _updateDeliveryStatus(delivery.id, decision.target, stage?.id, undefined, undefined, { organizationId: config.organizationId, fromStatus: currentStatus });
-                        currentStatus = decision.target;
-                    }
-                    const verifyDecision = resolveReconciledWrite({
-                        site: 'auto-advance',
-                        deliveryId: delivery.id,
-                        deliveryName: delivery.name,
-                        legacyTarget: 'verify',
-                        input: {
-                            currentStatus,
-                            issues: reconcilerIssues,
-                            gitState: { worktreeCommitted: true },
-                            guardVerdict: null,
-                            reviewState: null,
-                            discoveryOnly: discoveryComplete,
-                        },
-                    });
-                    const verifyStage = workflow.stages.find(s => s.name === verifyDecision.target);
-                    await _updateDeliveryStatus(delivery.id, verifyDecision.target, verifyStage?.id, undefined, undefined, { organizationId: config.organizationId, fromStatus: currentStatus });
-                    currentStatus = verifyDecision.target;
-                    // Discovery-only terminal step: verify -> done (no review window). The
-                    // legacyTarget stays at verify, so with the reconciler disabled the
-                    // delivery holds at verify exactly as before -- this edge is
-                    // reconciler-authoritative only.
-                    if (discoveryComplete && currentStatus === DELIVERY_STATUS_VERIFY) {
-                        const doneDecision = resolveReconciledWrite({
-                            site: 'auto-advance',
-                            deliveryId: delivery.id,
-                            deliveryName: delivery.name,
-                            legacyTarget: DELIVERY_STATUS_VERIFY,
-                            input: {
-                                currentStatus,
-                                issues: reconcilerIssues,
-                                gitState: { worktreeCommitted: true },
-                                guardVerdict: null,
-                                reviewState: null,
-                                discoveryOnly: true,
-                            },
-                        });
-                        if (doneDecision.target !== currentStatus) {
-                            // Operator-hold gate (FAIL-CLOSED): even this discovery-only
-                            // verify->done edge (audit deliveries, no review window) must not
-                            // converge over an open needs_operator / external_wait escalation
-                            // anchored to the delivery -- the same gate as the review-exit
-                            // auto-approve path, so the hold holds by ANY path to done.
-                            const holdDeps = {
-                                findOpenOperatorHoldForDelivery: _findOpenOperatorHoldForDelivery,
-                                updateDeliveryStatus: _updateDeliveryStatus,
-                            };
-                            const hold = await resolveOperatorHold(holdDeps, delivery.id, focusId);
-                            // External-hold gate (sibling of the operator-hold gate): an
-                            // irreducibly-external dependency carried as gate_state STATE (not
-                            // an escalation row) must ALSO hold this verify->done edge. It
-                            // clears by re-reading its condition, not by a human resolve.
-                            const externalHold = hold.held
-                                ? { held: false, hold: null, cleared: false }
-                                : await resolveExternalHold(holdDeps, delivery.id, delivery.gateState, 
-                                // Deferred import: queries/requests.js -> queries/shared.js pulls a
-                                // bare @telora/daemon-core value import that mis-resolves under the
-                                // node:test module-mock loader. A dynamic import inside the reader
-                                // keeps it out of load-time module graphs; it only resolves when a
-                                // request-referenced hold is actually re-read (never in mocked tests
-                                // that carry no such hold). Behavior is identical in production.
-                                makeRequestClosureEvaluator(async (ids) => {
-                                    const { listOutgoingRequestStatuses } = await import('./queries/requests.js');
-                                    return listOutgoingRequestStatuses(config.productId, ids);
-                                }));
-                            if (hold.held) {
-                                await writeOperatorHoldGateState(holdDeps, delivery.id, hold);
-                                log.info(`[listener] Delivery "${delivery.name}" NOT moved to done -- ${describeOperatorHold(hold)}. ` +
-                                    `Left in verify pending operator resolution.`);
-                            }
-                            else if (externalHold.held) {
-                                log.info(`[listener] Delivery "${delivery.name}" NOT moved to done -- ${describeExternalHold(externalHold)}. ` +
-                                    `Left in verify pending an external reality change.`);
-                            }
-                            else {
-                                const doneStage = workflow.stages.find(s => s.name === doneDecision.target);
-                                await _updateDeliveryStatus(delivery.id, doneDecision.target, doneStage?.id, undefined, undefined, { organizationId: config.organizationId, fromStatus: currentStatus });
-                                currentStatus = doneDecision.target;
-                            }
-                        }
-                    }
-                    log.info(`[listener] Auto-advanced delivery "${delivery.name}" from ${delivery.executionStatus} to ${currentStatus}: ` +
-                        (discoveryComplete
-                            ? `discovery-only delivery, ${contextGroups.length} finding(s) resolved`
-                            : `all ${workIssues.length} work issue(s) Done`));
-                }
-                catch (err) {
-                    log.warn(`[listener] Auto-advance: failed to check/advance delivery "${delivery.name}":`, err.message);
-                }
-            }
-        }
-        catch (err) {
-            log.warn(`[listener] Auto-advance: failed to fetch deliveries for focus ${focusId}:`, err.message);
-        }
-    }
-}
-/**
- * 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 async function checkDeliveryWorkStart(config, deps = {}) {
-    const _getActiveFocuses = deps.getActiveFocuses ?? getActiveFocuses;
-    const _getFocusDeliveries = deps.getFocusDeliveries ?? getFocusDeliveries;
-    const _getDeliveryIssues = deps.getDeliveryIssues ?? getDeliveryIssues;
-    const _fetchEffectiveWorkflow = deps.fetchEffectiveWorkflow ?? fetchEffectiveWorkflow;
-    const _updateDeliveryStatus = deps.updateDeliveryStatus ?? updateDeliveryStatus;
-    let activeFocuses;
-    try {
-        activeFocuses = await _getActiveFocuses(config.organizationId, config.productId);
-    }
-    catch (err) {
-        log.warn('Work-start: failed to fetch active focuses:', err.message);
-        return;
-    }
-    for (const focus of activeFocuses) {
-        let deliveries;
-        try {
-            deliveries = await _getFocusDeliveries(focus.focus_id);
-        }
-        catch (err) {
-            log.warn(`Work-start: failed to fetch deliveries for focus ${focus.focus_id}:`, err.message);
-            continue;
-        }
-        for (const delivery of deliveries) {
-            // Only queued deliveries can take the work-start crossing.
-            if ((delivery.executionStatus ?? '') !== DELIVERY_STATUS_QUEUED)
-                continue;
-            try {
-                const issues = await _getDeliveryIssues(delivery.id);
-                const reconcilerIssues = issues.map(i => ({ status: i.status, issueType: i.issueType }));
-                // Single-writer reconciler decides: queued + In-Progress work -> coding;
-                // otherwise stays queued (no active work yet / scoping gate). legacyTarget
-                // is the pre-fix behavior (stay queued), so the [reconciler-divergence]
-                // line marks the crossing.
-                const decision = resolveReconciledWrite({
-                    site: 'work-start',
-                    deliveryId: delivery.id,
-                    deliveryName: delivery.name,
-                    legacyTarget: DELIVERY_STATUS_QUEUED,
-                    input: {
-                        currentStatus: DELIVERY_STATUS_QUEUED,
-                        issues: reconcilerIssues,
-                        gitState: { worktreeCommitted: true },
-                        guardVerdict: null,
-                        reviewState: null,
-                    },
-                });
-                if (decision.target === DELIVERY_STATUS_QUEUED)
-                    continue; // no active work yet
-                const workflow = await _fetchEffectiveWorkflow(delivery.id);
-                const stage = workflow.stages.find(s => s.name === decision.target);
-                // fromStatus=queued double-write guard: if another path already crossed
-                // this delivery, the optimistic from-status check rejects/no-ops the write.
-                await _updateDeliveryStatus(delivery.id, decision.target, stage?.id, undefined, undefined, { organizationId: config.organizationId, fromStatus: DELIVERY_STATUS_QUEUED });
-                log.info(`[listener] Work-start: delivery "${delivery.name}" crossed ${DELIVERY_STATUS_QUEUED} -> ${decision.target} ` +
-                    `(work issue In Progress)`);
-            }
-            catch (err) {
-                log.warn(`Work-start: failed to advance delivery "${delivery.name}":`, err.message);
-            }
-        }
-    }
-}
-export async function checkVerifyDeliveriesForOpenIssues(config, deps = {}) {
-    const createEscalation = deps.createEscalation ?? defaultCreateEscalation;
-    const activeTeams = getActiveTeams();
-    if (activeTeams.size === 0)
-        return;
-    // Review-window single-writer discipline: while a focus has an open review
-    // window (review_requested_at set), the live reconciler must NOT apply
-    // verify -> verify_failed to that focus's deliveries. A review agent's own
-    // first defect filing would otherwise regress the delivery mid-pass, cascade
-    // the phase to coding, and cancel the review -- so only find-nothing reviews
-    // ever complete. Defects filed during the pass accumulate and route once, at
-    // review exit, via the deterministic review-exit router
-    // (completion/review-exit-phase.ts runReviewExitHandler). The suppression is
-    // per-focus (keyed on that focus's review_requested_at), NOT global: deliveries
-    // of OTHER focuses with no open window still route promptly in this same tick.
-    const reviewWindowFocusIds = new Set();
-    try {
-        const focuses = await getActiveFocuses(config.organizationId, config.productId);
-        for (const f of focuses) {
-            if (f.review_requested_at)
-                reviewWindowFocusIds.add(f.focus_id);
-        }
-    }
-    catch (err) {
-        // On a read failure, fall through with an empty set (pre-existing behavior:
-        // every focus routes). The review-exit router remains the backstop writer.
-        log.warn(`[listener] Failed to resolve review-window focuses for verify open-issue check: ${err.message}`);
-    }
-    for (const [focusId, team] of activeTeams) {
-        if (team.phase !== 'executing')
-            continue;
-        // Only operate on teams belonging to this product — without this guard,
-        // one product's poll cycle would modify another product's issues/deliveries.
-        if (team.productId !== config.productId)
-            continue;
-        // Suppress the live verify -> verify_failed write for a focus whose review
-        // window is open; the review-exit router owns the transition during the
-        // window (batching all filed defects at exit). Per-focus, never global.
-        if (reviewWindowFocusIds.has(focusId)) {
-            log.info(`[listener] Skipping verify open-issue routing for focus ${focusId} ` +
-                `("${team.focusName}"): review window open -- defects route at review exit.`);
-            continue;
-        }
-        try {
-            const deliveries = await getFocusDeliveries(focusId);
-            const verifyDeliveries = deliveries.filter(d => d.executionStatus === DELIVERY_STATUS_VERIFY);
-            for (const delivery of verifyDeliveries) {
-                try {
-                    const issues = await getDeliveryIssues(delivery.id);
-                    // Context Groups are reference material, not actionable work.
-                    // Auto-close any that are still open when all tasks/bugs are done.
-                    const workIssues = filterWorkIssues(issues);
-                    const contextGroups = filterContextGroups(issues);
-                    // Single shared open-work predicate (delivery-reconciler / constants).
-                    const openWork = workIssues.filter(i => OPEN_ISSUE_STATUSES.has(i.status));
-                    // Auto-close Context Groups when all work issues are done
-                    // (shared close action -- single definition).
-                    if (openWork.length === 0) {
-                        await autoCloseContextGroups(contextGroups, updateIssueStatus, log);
-                        continue;
-                    }
-                    // Route verify -> verify_failed through the single-writer reconciler.
-                    // Open work on a verify delivery is the trigger; the reconciler agrees
-                    // (verify + open work -> verify_failed) ahead of any review signal.
-                    const workflow = await fetchEffectiveWorkflow(delivery.id);
-                    const decision = resolveReconciledWrite({
-                        site: 'verify-open-issues',
-                        deliveryId: delivery.id,
-                        deliveryName: delivery.name,
-                        legacyTarget: 'verify_failed',
-                        input: {
-                            currentStatus: 'verify',
-                            issues: issues.map(i => ({ status: i.status, issueType: i.issueType })),
-                            gitState: { worktreeCommitted: true },
-                            guardVerdict: null,
-                            reviewState: { reviewRequested: true, reportExists: false, sessionType: 'coding', succeeded: false },
-                        },
-                    });
-                    const awaitingVerifyStage = workflow.stages.find(s => s.name === decision.target);
-                    const verifyFailedTransition = { organizationId: config.organizationId, fromStatus: 'verify' };
-                    try {
-                        await updateDeliveryStatus(delivery.id, decision.target, awaitingVerifyStage?.id, undefined, undefined, verifyFailedTransition);
-                        // Successful update -- evict any prior violation counters
-                        // for this delivery so transient earlier violations do not
-                        // accumulate across distinct (constraint, value) windows.
-                        for (const key of [...violationAttempts.keys()]) {
-                            if (key.startsWith(`${delivery.id}::`))
-                                violationAttempts.delete(key);
-                        }
-                        log.info(`[listener] Delivery "${delivery.name}" moved from ${delivery.executionStatus} to verify_failed: ` +
-                            `${openWork.length} open issue(s) found`);
-                    }
-                    catch (err) {
-                        // SchemaConstraintViolation: typed runtime CHECK rejection.
-                        // ReadOnlyModeError: startup schema-gate fired in warn mode.
-                        // Both are schema-drift signals routed through the same bounded-
-                        // retry + schema_drift_blocked escalation path. The operator
-                        // response is identical: deploy the missing migration.
-                        const schemaErr = isSchemaConstraintViolation(err)
-                            ? { constraintName: err.constraintName, rejectedValue: err.rejectedValue, cause: 'check_violation' }
-                            : isReadOnlyModeError(err)
-                                ? { constraintName: READ_ONLY_MODE_CONSTRAINT, rejectedValue: err.action, cause: 'read_only_mode' }
-                                : null;
-                        if (schemaErr) {
-                            const key = violationKey(delivery.id, schemaErr.constraintName, schemaErr.rejectedValue);
-                            const attempts = (violationAttempts.get(key) ?? 0) + 1;
-                            violationAttempts.set(key, attempts);
-                            if (attempts < SCHEMA_VIOLATION_RETRY_CAP) {
-                                log.warn(`[listener] Schema drift (${schemaErr.cause}) rejected verify_failed transition for "${delivery.name}" ` +
-                                    `(${schemaErr.constraintName ?? '<unknown>'} rejected ${schemaErr.rejectedValue ?? '<null>'}): ` +
-                                    `attempt ${attempts}/${SCHEMA_VIOLATION_RETRY_CAP}, will retry next poll`);
-                            }
-                            else {
-                                log.error(`[listener] Schema drift blocked (${schemaErr.cause}): ${schemaErr.constraintName ?? '<unknown>'} ` +
-                                    `rejects ${schemaErr.rejectedValue ?? '<null>'} after ${attempts} attempts on delivery "${delivery.name}". ` +
-                                    `Filing escalation.`);
-                                const description = schemaErr.cause === 'read_only_mode'
-                                    ? `Schema drift: daemon is in read-only mode (schema-version gate fired in warn ` +
-                                        `mode) so action '${schemaErr.rejectedValue}' is blocked after ${attempts} attempts.\n\n` +
-                                        `**Delivery:** ${delivery.name} (${delivery.id})\n` +
-                                        `**Focus:** ${team.focusName} (${focusId})\n` +
-                                        `**Last error:** ${err.message}`
-                                    : `Schema drift: CHECK constraint ${schemaErr.constraintName ?? '<unknown>'} ` +
-                                        `rejects value ${schemaErr.rejectedValue ?? '<null>'} after ${attempts} attempts.\n\n` +
-                                        `**Delivery:** ${delivery.name} (${delivery.id})\n` +
-                                        `**Focus:** ${team.focusName} (${focusId})\n` +
-                                        `**Last error:** ${err.message}`;
-                                const whatWasTried = schemaErr.cause === 'read_only_mode'
-                                    ? `Listener attempted verify_failed transition ${attempts} times; each was ` +
-                                        `blocked by the read-only gate before the network call.`
-                                    : `Listener attempted verify_failed transition ${attempts} times; each was ` +
-                                        `rejected by the same CHECK constraint.`;
-                                const helpNeeded = schemaErr.cause === 'read_only_mode'
-                                    ? `Apply the missing migrations the daemon expects (see schema-gate log line ` +
-                                        `at startup) and restart the daemon, OR set TELORA_SCHEMA_GATE=off to bypass ` +
-                                        `the gate if you know the missing migrations are intentional.`
-                                    : `Confirm the production DB schema includes the migration that teaches ` +
-                                        `the CHECK constraint to accept '${schemaErr.rejectedValue ?? '<null>'}'. ` +
-                                        `If the schema is correct, the daemon source may be writing a stale value.`;
-                                try {
-                                    await createEscalation({
-                                        organizationId: config.organizationId,
-                                        sessionId: '',
-                                        issueId: null,
-                                        reasonType: ESCALATION_REASON_ERROR_ENCOUNTERED,
-                                        // Operator triage: apply the missing migration / fix the schema.
-                                        disposition: ESCALATION_DISPOSITION_NEEDS_OPERATOR,
-                                        anchor: { deliveryId: delivery.id, focusId },
-                                        description,
-                                        whatWasTried,
-                                        helpNeeded,
-                                        escalationKind: SCHEMA_DRIFT_BLOCKED_KIND,
-                                        // Evidence/payload only -- provenance lives on the columns
-                                        // via the anchor.
-                                        metadata: {
-                                            cause: schemaErr.cause,
-                                            constraintName: schemaErr.constraintName,
-                                            rejectedValue: schemaErr.rejectedValue,
-                                            deliveryName: delivery.name,
-                                            attempts,
-                                            lastAttemptAt: new Date().toISOString(),
-                                        },
-                                    });
-                                }
-                                catch (escErr) {
-                                    log.warn(`[listener] Failed to file schema_drift_blocked escalation for "${delivery.name}":`, escErr.message);
-                                }
-                                // Evict so a later schema fix can heal cleanly without manual reset.
-                                violationAttempts.delete(key);
-                            }
-                        }
-                        else {
-                            // Non-schema failure of the verify -> verify_failed status WRITE
-                            // (distinct from the issue-fetch failure handled by the outer catch).
-                            log.warn(`[listener] Failed to write verify -> verify_failed transition for "${delivery.name}":`, err.message);
-                        }
-                    }
-                }
-                catch (err) {
-                    // Failure fetching/processing this verify delivery's issues (the outer
-                    // per-delivery guard, distinct from the transition-write failure above).
-                    log.warn(`[listener] Failed to check issues for verify delivery "${delivery.name}":`, err.message);
-                }
-            }
-        }
-        catch (err) {
-            log.warn(`[listener] Failed to check verify deliveries for "${team.focusName}":`, err.message);
-        }
-    }
-}
-//# sourceMappingURL=listener-auto-advance.js.map