night-orch 0.3.2 → 0.4.0

package/dist/runner/poller.js

@@ -11,8 +11,6 @@ import { resolveEnvironmentMode, setupEnvironment, teardownEnvironment, } from '
 import { createWorkerAdapter } from '../workers/factory.js';
 import { executeLoop } from '../loop/engine.js';
 import { resolveWorkflow } from '../loop/workflow.js';
-import { publishPR } from '../publishing/publisher.js';
-import { MergeConflictError } from '../publishing/push.js';
 import { transitionLabels } from '../labels/manager.js';
 import { buildLabelConfig } from '../labels/config.js';
 import { NotificationDispatcher } from '../notify/dispatcher.js';
@@ -22,21 +20,31 @@ import { branchName } from '../utils/ids.js';
 import { logger } from '../utils/logger.js';
 import { nowUtcIso } from '../utils/time.js';
 import { postPlanSummaryComment } from '../loop/plan-summary-comment.js';
-import { executeRebase, queueRebase } from '../ops/rebase-and-check.js';
-import { queueContinue } from '../ops/continue.js';
+import { executeRebase } from '../ops/rebase-and-check.js';
 import { markerTag, upsertBotComment } from '../forge/bot-comment.js';
 import { formatStatusComment } from '../forge/status-comment.js';
-import { scanForReactions } from '../reactions/scanner.js';
-import { handleReaction } from '../reactions/handler.js';
 import { processMergeQueue } from '../merge-queue/runner.js';
 import { decomposeIssue, shouldAttemptDecompose } from '../discovery/decomposer.js';
 import { executeParallelSubtasks } from '../loop/parallel.js';
 import { buildWorkerEnv } from '../workers/env.js';
 import { isPlanningIssue } from '../planning/mode.js';
-import { resolveIssueRepo } from '../utils/issue-repo.js';
-import { isCommandProcessed, markCommandProcessed, parseOrchCommands, } from '../discovery/commands.js';
 import { AgentObservability, setActiveAgentObservability, clearActiveAgentObservability, } from '../events/observability.js';
+// Extracted modules
+import { finalizeRunOutcome } from './run-finalizer.js';
+import { processCommentCommands, missingCommentCommandIssues } from './comment-commands.js';
+import { scanAndHandleReactions, reactionCursors } from './reaction-scan.js';
+import { coerceAgentName, isImmediateFollowupStatus, applyWorkflowAgentOverrides, applyWorkflowRoleDefaults, resolveWorkerProfileForAgent, extractFollowupPromptFeedback, prioritizeDiscoveredIssues, selectReplayableRun, shouldResetBranch, makePayload, postStatusComment, postErrorStatusComment, toErrorMessage, sanitizeErrorForComment, } from './helpers.js';
 const STATUS_MARKER = markerTag('status');
+/**
+ * Evict entries from process-global caches that are keyed by repo+issue.
+ * Called when a run reaches a terminal state so the caches don't grow
+ * unbounded over the daemon's lifetime.
+ */
+function cleanupRunCaches(repo, issueNumber) {
+    const key = `${repo}#${issueNumber}`;
+    missingCommentCommandIssues.delete(key);
+    reactionCursors.delete(key);
+}
 /**
  * Process one poll cycle: discover eligible issues, claim and process.
  * Repositories are processed in parallel; each repo runs up to
@@ -175,11 +183,6 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                             }
                             continue;
                         }
-                        // Lease duration is deliberately short (30 min) so a
-                        // crashed poller's leases expire promptly. The engine
-                        // bumps the deadline on every phase checkpoint via
-                        // leaseHeartbeat below, so a long run is not at risk of
-                        // expiring mid-work.
                         if (!leaseManager.acquire(issueRepo, discoveredIssue.issue.number, 'poller', 1800)) {
                             continue;
                         }
@@ -244,12 +247,10 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                             // Detect if this queued run needs a forced branch reset (e.g., after merge conflict)
                             const forceReset = activeRun?.blockReason === 'merge_conflict';
                             // Detect rebase mode from queued run's phaseData
-                            // If force-resetting, ignore stale rebase context — we're starting fresh
                             const reactionType = activeRun?.phaseData?.reactionType;
                             const isRebaseRun = !forceReset && (reactionType === 'rebase' || reactionType === 'merge_conflict');
                             const followupPromptFeedback = extractFollowupPromptFeedback(activeRun?.phaseData);
                             // Check if prior run left tainted work that should be discarded
-                            // Never reset to base for rebase runs — we need the existing branch
                             const planningMode = isPlanningIssue(discoveredIssue.issue.labels, repoConfigForRun);
                             const resetToBase = forceReset || (!isRebaseRun && (planningMode || shouldResetBranch(runManager, repoConfig.repo, discoveredIssue.issue.number, run.id)));
                             // Create worktree
@@ -259,14 +260,14 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                 branchName: branch,
                                 worktreePath,
                                 resetToBase,
+                                updateStrategy: repoConfig.updateStrategy,
                             });
                             // Execute rebase if this is a rebase-queued run
                             if (isRebaseRun) {
                                 logger.info({ repo: repoConfig.repo, issue: discoveredIssue.issue.number, runId: run.id }, 'Executing rebase for queued rebase run');
                                 const verifyCommands = repoConfig.verify ?? [];
-                                const rebaseResult = await executeRebase(repoConfig.localPath, worktreePath, branch, repoConfig.baseBranch, issueRepo, discoveredIssue.issue.number, verifyCommands);
+                                const rebaseResult = await executeRebase(repoConfig.localPath, worktreePath, branch, repoConfig.baseBranch, issueRepo, discoveredIssue.issue.number, verifyCommands, repoConfig.updateStrategy);
                                 if (rebaseResult.conflict) {
-                                    // Rebase had conflicts — block the run; retry will reset the branch and re-implement
                                     runManager.update(run.id, {
                                         status: 'blocked',
                                         blockReason: 'merge_conflict',
@@ -295,7 +296,6 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                     continue;
                                 }
                                 if (rebaseResult.rebased && rebaseResult.verifyPassed) {
-                                    // Rebase succeeded and verify passes — done, transition back to review_ready
                                     logger.info({ repo: repoConfig.repo, issue: discoveredIssue.issue.number }, 'Rebase succeeded, verify passed — returning to review_ready');
                                     runManager.update(run.id, {
                                         status: 'review_ready',
@@ -312,7 +312,6 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                     continue;
                                 }
                                 if (!rebaseResult.rebased && rebaseResult.verifyPassed) {
-                                    // Already up-to-date and verify passes — nothing to do
                                     logger.info({ repo: repoConfig.repo, issue: discoveredIssue.issue.number }, 'Branch already up to date — returning to review_ready');
                                     runManager.update(run.id, {
                                         status: 'review_ready',
@@ -325,8 +324,6 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                     repoProcessed++;
                                     continue;
                                 }
-                                // Rebase succeeded but verify failed — fall through to the loop engine
-                                // so the coder can fix the issues introduced by upstream changes
                                 logger.info({ repo: repoConfig.repo, issue: discoveredIssue.issue.number }, 'Rebase done but verify failed — entering code loop to fix');
                             }
                             if (repoConfigForRun.environment) {
@@ -377,6 +374,7 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                 prReviewFeedback: followupPromptFeedback,
                                 sessionIds: {},
                                 stepOutputs: {},
+                                iterationSnapshots: [],
                             };
                             // Check if decomposition is enabled and appropriate
                             const shouldDecompose = config.loop.decompose
@@ -466,17 +464,12 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                 repoProcessed++;
                             else
                                 repoErrors++;
-                            // Release per-run observability resources (session log
-                            // streams + event bus history) once the run has reached
-                            // a terminal state — without this both Maps grow for the
-                            // daemon's entire lifetime.
                             try {
                                 await observability.closeRun(run.id);
                             }
                             catch (closeErr) {
                                 logger.debug({ runId: run.id, err: closeErr }, 'closeRun failed (best-effort)');
                             }
-                            // Evict per-issue caches so they don't grow unbounded.
                             cleanupRunCaches(repoConfig.repo, discoveredIssue.issue.number);
                         }
                         catch (err) {
@@ -494,11 +487,7 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                     endedAt: nowUtcIso(),
                                 });
                                 if (canAutoRetry) {
-                                    // Bump retry_count on the same row so repeated replay
-                                    // retries converge on maxRetries. Without this the
-                                    // same run row cycles error → queued → error forever.
                                     runManager.incrementRetryCount(runId);
-                                    // Auto-retry: transition back to queued so the next poll picks it up
                                     logger.info({ repo: repoConfig.repo, issue: discoveredIssue.issue.number, attempt: attemptCount, maxRetries }, 'Infra error — auto-retrying (transitioning back to ready)');
                                     try {
                                         const latestIssue = await forge.getIssue(issueRepo, discoveredIssue.issue.number);
@@ -520,7 +509,6 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
                                     });
                                 }
                                 else {
-                                    // Retries exhausted: mark as error, require human
                                     logger.warn({ repo: repoConfig.repo, issue: discoveredIssue.issue.number, currentRetries, maxRetries }, 'Auto-retry limit reached — marking as error');
                                     try {
                                         const latestIssue = await forge.getIssue(issueRepo, discoveredIssue.issue.number);
@@ -607,754 +595,4 @@ export async function pollOnce(config, db, dryRun, metrics, targetIssue) {
         await observability.close();
     }
 }
-async function finalizeRunOutcome(params) {
-    const { finalCtx, runId, issue, runDurationSec, repo, repoConfig, issueRepo, issueNumber, db, forge, runManager, notifier, metrics, maxAutoRetries, botUser, } = params;
-    if (finalCtx.terminalStatus === 'publish') {
-        try {
-            const publishResult = await publishPR(finalCtx, forge, db);
-            runManager.update(runId, {
-                status: 'review_ready',
-                iterationCount: finalCtx.iteration,
-                prNumber: publishResult.prNumber,
-                prTitle: publishResult.prTitle,
-                endedAt: nowUtcIso(),
-            });
-            const latestIssue = await forge.getIssue(issueRepo, issueNumber);
-            await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'review_ready', buildLabelConfig(repoConfig, latestIssue.labels));
-            const notificationEvent = publishResult.created ? 'pr_ready' : 'pr_updated';
-            const notifyResult = await notifier.dispatch(makePayload(notificationEvent, repo, issue, {
-                prUrl: publishResult.prUrl,
-                prNumber: publishResult.prNumber,
-                summary: publishResult.created
-                    ? `PR ready: ${publishResult.prUrl}`
-                    : `PR updated: ${publishResult.prUrl}`,
-            }));
-            try {
-                metrics?.incRunsTotal('completed');
-                metrics?.observeRunDuration(runDurationSec);
-                metrics?.incPROperations(publishResult.created ? 'created' : 'updated');
-                for (const s of notifyResult.sent) {
-                    metrics?.incNotifications(s.channel, s.success ? 'sent' : 'failed');
-                }
-            }
-            catch { /* best-effort */ }
-            return 'processed';
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to publish PR');
-            const errorMessage = toErrorMessage(err);
-            // Merge conflicts during push get structured block reason so retry resets the branch
-            if (err instanceof MergeConflictError) {
-                runManager.update(runId, {
-                    status: 'blocked',
-                    iterationCount: finalCtx.iteration,
-                    blockReason: 'merge_conflict',
-                    lastError: err.message,
-                    endedAt: nowUtcIso(),
-                });
-                const latestIssue = await forge.getIssue(issueRepo, issueNumber);
-                await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'blocked', buildLabelConfig(repoConfig, latestIssue.labels), 'merge_conflict');
-                await postStatusComment({
-                    forge,
-                    issueRepo,
-                    issueNumber,
-                    botUser,
-                    body: formatStatusComment({
-                        blockReason: 'Publish failed due to merge conflicts while pushing branch updates.',
-                        nextStep: 'Run /orch retry to reset the branch to base and re-implement on top of latest main.',
-                    }),
-                    warnMessage: 'Failed to post publish merge-conflict status comment',
-                });
-                try {
-                    metrics?.incRunsTotal('blocked');
-                    metrics?.observeRunDuration(runDurationSec);
-                }
-                catch { /* best-effort */ }
-                return 'error';
-            }
-            const currentRun = runManager.getById(runId);
-            const currentRetries = currentRun?.retryCount ?? 0;
-            runManager.update(runId, { status: 'error', iterationCount: finalCtx.iteration, lastError: errorMessage, endedAt: nowUtcIso() });
-            const latestIssue = await forge.getIssue(issueRepo, issueNumber);
-            if (currentRetries < maxAutoRetries) {
-                runManager.incrementRetryCount(runId);
-                await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'queued', buildLabelConfig(repoConfig, latestIssue.labels));
-                logger.info({ repo, issueNumber, attempt: currentRetries + 1, maxAutoRetries }, 'Publish failed — auto-retrying');
-                await postErrorStatusComment({
-                    forge,
-                    issueRepo,
-                    issueNumber,
-                    botUser,
-                    error: `Publish failed. Last error: ${errorMessage}`,
-                    retryCount: currentRetries + 1,
-                    maxRetries: maxAutoRetries,
-                    nextStep: 'Automatic retry queued. night-orch will retry this issue on the next poll cycle.',
-                    warnMessage: 'Failed to post publish auto-retry status comment',
-                });
-            }
-            else {
-                await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'error', buildLabelConfig(repoConfig, latestIssue.labels));
-                const attemptCount = currentRetries + 1;
-                await postErrorStatusComment({
-                    forge,
-                    issueRepo,
-                    issueNumber,
-                    botUser,
-                    error: `Failed after ${attemptCount} attempts. Last error: ${errorMessage}`,
-                    retryCount: attemptCount,
-                    maxRetries: maxAutoRetries,
-                    nextStep: 'Manual action required: inspect the failure, then run /orch retry or /orch continue.',
-                    warnMessage: 'Failed to post publish retry-exhausted status comment',
-                });
-                const sanitizedErrorForSummary = sanitizeErrorForComment(errorMessage);
-                try {
-                    await notifier.dispatch(makePayload('retry_exhausted', repo, issue, {
-                        summary: `Publish failed after ${attemptCount} attempts: ${sanitizedErrorForSummary}`,
-                    }));
-                }
-                catch (notifyErr) {
-                    logger.warn({ repo, issueNumber, err: notifyErr }, 'Failed to send publish retry exhaustion notification');
-                }
-            }
-            try {
-                metrics?.incRunsTotal('error');
-                metrics?.observeRunDuration(runDurationSec);
-            }
-            catch { /* best-effort */ }
-            return 'error';
-        }
-    }
-    if (finalCtx.terminalStatus === 'blocked') {
-        const blockReason = buildBlockReason(finalCtx);
-        runManager.update(runId, {
-            status: 'blocked',
-            iterationCount: finalCtx.iteration,
-            lastError: blockReason,
-            blockReason: finalCtx.blockReason ?? null,
-            endedAt: nowUtcIso(),
-        });
-        const latestIssue = await forge.getIssue(issueRepo, issueNumber);
-        await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'blocked', buildLabelConfig(repoConfig, latestIssue.labels), finalCtx.blockReason ?? undefined);
-        // Upsert status comment with block reason
-        try {
-            const statusBody = formatStatusComment({
-                blockReason,
-                iteration: finalCtx.iteration,
-                maxIterations: finalCtx.adjustedLimits.maxReviewIterations,
-                cost: finalCtx.estimatedCostUsd,
-            });
-            if (botUser) {
-                await upsertBotComment(forge, issueRepo, issueNumber, STATUS_MARKER, statusBody, botUser);
-            }
-            else {
-                await forge.commentOnIssue(issueRepo, issueNumber, formatBlockComment(blockReason, finalCtx));
-            }
-        }
-        catch (commentErr) {
-            logger.warn({ repo, issueNumber, err: commentErr }, 'Failed to post block reason comment');
-        }
-        const notifyResult = await notifier.dispatch(makePayload('blocked', repo, issue, {
-            summary: blockReason,
-            blockingReason: blockReason,
-            reviewSummary: finalCtx.reviewResult?.summary ?? null,
-        }));
-        try {
-            metrics?.incRunsTotal('blocked');
-            metrics?.observeRunDuration(runDurationSec);
-            for (const s of notifyResult.sent) {
-                metrics?.incNotifications(s.channel, s.success ? 'sent' : 'failed');
-            }
-        }
-        catch { /* best-effort */ }
-        return 'processed';
-    }
-    const unexpectedError = `Loop ended in unexpected state: ${finalCtx.terminalStatus}/${finalCtx.currentPhase}`;
-    const currentRunForUnexpected = runManager.getById(runId);
-    const currentRetriesUnexpected = currentRunForUnexpected?.retryCount ?? 0;
-    runManager.update(runId, { status: 'error', iterationCount: finalCtx.iteration, lastError: unexpectedError, endedAt: nowUtcIso() });
-    const latestIssue = await forge.getIssue(issueRepo, issueNumber);
-    if (currentRetriesUnexpected < maxAutoRetries) {
-        runManager.incrementRetryCount(runId);
-        await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'queued', buildLabelConfig(repoConfig, latestIssue.labels));
-        logger.info({ repo, issueNumber, attempt: currentRetriesUnexpected + 1, maxAutoRetries }, 'Unexpected state — auto-retrying');
-        await postErrorStatusComment({
-            forge,
-            issueRepo,
-            issueNumber,
-            botUser,
-            error: `Loop entered unexpected state: ${finalCtx.terminalStatus}/${finalCtx.currentPhase}`,
-            retryCount: currentRetriesUnexpected + 1,
-            maxRetries: maxAutoRetries,
-            nextStep: 'Automatic retry queued. night-orch will retry this issue on the next poll cycle.',
-            warnMessage: 'Failed to post unexpected-state auto-retry status comment',
-        });
-    }
-    else {
-        await transitionLabels(forge, issueRepo, issueNumber, latestIssue.labels, 'running', 'error', buildLabelConfig(repoConfig, latestIssue.labels));
-        const attemptCount = currentRetriesUnexpected + 1;
-        await postErrorStatusComment({
-            forge,
-            issueRepo,
-            issueNumber,
-            botUser,
-            error: `Failed after ${attemptCount} attempts. Last error: ${unexpectedError}`,
-            retryCount: attemptCount,
-            maxRetries: maxAutoRetries,
-            nextStep: 'Manual action required: inspect the failure, then run /orch retry or /orch continue.',
-            warnMessage: 'Failed to post unexpected-state retry-exhausted status comment',
-        });
-    }
-    try {
-        metrics?.incRunsTotal('error');
-        metrics?.observeRunDuration(runDurationSec);
-    }
-    catch { /* best-effort */ }
-    return 'error';
-}
-function coerceAgentName(value, fallback) {
-    if (value === 'claude' || value === 'codex' || value === 'opencode') {
-        return value;
-    }
-    return fallback;
-}
-function isImmediateFollowupStatus(status) {
-    return status === 'review_ready'
-        || status === 'blocked'
-        || status === 'error'
-        || status === 'completed';
-}
-function applyWorkflowAgentOverrides(repoConfig, workflow) {
-    if (!workflow.agents || Object.keys(workflow.agents).length === 0) {
-        return repoConfig;
-    }
-    return {
-        ...repoConfig,
-        agents: {
-            ...repoConfig.agents,
-            ...workflow.agents,
-        },
-    };
-}
-function applyWorkflowRoleDefaults(repoDefaults, workflow, repoConfig, config) {
-    if (!workflow.roles) {
-        return repoDefaults;
-    }
-    const merged = {
-        ...repoDefaults,
-        ...workflow.roles,
-    };
-    for (const role of ['planner', 'coder', 'reviewer']) {
-        const preferredAgent = merged[role];
-        if (canResolveAgent(preferredAgent, repoConfig, config))
-            continue;
-        merged[role] = repoDefaults[role];
-    }
-    return merged;
-}
-function canResolveAgent(agent, repoConfig, config) {
-    return resolveWorkerProfileForAgent(agent, repoConfig, config) !== null;
-}
-function resolveWorkerProfileForAgent(agent, repoConfig, config) {
-    const mappedProfileName = repoConfig.agents[agent];
-    if (mappedProfileName) {
-        const mappedProfile = config.workerProfiles[mappedProfileName];
-        if (mappedProfile)
-            return mappedProfile;
-    }
-    return Object.values(config.workerProfiles).find((profile) => profile.type === agent) ?? null;
-}
-function buildBlockReason(ctx) {
-    const blockMessage = ctx.stepOutputs?.['blockMessage'];
-    if (typeof blockMessage === 'string' && blockMessage.trim().length > 0) {
-        return blockMessage;
-    }
-    if (ctx.reviewResult) {
-        const findings = ctx.reviewResult.findings
-            .filter((f) => f.severity === 'critical' || f.severity === 'major')
-            .map((f) => `[${f.severity}] ${f.message}`)
-            .join('; ');
-        return findings
-            ? `${ctx.reviewResult.summary} — ${findings}`
-            : ctx.reviewResult.summary;
-    }
-    if (ctx.blockReason) {
-        return blockReasonSummary(ctx.blockReason, ctx);
-    }
-    return `Blocked in phase ${ctx.currentPhase} (no review result available)`;
-}
-function blockReasonSummary(reason, ctx) {
-    switch (reason) {
-        case 'cost_limit':
-            // The engine writes a precise, limit-specific message into stepOutputs.blockMessage
-            // (see src/loop/engine.ts cost check). This branch is only reached when that
-            // structured message is missing — keep it vague so we do not claim the per-run
-            // limit tripped when it might have been the daily cap.
-            return `Cost limit exceeded for this run (estimated run cost: $${ctx.estimatedCostUsd.toFixed(4)})`;
-        case 'iteration_limit':
-            return `Maximum review iterations reached (${ctx.iteration}/${ctx.adjustedLimits.maxReviewIterations})`;
-        case 'agent_pass_limit':
-            return `Maximum total agent passes reached (${ctx.totalAgentPasses}/${ctx.adjustedLimits.maxTotalAgentPasses})`;
-        case 'reviewer_blocked':
-            return 'Reviewer marked this run as blocked';
-        case 'ambiguous_review':
-            return 'Review output was not parseable and blockOnAmbiguousReview is enabled';
-        case 'verify_config':
-            return 'Verification is required but verify commands or results are unavailable';
-        case 'merge_conflict':
-            return 'Merge conflict encountered while applying updates';
-        case 'auth_failure':
-            return 'Worker CLI authentication expired — re-authenticate and retry';
-        default:
-            return `Blocked in phase ${ctx.currentPhase}`;
-    }
-}
-function formatBlockComment(reason, ctx) {
-    const parts = [`⛔ **night-orch**: Run blocked.\n\n**Reason:** ${reason}`];
-    if (ctx.reviewResult?.findings && ctx.reviewResult.findings.length > 0) {
-        parts.push('\n**Findings:**');
-        for (const f of ctx.reviewResult.findings) {
-            const fix = f.suggestedFix ? ` → ${f.suggestedFix}` : '';
-            parts.push(`- **${f.severity}**: ${f.message}${fix}`);
-        }
-    }
-    parts.push(`\n*Iteration ${ctx.iteration}, cost: $${ctx.estimatedCostUsd.toFixed(4)}*`);
-    return parts.join('\n');
-}
-function makePayload(event, repo, issue, extra = {}) {
-    return {
-        event,
-        repo,
-        issueNumber: issue.number,
-        issueTitle: issue.title,
-        issueUrl: issue.url ?? null,
-        state: event,
-        prUrl: null,
-        prNumber: null,
-        summary: `${event}: #${issue.number} ${issue.title}`,
-        blockingReason: null,
-        reviewSummary: null,
-        iterationCount: 0,
-        timestamp: nowUtcIso(),
-        ...extra,
-    };
-}
-async function postStatusComment(params) {
-    const { forge, issueRepo, issueNumber, botUser, body, warnMessage, } = params;
-    try {
-        if (botUser) {
-            await upsertBotComment(forge, issueRepo, issueNumber, STATUS_MARKER, body, botUser);
-        }
-        else {
-            await forge.commentOnIssue(issueRepo, issueNumber, body);
-        }
-    }
-    catch (commentErr) {
-        logger.warn({ repo: issueRepo, issueNumber, err: commentErr }, warnMessage);
-    }
-}
-const ERROR_COMMENT_MAX_LENGTH = 400;
-const TOKEN_REDACTION_PATTERNS = [
-    /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g,
-    /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
-    /\bsk-[A-Za-z0-9]{20,}\b/g,
-    /\bAKIA[0-9A-Z]{16}\b/g,
-    /\bASIA[0-9A-Z]{16}\b/g,
-    /\bAIza[0-9A-Za-z\-_]{20,}\b/g,
-    /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g,
-];
-async function postErrorStatusComment(params) {
-    const { forge, issueRepo, issueNumber, botUser, error, retryCount, maxRetries, nextStep, warnMessage, } = params;
-    const sanitizedError = sanitizeErrorForComment(error);
-    const body = formatStatusComment({
-        error: sanitizedError,
-        retryCount,
-        maxRetries,
-        nextStep,
-    });
-    await postStatusComment({
-        forge,
-        issueRepo,
-        issueNumber,
-        botUser,
-        body,
-        warnMessage,
-    });
-}
-function toErrorMessage(err) {
-    if (err instanceof Error && typeof err.message === 'string' && err.message.trim().length > 0) {
-        return err.message;
-    }
-    return String(err);
-}
-function sanitizeErrorForComment(errorMessage) {
-    let sanitized = errorMessage
-        .replace(/[\r\n]+/g, ' ');
-    sanitized = stripControlChars(sanitized);
-    sanitized = sanitized
-        .replace(/\b(token|secret|password|passwd|api[_-]?key)\s*[:=]\s*([^\s,;]+)/gi, '$1=[REDACTED]')
-        .trim();
-    for (const pattern of TOKEN_REDACTION_PATTERNS) {
-        sanitized = sanitized.replace(pattern, '[REDACTED]');
-    }
-    sanitized = sanitized.replace(/\s+/g, ' ').trim();
-    if (!sanitized)
-        return 'unknown error';
-    const clipped = sanitized.length > ERROR_COMMENT_MAX_LENGTH
-        ? `${sanitized.slice(0, ERROR_COMMENT_MAX_LENGTH - 1)}…`
-        : sanitized;
-    return escapeMarkdownForComment(clipped);
-}
-function escapeMarkdownForComment(value) {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/([`*_#[\]])/g, '\\$1')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/@/g, '@\u200B');
-}
-function stripControlChars(value) {
-    let out = '';
-    for (const ch of value) {
-        const code = ch.charCodeAt(0);
-        if ((code >= 0 && code <= 31) || code === 127) {
-            out += ' ';
-            continue;
-        }
-        out += ch;
-    }
-    return out;
-}
-/** Issues that returned 404 during comment scan in this process lifecycle.
- *  Bounded: entries are evicted when the key's run reaches a terminal state
- *  via {@link cleanupRunCaches}. */
-const missingCommentCommandIssues = new Set();
-function getHttpStatus(err) {
-    if (typeof err !== 'object' || err === null)
-        return null;
-    const e = err;
-    if (typeof e.status === 'number')
-        return e.status;
-    if (typeof e.response?.status === 'number')
-        return e.response.status;
-    return null;
-}
-async function processCommentCommands(params) {
-    const { config, db, forge, runManager, leaseManager, repoConfig, botUser, } = params;
-    const commandSettings = config.commentCommands ?? { enabled: true, requireCollaborator: false };
-    if (!commandSettings.enabled)
-        return;
-    // Warn once per poll when comment commands accept non-collaborators —
-    // for public repos this means any GitHub user can trigger retry/rebase/
-    // continue/delete operations.
-    if (!commandSettings.requireCollaborator) {
-        logger.warn({ repo: repoConfig.repo }, 'commentCommands.requireCollaborator=false — /orch commands accept any commenter. Enable on public repos.');
-    }
-    const activeRuns = runManager
-        .getActive()
-        .filter((run) => run.repo === repoConfig.repo);
-    const issueRows = [...new Map(activeRuns.map((run) => {
-            const issueRepo = resolveIssueRepo(run.phaseData, repoConfig.repo);
-            return [`${issueRepo}#${run.issueNumber}`, { issue_number: run.issueNumber, issue_repo: issueRepo }];
-        })).values()]
-        .sort((a, b) => a.issue_repo.localeCompare(b.issue_repo) || a.issue_number - b.issue_number);
-    if (issueRows.length === 0)
-        return;
-    const collaboratorCache = new Map();
-    for (const row of issueRows) {
-        const issueKey = `${row.issue_repo}#${row.issue_number}`;
-        if (missingCommentCommandIssues.has(issueKey)) {
-            continue;
-        }
-        let comments;
-        try {
-            comments = await forge.listIssueComments(row.issue_repo, row.issue_number);
-        }
-        catch (err) {
-            if (getHttpStatus(err) === 404) {
-                missingCommentCommandIssues.add(issueKey);
-                logger.debug({ repo: row.issue_repo, issueNumber: row.issue_number }, 'Skipping comment command scan for missing or inaccessible issue');
-                continue;
-            }
-            throw err;
-        }
-        const parsed = parseOrchCommands(comments, '1970-01-01T00:00:00Z');
-        for (const item of parsed) {
-            if (isCommandProcessed(db, row.issue_repo, row.issue_number, item.commentId))
-                continue;
-            // Track whether the command reached a terminal outcome — applied,
-            // denied (policy decision), or rejected (validated failure). Only
-            // terminal outcomes mark the command as processed; transient
-            // failures must remain retriable on the next poll cycle.
-            let commandStatus = null;
-            try {
-                const allowed = await canExecuteCommentCommand({
-                    forge,
-                    repo: row.issue_repo,
-                    user: item.user,
-                    requireCollaborator: commandSettings.requireCollaborator,
-                    cache: collaboratorCache,
-                });
-                if (!allowed) {
-                    commandStatus = 'denied';
-                    logger.info({ repo: repoConfig.repo, issueNumber: row.issue_number, user: item.user, commentId: item.commentId }, 'Ignoring comment command from non-collaborator');
-                    continue;
-                }
-                const result = await executeCommentCommand({
-                    command: item.command,
-                    db,
-                    forge,
-                    runManager,
-                    leaseManager,
-                    repoConfig,
-                    issueRepo: row.issue_repo,
-                    issueNumber: row.issue_number,
-                    botUser,
-                    user: item.user,
-                });
-                if (!result.ok) {
-                    commandStatus = 'rejected';
-                    logger.info({ repo: repoConfig.repo, issueNumber: row.issue_number, command: item.command.type, reason: result.reason }, 'Comment command rejected');
-                }
-                else {
-                    commandStatus = 'applied';
-                    logger.info({ repo: repoConfig.repo, issueNumber: row.issue_number, command: item.command.type, user: item.user }, 'Comment command applied');
-                }
-            }
-            catch (err) {
-                // Transient failure: leave commandStatus=null so the command
-                // remains unprocessed and will be retried on the next poll.
-                logger.warn({ repo: repoConfig.repo, issueNumber: row.issue_number, commentId: item.commentId, command: item.command.type, err }, 'Comment command failed (transient — will retry)');
-            }
-            finally {
-                if (commandStatus !== null) {
-                    markCommandProcessed(db, row.issue_repo, row.issue_number, item.commentId, `${item.command.type}:${commandStatus}`);
-                }
-            }
-        }
-    }
-}
-async function canExecuteCommentCommand(params) {
-    const { forge, repo, user, requireCollaborator, cache } = params;
-    if (!requireCollaborator)
-        return true;
-    if (!user)
-        return false;
-    // Cache key must include the repo — a user might be a collaborator on
-    // one linked project but not another, and reusing a single-user cache
-    // across repos in the same scan would erroneously grant or deny access.
-    const cacheKey = `${repo}\n${user}`;
-    const cached = cache.get(cacheKey);
-    if (cached !== undefined)
-        return cached;
-    if (!forge.isCollaborator) {
-        logger.warn({ repo, user }, 'requireCollaborator=true but forge adapter has no isCollaborator() implementation');
-        cache.set(cacheKey, false);
-        return false;
-    }
-    try {
-        const allowed = await forge.isCollaborator(repo, user);
-        cache.set(cacheKey, allowed);
-        return allowed;
-    }
-    catch (err) {
-        logger.warn({ repo, user, err }, 'Failed collaborator check for comment command user');
-        cache.set(cacheKey, false);
-        return false;
-    }
-}
-async function executeCommentCommand(params) {
-    const { command, db, forge, runManager, leaseManager, repoConfig, issueRepo, issueNumber, botUser, user, } = params;
-    switch (command.type) {
-        case 'retry':
-            return queueRetryFromComment({
-                runManager,
-                leaseManager,
-                forge,
-                repoConfig,
-                issueRepo,
-                issueNumber,
-                resetPlan: command.resetPlan,
-            });
-        case 'continue':
-            {
-                const result = await queueContinue(db, forge, repoConfig, issueNumber, botUser, { issueRepo });
-                return result.queued ? { ok: true } : { ok: false, reason: result.reason };
-            }
-        case 'rebase': {
-            // queueRebase currently always verifies after rebase; keep behavior stable.
-            const result = await queueRebase(db, forge, repoConfig, issueNumber, botUser);
-            return result.queued ? { ok: true } : { ok: false, reason: result.reason };
-        }
-        case 'cancel':
-            return cancelRunFromComment({
-                runManager,
-                leaseManager,
-                forge,
-                repoConfig,
-                issueRepo,
-                issueNumber,
-                user,
-            });
-        default: {
-            const exhaustive = command;
-            return { ok: false, reason: `Unsupported command: ${String(exhaustive)}` };
-        }
-    }
-}
-async function queueRetryFromComment(params) {
-    const { runManager, leaseManager, forge, repoConfig, issueRepo, issueNumber, resetPlan } = params;
-    const run = runManager.getByRepoAndIssue(repoConfig.repo, issueNumber);
-    if (!run)
-        return { ok: false, reason: 'No run found for issue' };
-    if (run.status === 'running')
-        return { ok: false, reason: 'Run is currently running' };
-    if (!['blocked', 'error', 'review_ready'].includes(run.status)) {
-        return { ok: false, reason: `Retry not allowed from status ${run.status}` };
-    }
-    runManager.update(run.id, {
-        status: 'queued',
-        currentPhase: null,
-        endedAt: null,
-        lastError: null,
-        phaseData: resetPlan ? null : run.phaseData,
-        blockReason: null,
-    });
-    leaseManager.release(issueRepo, issueNumber);
-    if (issueRepo !== repoConfig.repo) {
-        leaseManager.release(repoConfig.repo, issueNumber);
-    }
-    const issue = await forge.getIssue(issueRepo, issueNumber);
-    await transitionLabels(forge, issueRepo, issueNumber, issue.labels, run.status, 'queued', buildLabelConfig(repoConfig, issue.labels));
-    return { ok: true };
-}
-async function cancelRunFromComment(params) {
-    const { runManager, leaseManager, forge, repoConfig, issueRepo, issueNumber, user } = params;
-    const run = runManager.getByRepoAndIssue(repoConfig.repo, issueNumber);
-    if (!run)
-        return { ok: false, reason: 'No run found for issue' };
-    if (run.status !== 'running' && run.status !== 'queued') {
-        return { ok: false, reason: `Cancel only supports running/queued runs (current: ${run.status})` };
-    }
-    runManager.update(run.id, {
-        status: 'blocked',
-        endedAt: nowUtcIso(),
-        lastError: `Cancelled by @${user} via comment command`,
-        blockReason: null,
-    });
-    leaseManager.release(issueRepo, issueNumber);
-    if (issueRepo !== repoConfig.repo) {
-        leaseManager.release(repoConfig.repo, issueNumber);
-    }
-    const issue = await forge.getIssue(issueRepo, issueNumber);
-    await transitionLabels(forge, issueRepo, issueNumber, issue.labels, run.status, 'blocked', buildLabelConfig(repoConfig, issue.labels));
-    return { ok: true };
-}
-/**
- * Block reasons that indicate the coder's work is broken and the branch
- * should be hard-reset to base on the next attempt. Salvageable states
- * (reviewer_blocked, iteration_limit, ambiguous_review, verify_config)
- * preserve the branch so existing work can be continued.
- */
-const TAINTED_BLOCK_REASONS = new Set(['agent_pass_limit', 'cost_limit', 'merge_conflict', 'auth_failure']);
-// --- Reaction scanning ---
-/** In-memory reaction cursors, keyed by "repo#issueNumber".
- *  Bounded: entries are evicted via {@link cleanupRunCaches}. */
-const reactionCursors = new Map();
-/**
- * Evict entries from process-global caches that are keyed by repo+issue.
- * Called when a run reaches a terminal state so the caches don't grow
- * unbounded over the daemon's lifetime.
- */
-function cleanupRunCaches(repo, issueNumber) {
-    const key = `${repo}#${issueNumber}`;
-    missingCommentCommandIssues.delete(key);
-    reactionCursors.delete(key);
-}
-async function scanAndHandleReactions(params) {
-    const { db, forge, runManager, repoConfig, botUser } = params;
-    // Find review_ready issues with PRs for this repo.
-    const rows = runManager
-        .getActive()
-        .filter((run) => run.repo === repoConfig.repo && run.status === 'review_ready' && run.prNumber !== null)
-        .map((run) => ({
-        id: run.id,
-        repo: run.repo,
-        issue_number: run.issueNumber,
-        pr_number: run.prNumber,
-    }));
-    for (const row of rows) {
-        const cursorKey = `${row.repo}#${row.issue_number}`;
-        const cursor = reactionCursors.get(cursorKey);
-        const result = await scanForReactions(forge, row.repo, row.pr_number, row.issue_number, botUser, cursor);
-        // Update cursor regardless of reactions
-        reactionCursors.set(cursorKey, result.cursor);
-        // Handle each reaction
-        for (const reaction of result.reactions) {
-            try {
-                await handleReaction(reaction, { db, forge, runManager, repoConfig });
-            }
-            catch (err) {
-                logger.warn({ repo: row.repo, issueNumber: row.issue_number, reactionType: reaction.type, err }, 'Failed to handle reaction');
-            }
-        }
-    }
-}
-function extractFollowupPromptFeedback(phaseData) {
-    if (!phaseData)
-        return null;
-    const context = phaseData['reactionContext'];
-    if (typeof context !== 'string' || context.trim().length === 0)
-        return null;
-    const type = typeof phaseData['reactionType'] === 'string' && phaseData['reactionType'].trim().length > 0
-        ? phaseData['reactionType']
-        : 'continue';
-    const summary = typeof phaseData['reactionSummary'] === 'string' && phaseData['reactionSummary'].trim().length > 0
-        ? phaseData['reactionSummary']
-        : 'Follow-up context available';
-    return { type, summary, context };
-}
-/**
- * Prioritize follow-up work over fresh issues so reactive runs (especially
- * merge conflict rebases) are handled promptly and don't starve behind newer
- * ready issues.
- */
-function prioritizeDiscoveredIssues(runManager, repo, discovered) {
-    const ranked = discovered.map((item) => ({
-        item,
-        rank: getIssueQueuePriority(runManager, repo, item.issue.number),
-    }));
-    ranked.sort((a, b) => a.rank - b.rank);
-    return ranked.map((entry) => entry.item);
-}
-function getIssueQueuePriority(runManager, repo, issueNumber) {
-    const queuedRun = runManager.getLatestQueuedByIssue(repo, issueNumber);
-    if (!queuedRun)
-        return 3;
-    const reactionType = queuedRun.phaseData?.reactionType;
-    if (reactionType === 'merge_conflict' || reactionType === 'rebase')
-        return 0;
-    if (typeof reactionType === 'string' && reactionType.length > 0)
-        return 1;
-    return 2;
-}
-function selectReplayableRun(run) {
-    if (!run)
-        return null;
-    if (run.status === 'blocked' || run.status === 'review_ready' || run.status === 'error') {
-        return run;
-    }
-    return null;
-}
-function shouldResetBranch(runManager, repo, issueNumber, currentRunId) {
-    const prior = runManager.getLatestFinishedByIssue(repo, issueNumber, currentRunId);
-    if (!prior)
-        return false;
-    // Infrastructure errors — work is unreliable
-    if (prior.status === 'error')
-        return true;
-    // Blocked with tainted block reason — coder couldn't produce working code
-    if (prior.status === 'blocked' && prior.blockReason && TAINTED_BLOCK_REASONS.has(prior.blockReason))
-        return true;
-    return false;
-}
 //# sourceMappingURL=poller.js.map