@claudexor/orchestrator 5.0.1 → 5.0.2

package/dist/orchestrator.js

@@ -18,11 +18,11 @@ import { PoolAttemptEvidence, terminalPoolAttempts, withPoolAttempts, } from "./
 import { writeRunTelemetryArtifact } from "./runTelemetryWriter.js";
 import { buildFileBackedSynthesisInput, materializeWinnerOutputs, stageFileBackedContext, writeCandidateAttemptArtifacts, } from "./candidateOutputs.js";
 import { processAttemptUsage } from "./attemptUsage.js";
-import { captureDirectoryCandidate, directoryHasOutput, directoryCandidateStable, observeDirectoryPaths, publishDirectoryCandidate, } from "./directoryCandidate.js";
+import { captureDirectoryCandidate, directoryPreparationNotice, directoryHasOutput, directoryCandidateStable, observeDirectoryPaths, publishDirectoryCandidate, } from "./directoryCandidate.js";
 import { appliedAttemptFacts, assertDelegatedEvidence, isMutatingAccess, outerBoundaryNotice, scopedHarnessHome, selectLaneHome, followSpecHome, } from "./delegatedHome.js";
 import * as AC from "./attemptUsageCost.js";
 import * as custody from "./continuation-custody.js";
-import { candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, } from "./candidateEvidence.js";
+import { candidateCaptureRefusals, candidateCompletion, candidateRoster, candidateStatuses, convergenceOutcomeFacts, isWorkingCandidate, partitionCandidates, toCandidateEvidence, } from "./candidateEvidence.js";
 import { capabilityIntents } from "@claudexor/gateway";
 import { reviewCandidateRuns, unreviewedCandidateEvidence, evaluateUnreviewedConvergence, } from "./candidateReview.js";
 import { join } from "node:path";
@@ -1262,11 +1262,12 @@ export class Orchestrator {
         const inPlaceEnvelope = envelope.worktree_path === envelope.repo_root;
         const directory = envelope.workspace_kind === "directory";
         let directoryCapture = {};
-        const captureDirectory = async () => (directoryCapture = await captureDirectoryCandidate({
+        const captureDirectory = async (final = false) => (directoryCapture = await captureDirectoryCandidate({
             manager: wsm,
             envelope,
             artifactRoot: join(paths.attemptsDir, attemptId),
             observedPaths: [...observedPaths],
+            ...(final ? { holder: { runId: paths.runId, runDir: paths.root } } : {}),
         }));
         const sessionFields = runInput
             ? await this.sessionSpecFields(runInput, adapter.id, knobs.model, log, routed.authRouteEstimate, routed.quotaAdmission)
@@ -1304,6 +1305,7 @@ export class Orchestrator {
             [
                 prompt,
                 outerBoundaryNotice(harnessHome, routed.auxiliaryWritableRoots),
+                await directoryPreparationNotice(envelope, attemptId, log),
                 laneContinuity?.pointerLine,
                 continuationPointer,
             ]
@@ -1632,7 +1634,7 @@ export class Orchestrator {
         const unwrapped = unwrapWorkReportEnvelope(acceptedTryOutput(answer, harnessErrored), workReportMode, { sideToolReport: telemetry.sideToolWorkReport ?? undefined });
         const answerText = unwrapped.deliverable.trim().length > 0 ? unwrapped.deliverable : undefined;
         if (directory)
-            await captureDirectory();
+            await captureDirectory(true);
         const captured = directory
             ? { diff: "", captureRefusal: directoryCapture.refusal }
             : await secretDiff.captureCandidateWorkspace({
@@ -2108,17 +2110,7 @@ export class Orchestrator {
                 }, input, requestedSingleCandidate, // W-C4 deltas: single-candidate chat lane only (racing = noise x N)
                 undefined, undefined, harnessHome, undefined, tried);
                 ledger.settle(slot.lease.lease_id, attemptUsageCostSettlement(run.cost, run.costEstimated, run.attemptId, run.harnessId, run.telemetry.authMode, run.telemetry.usageCost));
-                log.emit("harness.completed", {
-                    harness_id: adapter.id,
-                    attempt_id: slot.attemptId,
-                    // QA-027: never claim `success` over an attempt the operator/deadline
-                    // cut short. An abort makes the run non-successful; the top-level
-                    // status axis must say `cancelled` (the nested outcome axis already
-                    // rides in telemetrySummary), not launder a torn-off stream as clean.
-                    status: input.signal?.aborted ? "cancelled" : run.errored ? "failed" : "success",
-                    cost_usd: run.cost,
-                    ...telemetrySummary(run.telemetry),
-                });
+                log.emit("harness.completed", candidateCompletion(run, input.signal));
                 // D-16d one-shot continuation for an ENVELOPED candidate (parity with the
                 // read-only loop, which had the ONLY continuation wiring). An eligible
                 // terminal context exhaustion (repeated_refill, no completed report) gets
@@ -2187,21 +2179,18 @@ export class Orchestrator {
                                     return true;
                                 }, input, requestedSingleCandidate, undefined, packet.pointerLine ?? undefined, harnessHome, undefined, contTried);
                                 ledger.settle(contLeaseId, attemptUsageCostSettlement(contRun.cost, contRun.costEstimated, contRun.attemptId, contRun.harnessId, contRun.telemetry.authMode, contRun.telemetry.usageCost));
-                                log.emit("harness.completed", {
-                                    harness_id: adapter.id,
-                                    attempt_id: contAttemptId,
-                                    status: input.signal?.aborted
-                                        ? "cancelled"
-                                        : contRun.errored
-                                            ? "failed"
-                                            : "success",
-                                    cost_usd: contRun.cost,
-                                    ...telemetrySummary(contRun.telemetry),
-                                });
+                                log.emit("harness.completed", candidateCompletion(contRun, input.signal));
                                 // Supersede the exhausted candidate ONLY after the continuation
                                 // actually completes cleanly (never over a torn-off/aborted stream).
                                 if (!contRun.errored && !input.signal?.aborted)
                                     effectiveRun = contRun;
+                                // A refused capture is errored: the original keeps leading, and
+                                // the copy they share stays kept under the continuation's receipt.
+                                if (contRun.captureRefusal)
+                                    effectiveRun.continuationRefusal = {
+                                        attemptId: contRun.attemptId,
+                                        refusal: contRun.captureRefusal,
+                                    };
                             }
                             catch (err) {
                                 ledger.settle(contLeaseId, AC.attemptFailureCost(err, "continuation-error", 0).settlement);
@@ -2334,7 +2323,7 @@ export class Orchestrator {
             await disposeReviewEnvelopes();
             return cancelledRaceResult();
         }
-        const failedDelegation = delegateFailure.dominantRaceCandidateFailure(runs);
+        const failedDelegation = delegateFailure.dominantRaceCandidateFailure(runs, input);
         if (failedDelegation) {
             await disposeReviewEnvelopes();
             const failedOutput = {
@@ -2360,7 +2349,7 @@ export class Orchestrator {
                     budgetDenial,
                     ...(mutatingRun ? { liveCapture: failedOutput } : {}),
                 });
-            const failure = delegateFailure.candidateFailureTerminal(failedDelegation, "race");
+            const failure = delegateFailure.candidateFailureTerminal(failedDelegation, "race", runs);
             if (mutatingRun)
                 await delegateFailure.persistFailedCandidateOutput(failedOutput);
             raceTerminal.writeTelemetry();
@@ -2802,7 +2791,7 @@ export class Orchestrator {
                     },
                 });
             }
-            store.writeText(join(paths.finalDir, "summary.md"), withPoolAttempts(renderSummary(runId, mode, { ...result.decision, facts }, evidences, synth.reason, actualReviewVerified, secretDiff.resultSummaryLines(winnerRun)), racePool()));
+            store.writeText(join(paths.finalDir, "summary.md"), withPoolAttempts(renderSummary(runId, mode, { ...result.decision, facts }, evidences, synth.reason, actualReviewVerified, delegateFailure.raceSummaryDisclosure(winnerRun, runs)), racePool()));
             // summary.md is a DIAGNOSTIC artifact only (V8/PLAN addendum 2): it no
             // longer carries primary-output authority. A clean applyable success or a
             // winner answer still marks it ready for legacy INV-116 ordering; any
@@ -2829,12 +2818,15 @@ export class Orchestrator {
         const needsDecisionTerminal = facts.review === "blocked" || facts.checks === "failed";
         const isFailureTerminal = facts.lifecycle !== "succeeded" || needsDecisionTerminal;
         const pool = racePool();
+        // Beside whichever failure record leads, a source another attempt kept stays named.
+        const keptSources = candidateCaptureRefusals(runs).flatMap(secretDiff.captureInspectionActions);
         if (deliveryFailureReason && !finalVerifyFailed) {
             const refused = deliveryRefusalFailure(deliveryFailureReason, paths.root);
             writeFailure(store, paths, {
                 ...refused,
                 safeMessage: withPoolAttempts(refused.safeMessage, pool),
                 poolAttempts: pool,
+                nextActions: [...refused.nextActions, ...keptSources],
             });
         }
         else if (finalVerifyFailed) {
@@ -2848,15 +2840,18 @@ export class Orchestrator {
                     : `final verify failed: ${finalVerify?.reason ?? (finalVerify?.gates_passed === false ? "deterministic gates failed on the fresh verify tree" : "unknown")}`, pool),
                 poolAttempts: pool,
                 runDir: paths.root,
-                nextActions: finalVerify?.applied_cleanly === null
-                    ? [
-                        "Inspect arbitration/decision.yaml (final_verify) for the verifier error",
-                        "Fix the verify infrastructure (git worktree/tmp) and re-run, or accept_risk to override",
-                    ]
-                    : [
-                        "Inspect arbitration/decision.yaml (final_verify)",
-                        "Re-run after fixing the base conflict or the failing gates",
-                    ],
+                nextActions: [
+                    ...(finalVerify?.applied_cleanly === null
+                        ? [
+                            "Inspect arbitration/decision.yaml (final_verify) for the verifier error",
+                            "Fix the verify infrastructure (git worktree/tmp) and re-run, or accept_risk to override",
+                        ]
+                        : [
+                            "Inspect arbitration/decision.yaml (final_verify)",
+                            "Re-run after fixing the base conflict or the failing gates",
+                        ]),
+                    ...keptSources,
+                ],
             });
         }
         else if (isFailureTerminal) {
@@ -2888,19 +2883,22 @@ export class Orchestrator {
                     ? `attempts/${winnerRun.attemptId}/attempt.yaml`
                     : undefined,
                 runDir: paths.root,
-                nextActions: decisionBlock
-                    ? [
-                        "Review the blocking findings on the run's turn",
-                        "Accept the risk to apply this exact patch, or discard the change",
-                        ...(facts.checks === "failed"
-                            ? ["Configure/approve the deterministic test command, then re-run"]
-                            : []),
-                    ]
-                    : [
-                        "Open diagnostics",
-                        "Inspect candidate artifacts",
-                        "Retry with a narrower prompt or different harness pool",
-                    ],
+                nextActions: [
+                    ...(decisionBlock
+                        ? [
+                            "Review the blocking findings on the run's turn",
+                            "Accept the risk to apply this exact patch, or discard the change",
+                            ...(facts.checks === "failed"
+                                ? ["Configure/approve the deterministic test command, then re-run"]
+                                : []),
+                        ]
+                        : [
+                            "Open diagnostics",
+                            "Inspect candidate artifacts",
+                            "Retry with a narrower prompt or different harness pool",
+                        ]),
+                    ...keptSources,
+                ],
             });
             if (!winnerRun) {
                 store.writeText(join(paths.finalDir, "summary.md"), `# Run ${runId} (${mode})\n\n- Lifecycle: ${facts.lifecycle}${facts.reason ? ` (${facts.reason})` : ""}\n- Phase: arbitration\n\n${withPoolAttempts(result.decision.why_winner, pool)}\n`);
@@ -3327,14 +3325,13 @@ export class Orchestrator {
                         telemetry: createAttemptTelemetry(knobs.webPolicy, contract.external_context.web_required, effectiveWeb, [routed.browserRequirement, routed.denyRequirement, routed.delegationRequirement], knobs.model),
                     };
                     if (envelope.workspace_kind === "directory") {
-                        const captured = await captureDirectoryCandidate({
+                        ({ files: run.files, refusal: run.captureRefusal } = await captureDirectoryCandidate({
                             manager: wsm,
                             envelope,
                             artifactRoot: join(paths.attemptsDir, attemptId),
                             observedPaths: [...observedPaths],
-                        });
-                        run.files = captured.files;
-                        run.captureRefusal = captured.refusal;
+                            holder: { runId: paths.runId, runDir: paths.root },
+                        }));
                     }
                 }
                 lastRun = run;