@cat-factory/orchestration 0.70.1 → 0.71.0

package/dist/modules/execution/RunDispatcher.js

@@ -1,12 +1,14 @@
 import { ConflictError, DEFAULT_MERGE_PRESET, getErrorMessage, getProvider, INITIATIVE_ANALYST_AGENT_KIND, INITIATIVE_COMMITTER_AGENT_KIND, INITIATIVE_INTERVIEWER_AGENT_KIND, INITIATIVE_PLANNER_AGENT_KIND, isAsyncAgentExecutor, NotFoundError, parseLocalModelId, recordGateAttempt, registeredGateFactories, registeredStepResolverFactories, requireProvider, sameSubtasks, } from '@cat-factory/kernel';
 import { frontendOriginsForService, parseBlueprintService, parseSpecDoc, } from '@cat-factory/contracts';
-import { blueprintPostOp, commitInitiativeTracker, isCompanionKind, isContainerBackedCompanion, moduleSlug, registeredAgentStep, registeredPostOps, registeredPreOps, runRepoOps, specPostOp, TASK_ESTIMATOR_AGENT_KIND, } from '@cat-factory/agents';
+import { blueprintPostOp, commitInitiativeTracker, isCompanionKind, isContainerBackedCompanion, moduleSlug, runRepoOps, specPostOp, TASK_ESTIMATOR_AGENT_KIND, } from '@cat-factory/agents';
 import { DEPLOYER_AGENT_KIND, isDeployStep } from '@cat-factory/integrations';
+import { BUG_INTAKE_AGENT_KIND } from '../pipelines/pipelineShape.js';
 import { coerceTaskEstimate, summarizeEstimate } from '../estimation/estimate.logic.js';
 import { reviewableArtifactOutput } from './artifact-review.logic.js';
 import { deployEvictionEpoch, deployJobId, orderProvisionTargets } from './deployer.logic.js';
+import { renderInvestigationDigest } from './bugInvestigation.logic.js';
 import { frameOf, validInvolvedServiceFrames } from './frame.logic.js';
-import { ANALYSIS_AGENT_KIND, ARCHITECTURE_BRAINSTORM_AGENT_KIND, BLUEPRINTS_AGENT_KIND, CLARITY_REVIEW_AGENT_KIND, CONFLICTS_AGENT_KIND, HUMAN_TEST_AGENT_KIND, isTesterKind, MERGER_AGENT_KIND, REQUIREMENTS_BRAINSTORM_AGENT_KIND, REQUIREMENTS_REVIEW_AGENT_KIND, SPEC_WRITER_AGENT_KIND, TESTER_AGENT_KIND, TRACKER_AGENT_KIND, UI_TESTER_AGENT_KIND, VISUAL_CONFIRM_AGENT_KIND, } from './ci.logic.js';
+import { ANALYSIS_AGENT_KIND, ARCHITECTURE_BRAINSTORM_AGENT_KIND, BLUEPRINTS_AGENT_KIND, BUG_INVESTIGATOR_AGENT_KIND, CLARITY_REVIEW_AGENT_KIND, CONFLICTS_AGENT_KIND, HUMAN_TEST_AGENT_KIND, isTesterKind, MERGER_AGENT_KIND, REQUIREMENTS_BRAINSTORM_AGENT_KIND, REQUIREMENTS_REVIEW_AGENT_KIND, SPEC_WRITER_AGENT_KIND, TESTER_AGENT_KIND, TRACKER_AGENT_KIND, UI_TESTER_AGENT_KIND, VISUAL_CONFIRM_AGENT_KIND, } from './ci.logic.js';
 import { followUpsToSendBack, hasPendingFollowUps, renderFollowUpRework, shouldLoopCoder, } from './followUp.logic.js';
 import { agentFailureKindFromCause, classifyAgentFailure, isContainerEvictionError, isTransientEviction, MAX_EVICTION_RECOVERIES, MAX_TRANSIENT_EVICTION_RECOVERIES, } from './job.logic.js';
 import { AgentContextBuilder } from './AgentContextBuilder.js';
@@ -97,6 +99,7 @@ export class RunDispatcher {
     blockRepository;
     executionRepository;
     agentExecutor;
+    agentKindRegistry;
     workRunner;
     events;
     idGenerator;
@@ -120,6 +123,7 @@ export class RunDispatcher {
     environmentProvisioning;
     ticketTrackerProvider;
     issueWriteback;
+    bugIntakeService;
     notificationService;
     blueprintReconciler;
     initiativeService;
@@ -139,6 +143,7 @@ export class RunDispatcher {
         this.blockRepository = deps.blockRepository;
         this.executionRepository = deps.executionRepository;
         this.agentExecutor = deps.agentExecutor;
+        this.agentKindRegistry = deps.agentKindRegistry;
         this.workRunner = deps.workRunner;
         this.events = deps.events;
         this.idGenerator = deps.idGenerator;
@@ -162,6 +167,7 @@ export class RunDispatcher {
         this.environmentProvisioning = deps.environmentProvisioning;
         this.ticketTrackerProvider = deps.ticketTrackerProvider;
         this.issueWriteback = deps.issueWriteback;
+        this.bugIntakeService = deps.bugIntakeService;
         this.notificationService = deps.notificationService;
         this.blueprintReconciler = deps.blueprintReconciler;
         this.initiativeService = deps.initiativeService;
@@ -902,23 +908,28 @@ export class RunDispatcher {
         step.rework = undefined;
         // A repo-operating step (the container "implementer" agent) opened a PR for
         // its work. Record it on the block so the board can surface and link to it,
-        // regardless of whether this is the final step.
-        if (result.pullRequest) {
+        // regardless of whether this is the final step. A multi-repo run
+        // (service-connections phase 3) additionally reports the PRs it opened in the
+        // connected involved-service repos; record them beside the own-service PR (they may
+        // even arrive when the own service was a no-op and only a peer changed).
+        if (result.pullRequest || result.peerPullRequests?.length) {
             // Read the block before the update so we can tell whether this PR is newly
             // opened (vs. the same PR re-reported by a re-run/retry of the coder step).
             const priorBlock = this.issueWriteback
                 ? await this.blockRepository.get(workspaceId, instance.blockId)
                 : null;
             await this.blockRepository.update(workspaceId, instance.blockId, {
-                pullRequest: result.pullRequest,
+                ...(result.pullRequest ? { pullRequest: result.pullRequest } : {}),
+                ...(result.peerPullRequests?.length ? { peerPullRequests: result.peerPullRequests } : {}),
             });
             // Best-effort writeback: comment on the task's linked tracker issue(s) that a
-            // PR opened. Only when the PR is newly recorded — a retry that re-reports the
-            // same PR must not re-comment (the tracker comment is not idempotent). Gated
-            // inside the provider by the workspace setting + per-task override;
-            // fire-and-forget so a tracker outage never fails the run.
+            // PR opened. Only for the OWN-service PR, and only when it is newly recorded — a
+            // retry that re-reports the same PR must not re-comment (the tracker comment is not
+            // idempotent). Gated inside the provider by the workspace setting + per-task
+            // override; fire-and-forget so a tracker outage never fails the run.
             if (this.issueWriteback &&
                 priorBlock &&
+                result.pullRequest &&
                 priorBlock.pullRequest?.url !== result.pullRequest.url) {
                 await this.issueWriteback
                     .onPullRequestOpened(workspaceId, priorBlock, result.pullRequest)
@@ -1548,6 +1559,89 @@ export class RunDispatcher {
             return { output: `Could not file a tracking ticket: ${getErrorMessage(error)}` };
         }
     }
+    /**
+     * Run a `bug-intake` step — the recurring bug-triage pipeline's inbound dual of `tracker`
+     * (design §3). Pull ONE matching open issue from the schedule's configured tracker board,
+     * claim it (import + replace-link onto the reused block, mark it in-progress + comment), and
+     * seed the block's title/description from it so every downstream step works THAT bug. When
+     * nothing matches — or no task source is wired — the run completes SUCCESSFULLY with every
+     * remaining step skipped (there is nothing to investigate / reproduce / fix), no notification.
+     * Best-effort throughout: the intake helper never throws (a tracker outage resolves to a
+     * no-op), and the pickup writeback is fire-and-forget.
+     */
+    async runBugIntake(workspaceId, instance, step, block, isFinalStep) {
+        const outcome = this.bugIntakeService
+            ? await this.bugIntakeService.pickForBlock(workspaceId, block.id)
+            : { picked: null, summary: 'Issue intake is not configured on this deployment.' };
+        if (!outcome.picked) {
+            return this.completeRunSkippingRemaining(workspaceId, instance, step, outcome.summary);
+        }
+        const pickup = outcome.picked;
+        // Seed the reused recurring block from the picked issue so each fire works a different bug
+        // through the same block (the same block-seeding `createTaskFromIssue` does, applied in place).
+        // Clear the previous fire's peer PRs too — this fire works a DIFFERENT bug, so a prior bug's
+        // connected-repo PRs must not linger on the block. (The own-service `pullRequest` is overwritten
+        // by this run's coder step before any step reads it; it is a non-nullable `BlockPatch` field, so
+        // it cannot be cleared here anyway.)
+        await this.blockRepository.update(workspaceId, block.id, {
+            title: pickup.seedTitle,
+            description: pickup.seedDescription,
+            peerPullRequests: [],
+        });
+        // Best-effort: claim the issue where it was filed (in-progress mark + "taken by cat-factory"
+        // comment). Fire-and-forget — a tracker hiccup must never fail the run, mirroring the PR
+        // open/merge writeback hooks; and unlike them this is NOT gated on the writeback settings.
+        if (this.issueWriteback) {
+            await this.issueWriteback
+                .onIssuePickedUp(workspaceId, block.id, pickup.inProgressLabel ? { inProgressLabel: pickup.inProgressLabel } : {})
+                .catch(() => { });
+        }
+        return this.recordStepResult(workspaceId, instance, step, isFinalStep, {
+            output: pickup.summary,
+        });
+    }
+    /**
+     * Complete the run successfully after a `bug-intake` step found no issue to work: record the
+     * intake step's own no-match output (it SUCCEEDED — it made the decision), then mark every
+     * REMAINING step `skipped` and finalize the reused block `done`, with NO notification (the
+     * outcome is visible in the schedule's run history).
+     *
+     * The block is finalized `done` DIRECTLY here rather than through `RunStateMachine.finalizeBlock`:
+     * for a mergerless task block (every bug-triage pipeline) finalizeBlock's terminal branch treats
+     * the run as "work complete but unmerged" — it flips the block `pr_ready` and raises a
+     * `pipeline_complete` "confirm + merge the PR" notification. This fire did NO work and opened NO
+     * PR, so that card would be spurious (and its payload would reference a STALE PR carried over from
+     * a prior fire). Setting the terminal status inline keeps the no-op silent, as documented.
+     */
+    async completeRunSkippingRemaining(workspaceId, instance, step, summary) {
+        step.output = summary;
+        step.progress = 1;
+        step.subtasks = undefined;
+        this.stepGraph.finishStep(step);
+        for (let i = instance.currentStep + 1; i < instance.steps.length; i++) {
+            const remaining = instance.steps[i];
+            if (!remaining)
+                continue;
+            remaining.skipped = true;
+            remaining.output = '';
+            remaining.progress = 1;
+            remaining.subtasks = undefined;
+            this.stepGraph.finishStep(remaining);
+        }
+        instance.currentStep = instance.steps.length - 1;
+        instance.status = 'done';
+        const block = await this.blockRepository.get(workspaceId, instance.blockId);
+        if (block && block.status !== 'done') {
+            await this.blockRepository.update(workspaceId, instance.blockId, {
+                status: 'done',
+                progress: 1,
+            });
+        }
+        await this.executionRepository.upsert(workspaceId, instance);
+        await this.runStateMachine.emitInstance(workspaceId, instance);
+        await this.runStateMachine.stopRunContainer(workspaceId, instance);
+        return { kind: 'done' };
+    }
     /**
      * Persist an APPROVED initiative plan for an `initiative-committer` step: flip the
      * entity to `executing` and mirror the tracker into the repo's default branch
@@ -1686,13 +1780,13 @@ export class RunDispatcher {
      * unchanged without the feature. A throwing op propagates to fail the step.
      */
     async runRegisteredPreOps(workspaceId, block, step, context) {
-        const ops = registeredPreOps(step.agentKind);
+        const ops = this.agentKindRegistry.preOps(step.agentKind);
         if (ops.length === 0)
             return;
         const runRepo = await this.resolveRunRepo(workspaceId, block.id);
         if (!runRepo)
             return;
-        const branch = await this.resolveRepoOpBranch(registeredAgentStep(step.agentKind), block, runRepo);
+        const branch = await this.resolveRepoOpBranch(this.agentKindRegistry.agentStep(step.agentKind), block, runRepo);
         await runRepoOps(ops, { repo: runRepo.repo, context, branch });
     }
     /**
@@ -1717,7 +1811,7 @@ export class RunDispatcher {
      * {@link runRegisteredPreOps}; the agent's {@link AgentRunResult} is threaded through.
      */
     async runRegisteredPostOps(workspaceId, instance, step, isFinalStep, result) {
-        const registered = registeredPostOps(step.agentKind);
+        const registered = this.agentKindRegistry.postOps(step.agentKind);
         const builtIn = this.builtInPostOps(step.agentKind);
         if (registered.length === 0 && builtIn.length === 0)
             return;
@@ -1730,7 +1824,7 @@ export class RunDispatcher {
         const context = await this.contextBuilder.buildContext(workspaceId, instance, step, isFinalStep, block);
         // Registered (custom) kinds resolve their branch from their declared clone target.
         if (registered.length > 0) {
-            const branch = await this.resolveRepoOpBranch(registeredAgentStep(step.agentKind), block, runRepo);
+            const branch = await this.resolveRepoOpBranch(this.agentKindRegistry.agentStep(step.agentKind), block, runRepo);
             await runRepoOps(registered, { repo: runRepo.repo, context, branch, result });
         }
         // Built-in (migrated) kinds resolve their branch to MATCH their container dispatch
@@ -1837,6 +1931,17 @@ export class RunDispatcher {
                     return this.recordStepResult(workspaceId, instance, step, isFinalStep, result);
                 },
             },
+            // A `bug-intake` step (the recurring bug-triage pipeline) pulls ONE matching open issue from
+            // the schedule's tracker board, claims it, and seeds the reused block from it — no LLM of its
+            // own, the inbound dual of `tracker`. On no match (or no task source wired) it completes the
+            // run successfully, skipping every remaining step. Handled entirely inside
+            // {@link runBugIntake}, so it always claims the step.
+            {
+                kind: BUG_INTAKE_AGENT_KIND,
+                order: 111,
+                canHandle: ({ step }) => step.agentKind === BUG_INTAKE_AGENT_KIND,
+                handle: ({ workspaceId, instance, step, block, isFinalStep }) => this.runBugIntake(workspaceId, instance, step, block, isFinalStep),
+            },
             // The `initiative-interviewer` step interviews the human on goals/constraints — an
             // inline LLM gate that PARKS the planning run on a decision-wait while they answer
             // through the planning window, then synthesizes the brief onto the entity and advances
@@ -2113,6 +2218,22 @@ export class RunDispatcher {
             // whether the single-actor estimator or the consensus ranked-scoring variant produced
             // the JSON. Running at the post-completion slot keeps the summary in `step.output`
             // before the approval gate reads it as the proposal.
+            // A `bug-investigator` step returns its STRUCTURED triage as `result.custom` (kept on
+            // `step.custom` for the generic-structured view + the clarity gate's structured read).
+            // Render a prose digest into `step.output` at the post-completion slot so downstream
+            // steps (estimator / repro-test / coder) read the investigation via `priorOutputs`
+            // (which carries only `step.output`), and the clarity gate's investigation-prose context
+            // sees it too. An unparseable result leaves the agent's raw reply on `step.output`.
+            {
+                kind: BUG_INVESTIGATOR_AGENT_KIND,
+                phase: 'post-completion',
+                applies: (result) => result.custom !== undefined,
+                resolve: async ({ result }) => {
+                    const digest = renderInvestigationDigest(result.custom);
+                    if (digest)
+                        return { output: digest };
+                },
+            },
             {
                 kind: TASK_ESTIMATOR_AGENT_KIND,
                 phase: 'post-completion',
@@ -2224,6 +2345,12 @@ export class RunDispatcher {
         const gateState = step.gate;
         const probe = await this.runInitiatorScope(instance.initiatedBy, () => gate.probe(workspaceId, block.id, gateState));
         step.gate.headSha = probe.headSha;
+        // Multi-repo (service-connections phase 4): the CI / conflicts gates aggregate across every
+        // PR the task opened; persist the per-repo head shas (and, for the conflicts gate, which repo
+        // conflicted) so the run-detail UI can group checks by service and the conflict-resolver can
+        // target the conflicted repo.
+        step.gate.headShas = probe.headShas ?? null;
+        step.gate.conflictTarget = probe.conflictTarget ?? null;
         // Persist the precheck outcome so the run-detail UI can surface why the gate is
         // looping (the failing checks / conflict reason) — detail that was previously fed
         // only to the helper agent and then discarded.
@@ -2244,7 +2371,10 @@ export class RunDispatcher {
             return { kind: 'awaiting_gate', stepIndex: instance.currentStep };
         }
         // probe.status === 'fail'.
-        const canEscalate = isAsyncAgentExecutor(this.agentExecutor);
+        // A gate can decline escalation for a failure its helper can't fix (e.g. the conflicts
+        // gate on a PEER-repo conflict it has no resolver for) — go straight to give-up instead
+        // of burning the attempt budget on a helper that can't touch the problem.
+        const canEscalate = isAsyncAgentExecutor(this.agentExecutor) && probe.escalatable !== false;
         if (canEscalate && step.gate.attempts < step.gate.maxAttempts) {
             return this.dispatchGateHelper(workspaceId, instance, step, block, isFinalStep, gate, probe.failureSummary);
         }