specrails-core 5.6.0 → 6.0.1

package/dist/agent-runtime/graph/nodes.js

@@ -1,15 +1,18 @@
 import { guardrailEnabled } from '../guardrails.js';
 import { addDeveloperChecks, bindPlan, expandedPlanCommands, initializeVerificationPlan, readVerificationPlan, validateProposedChecks } from '../verification-plan.js';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { OpenSpecTools } from '../openspec.js';
-import { candidateManifest, fingerprintCandidate, frozenAcceptanceCriteria, recordAcceptance, transitionPipeline, validateAcceptanceReport, verifyPipeline, } from '../../installer/runtime/pipeline-state.js';
+import { candidateManifest, fingerprintCandidate, frozenAcceptanceCriteria, inspectPipeline, recordAcceptance, transitionPipeline, validateAcceptanceReport, verifyPipeline, } from '../../pipeline/pipeline-state.js';
 import { ARCHITECT_OUTPUT_SCHEMA, DEVELOPER_OUTPUT_SCHEMA, REVIEW_OUTPUT_SCHEMA, correctionInstructions, deepenInstructions, roleInstructions } from '../prompts.js';
 import { archive, child, journal, object, parseArchitecture, proposedVerification, write, writeDesignConfidence } from './artifacts.js';
 import { evaluateReview } from './review-policy.js';
-import { installEnvironment, isEnvironmentFailure } from '../compact/environment.js';
+import { hostPreconditionFailure, installEnvironment, isEnvironmentFailure } from '../compact/environment.js';
 import { unreachedTestFiles, unreachedTestsReason } from '../compact/test-reachability.js';
 import { exitCodeContradiction, exitHonestyReason } from '../compact/exit-code-honesty.js';
 import { boundedReviewManifest, reviewChanges } from '../review-context.js';
+import { describeFailure, divergence, outcomesSinceResume, unchangedFailure } from './convergence.js';
+import { captureOutOfScope, changeBases, changeSet, describeDiscarded, discardOutOfScopeEdits, renderChangeSet } from '../change-scope.js';
 /** Autonomous investigation passes before a low-confidence design asks or proceeds. */
 export const MAX_DEEPEN_PASSES = 1;
 const DEVELOPER_SUMMARY_LIMIT = 32_000;
@@ -63,6 +66,34 @@ export function developerRecord(output, text, result, provider) {
         incomplete,
     };
 }
+/** The change so far as prompt lines; a checkout git cannot measure yields no section instead of failing the role. */
+function measuredChange(context, change) {
+    try {
+        return renderChangeSet(changeSet(context, change));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The turn's record without the files Core undid: they are not part of the change, so they never count as progress. */
+function withoutDiscarded(context, record, discarded) {
+    if (!discarded.length)
+        return record;
+    const undone = new Set(discarded.map(edit => edit.path));
+    const relative = (file) => {
+        let value = file.replace(/\\/g, '/').replace(/^\.\//, '');
+        for (const repository of context.repositories) {
+            const root = repository.path.replace(/\\/g, '/');
+            if (value.startsWith(root + '/')) {
+                value = value.slice(root.length + 1);
+                break;
+            }
+        }
+        return value;
+    };
+    const kept = (files) => files.filter(file => !undone.has(relative(file)));
+    return { ...record, files: kept(record.files), tests: kept(record.tests), discarded: discarded.map(edit => (context.repositories.length > 1 ? edit.repositoryId + ':' : '') + edit.path).slice(0, 200) };
+}
 function architectNode(deps) {
     const { context, config, change, invoke, note } = deps;
     const accept = (output) => {
@@ -77,6 +108,8 @@ function architectNode(deps) {
         effect: 'write', ends: ['developer'],
         async run(state, step) {
             transitionPipeline(context, 'architect', 'running');
+            // The change is measured from here: record each repository's base before any role edits.
+            changeBases(context);
             // A resumed node collects the requester's answer first, so the pass that
             // asked the question is never repeated.
             const answers = [...state.answers];
@@ -164,7 +197,9 @@ async function implementationVisit(deps, state, step, mode) {
     // instructions.
     const fixer = fixing ? config.fixer : undefined;
     const provider = (fixer ?? config.agents.developer).provider;
-    const full = roleInstructions('developer', context, change, { definition: fixing ? config.rolePrompts?.fixer : config.rolePrompts?.developer, ...(fixing ? { stance: 'fixer' } : {}), feedback, verification: state.plan }) + (config.efficiency?.acceptDeveloperChecks !== false ? '\nYou may propose verificationChecks in your JSON summary. These are additive required checks, never replacements for the baseline. Use kind command with structured command/args, or kind harness with entrypoint and 1–8 relative source files (64 KiB each, 256 KiB total). Core persists harnesses outside delivery, appends the absolute entrypoint to argv and supplies SPECRAILS_CHECK_REPO_ROOT. Stable keys revise your own checks; omission retains them. Do not claim a check passed until Core has executed it.' : '');
+    // What the run has changed so far, from git: a correction stays inside it.
+    const changes = state.development ? measuredChange(context, change) : undefined;
+    const full = roleInstructions('developer', context, change, { definition: fixing ? config.rolePrompts?.fixer : config.rolePrompts?.developer, ...(fixing ? { stance: 'fixer' } : {}), feedback, verification: state.plan, developer: state.development, ...(changes ? { changeSet: changes } : {}) }) + (config.efficiency?.acceptDeveloperChecks !== false ? '\nYou may propose verificationChecks in your JSON summary. These are additive required checks, never replacements for the baseline. Use kind command with structured command/args, or kind harness with entrypoint and 1–8 relative source files (64 KiB each, 256 KiB total). Core persists harnesses outside delivery, appends the absolute entrypoint to argv and supplies SPECRAILS_CHECK_REPO_ROOT. Stable keys revise your own checks; omission retains them. Do not claim a check passed until Core has executed it.' : '');
     const previous = state.development;
     // A CLI developer with a live session takes corrections and continuations
     // as a short follow-up in that session; a configured fixer engine always
@@ -173,11 +208,13 @@ async function implementationVisit(deps, state, step, mode) {
     const resumable = !fixer && previous?.sessionId !== undefined && previous.provider === provider && visits > 1;
     if (fixer)
         note('fixer', `Correction round on the fixer engine (${fixer.provider}/${fixer.model ?? 'provider default'}).`);
+    // Out-of-scope state before the turn: afterwards the host undoes exactly what the turn did outside the scope.
+    const guard = captureOutOfScope(context, change);
     const outcome = await invoke('developer', step, {
         kind: visits > 1 ? 'correction' : 'initial',
         ...(fixer ? { agentOverride: fixer } : {}), ...(fixing ? { stance: 'fixer' } : {}),
         ...(resumable
-            ? { prompt: correctionInstructions('developer', feedback), resumeSessionId: previous.sessionId, fallbackPrompt: full }
+            ? { prompt: correctionInstructions('developer', feedback, { ...(changes ? { changeSet: changes } : {}), developer: state.development }), resumeSessionId: previous.sessionId, fallbackPrompt: full }
             : { prompt: full }),
         structured: true, lenient: true, outputSchema: DEVELOPER_OUTPUT_SCHEMA,
     }, (output, text, result) => {
@@ -188,6 +225,19 @@ async function implementationVisit(deps, state, step, mode) {
             throw new Error('Developer verification proposals are disabled by the frozen policy');
         return { ...developerRecord(output, text, result, provider), ...(checks.length ? { verificationChecks: checks } : {}) };
     });
+    const who = fixing ? 'Fixer' : 'Developer';
+    let discarded;
+    try {
+        discarded = discardOutOfScopeEdits(context, guard);
+    }
+    catch (error) {
+        return { status: 'blocked', error: `${who} edited files outside the repository scope and Core could not undo them: ${error instanceof Error ? error.message : String(error)}. Restore those files in the worktree, then resume.` };
+    }
+    const multiple = context.repositories.length > 1;
+    if (discarded.length) {
+        const scopes = context.repositories.filter(repository => repository.scope?.length).map(repository => repository.scope.join(', ')).join('; ');
+        note(mode, `Undid ${plural(discarded.length, 'edit')} outside the repository scope (${scopes}): ${describeDiscarded(discarded, multiple)}. Only changes inside the scope are part of this change.`);
+    }
     // A timeout is a budget, not a defect: the groups already finished are
     // ticked in tasks.md and verified, and write_progress holds the handoff, so
     // the run BLOCKS (resume continues from the next open group, or raise
@@ -195,10 +245,9 @@ async function implementationVisit(deps, state, step, mode) {
     if (!outcome.ok)
         return settle(outcome, 'Finished task groups are ticked and verified; resume to continue from the next open group, or raise limits.timeoutMs.');
     new OpenSpecTools(deps.openspec.developer, step.signal).assertParticipation();
-    const record = outcome.value;
+    const record = withoutDiscarded(context, outcome.value, discarded);
     const effective = addDeveloperChecks(context, record.verificationChecks ?? []);
     bindPlan(context, effective);
-    const who = fixing ? 'Fixer' : 'Developer';
     note(mode, record.structured
         ? `${who} finished: ${plural(record.files.length, 'file')} changed, ${plural(record.tests.length, 'test file')} touched${record.incomplete.length ? `, ${plural(record.incomplete.length, 'task')} left incomplete` : ''}.`
         : `${who} finished without the structured summary; the prose summary is recorded instead.`);
@@ -237,8 +286,55 @@ function fixerNode(deps) {
         },
     };
 }
+/** Where a missing dependency install belongs: the nearest directory with a lockfile or manifest above the failing command, else the repository root. */
+const INSTALL_MARKERS = ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock', 'bun.lockb', 'requirements.txt', 'pyproject.toml', 'go.mod', 'Cargo.toml'];
+function installRoots(context, commands) {
+    const roots = [];
+    for (const command of commands) {
+        const repository = context.repositories.find(repo => repo.id === command.repositoryId);
+        if (!repository)
+            continue;
+        let directory = command.cwd;
+        let chosen = repository.path;
+        for (;;) {
+            const relative = path.relative(repository.path, directory);
+            if (relative.startsWith('..') || path.isAbsolute(relative))
+                break;
+            if (INSTALL_MARKERS.some(name => existsSync(path.join(directory, name)))) {
+                chosen = directory;
+                break;
+            }
+            if (!relative)
+                break;
+            directory = path.dirname(directory);
+        }
+        roots.push(chosen);
+    }
+    // Every repository root stays a candidate: its plan is a no-op when it is already installed.
+    return [...new Set([...roots, ...context.repositories.map(repository => repository.path)])];
+}
+/** A directory as the log should name it: relative to the checkout that contains it. */
+function checkoutRelative(context, directory) {
+    const repository = context.repositories.find(repo => { const relative = path.relative(repo.path, directory); return !relative.startsWith('..') && !path.isAbsolute(relative); });
+    return repository ? path.relative(repository.path, directory).split(path.sep).join('/') || '.' : directory;
+}
+function hostPreconditionMessage(reason, command, args, directory) {
+    return `Verification cannot run in this environment: ${reason} (\`${[command, ...args].join(' ')}\` in ${directory}). This is not a defect in the change, so no correction round was started. Make it available to Specrails (for example in the login shell profile Specrails loads, or with a refreshed registry token), then resume.`;
+}
+/** A failed check the host must unblock (credentials, registry access, a missing variable): no correction round can repair it. */
+function preconditionBlock(context, receipt) {
+    for (const command of receipt.commands) {
+        if (command.exitCode === 0)
+            continue;
+        const reason = hostPreconditionFailure(command.output);
+        if (reason)
+            return hostPreconditionMessage(reason, command.command, command.args, checkoutRelative(context, command.cwd));
+    }
+    return undefined;
+}
 function verifyNode(deps) {
     const { context, note, config } = deps;
+    const roots = context.repositories.map(repository => repository.path);
     return {
         effect: 'write', ends: ['reviewer', 'developer', 'fixer'],
         async run(state, step) {
@@ -257,35 +353,85 @@ function verifyNode(deps) {
                 throw new Error('Verification plan is unavailable');
             const plan = expandedPlanCommands(context, effective);
             const uncovered = uncoveredRepositories(context, plan);
-            let receipt = await verifyPipeline(context, { kind: 'full', planHash: effective.planHash, commands: plan, ...(uncovered.length ? { unverified: true } : {}) }, deps.onVerificationOutput, step.signal, { ...(guardrailEnabled(config.guardrails, 'verify-idle-timeout') ? {} : { idleTimeoutMs: 0 }), onEvidence: async (kind, payload) => { await step.reportEfficiencyActivity?.(kind, payload); }, maxConcurrency: effective.executionPolicy.maxConcurrency, ...(step.remainingBudget().maxDurationMs === undefined ? {} : { deadline: Date.now() + step.remainingBudget().maxDurationMs }) });
+            // A correction round that left the failed candidate exactly as it was
+            // cannot pass the same checks: stop instead of re-running them.
+            const recent = outcomesSinceResume(state.verifyHistory ?? [], step.checkpoint);
+            const last = recent.at(-1);
+            const rejected = last?.passed === true && state.review !== null && !state.review.approved;
+            if (recent.some(entry => !entry.passed) || rejected) {
+                const candidate = fingerprintCandidate(journal(context));
+                const unchanged = unchangedFailure(recent, candidate, effective.planHash);
+                if (unchanged) {
+                    note('fixer', 'The correction round did not change the candidate that failed verification; stopping instead of re-running the same checks.');
+                    return { status: 'blocked', error: `Correction loop stopped: the last correction round left the change exactly as it was when verification failed (${unchanged.summary}). Re-running the same checks cannot pass. If the failure lies outside this change (a pre-existing failure, another package or the environment), fix it there and resume.`, usage: NO_SPEND };
+                }
+                // The reviewer rejected exactly this candidate and the correction round changed nothing: the
+                // fixer disputes the request. Its evidence still holds, so the reviewer decides again without
+                // re-running the same checks; a second rejection of the same change ends the dispute.
+                if (rejected && last.candidateHash === candidate && last.planHash === effective.planHash) {
+                    const reviews = recent.filter(entry => entry.passed && entry.candidateHash === candidate && entry.planHash === effective.planHash).length;
+                    if (reviews >= 2) {
+                        note('fixer', 'The reviewer rejected the same unchanged change twice; stopping instead of another round.');
+                        return { status: 'blocked', error: `Correction loop stopped: the reviewer rejected the same change twice and the correction rounds did not change it (${state.review.issues.slice(0, 3).join('; ').slice(0, 600) || state.review.summary.slice(0, 300)}). Decide whether the review request applies to this change, then resume.`, usage: NO_SPEND };
+                    }
+                    if (inspectPipeline(context).verification.valid && state.verifyResult) {
+                        note('developer', 'The correction round did not change the verified change; reusing its verification evidence and returning to the reviewer.');
+                        transitionPipeline(context, 'developer', 'done');
+                        return { status: 'succeeded', next: 'reviewer', update: { verifyResult: state.verifyResult, verifyHistory: [{ ...last, at: new Date().toISOString() }] }, output: state.verifyResult, usage: NO_SPEND };
+                    }
+                }
+            }
+            const run = () => verifyPipeline(context, { kind: 'full', planHash: effective.planHash, commands: plan, ...(uncovered.length ? { unverified: true } : {}) }, deps.onVerificationOutput, step.signal, { ...(guardrailEnabled(config.guardrails, 'verify-idle-timeout') ? {} : { idleTimeoutMs: 0 }), onEvidence: async (kind, payload) => { await step.reportEfficiencyActivity?.(kind, payload); }, maxConcurrency: effective.executionPolicy.maxConcurrency, ...(step.remainingBudget().maxDurationMs === undefined ? {} : { deadline: Date.now() + step.remainingBudget().maxDurationMs }) });
+            let receipt = await run();
+            const hostBlocked = (reason) => {
+                note('fixer', 'Verification failed on the environment, not on the change; stopping for the host instead of starting a correction round.');
+                return { status: 'blocked', error: reason, usage: NO_SPEND };
+            };
+            let precondition = receipt.valid ? undefined : preconditionBlock(context, receipt);
+            if (precondition)
+                return hostBlocked(precondition);
             // A failure that is really a missing toolchain or dependency (exit 127,
             // "command not found", "Cannot find module"…) is the HOST's to fix, not
             // the model's — for every developer: a fresh worktree has no
-            // node_modules whatever wrote the code. Install once and re-verify; only
-            // a second failure becomes developer feedback.
+            // node_modules whatever wrote the code. Install once where the failing
+            // command runs and re-verify; only a second failure becomes feedback.
             if (!receipt.valid && guardrailEnabled(config.guardrails, 'environment-repair') && receipt.commands.some(command => isEnvironmentFailure(command.exitCode, command.output))) {
-                const installs = installEnvironment(context.repositories.map(repository => repository.path), { failureOutput: receipt.commands.map(command => command.output).join('\n'), lockfileRepair: guardrailEnabled(config.guardrails, 'lockfile-repair'), onEvent: event => note('developer', event.kind === 'text' ? event.text ?? '' : `[environment] ${event.tool ?? ''} ${event.detail ?? ''}`.trim()) });
+                const installs = installEnvironment(installRoots(context, receipt.commands.filter(command => command.exitCode !== 0)), { failureOutput: receipt.commands.map(command => command.output).join('\n'), lockfileRepair: guardrailEnabled(config.guardrails, 'lockfile-repair'), onEvent: event => note('developer', event.kind === 'text' ? event.text ?? '' : `[environment] ${event.tool ?? ''} ${event.detail ?? ''}`.trim()) });
+                const refused = installs.find(outcome => outcome.precondition);
+                if (refused)
+                    return hostBlocked(hostPreconditionMessage(`installing its dependencies failed because ${refused.precondition}`, refused.command, refused.args, checkoutRelative(context, refused.root)));
                 if (installs.some(outcome => outcome.ok)) {
                     note('developer', 'Verification failed on the environment (missing dependencies or tools); the host installed them and is verifying again.');
-                    receipt = await verifyPipeline(context, { kind: 'full', planHash: effective.planHash, commands: plan, ...(uncovered.length ? { unverified: true } : {}) }, deps.onVerificationOutput, step.signal, { ...(guardrailEnabled(config.guardrails, 'verify-idle-timeout') ? {} : { idleTimeoutMs: 0 }), onEvidence: async (kind, payload) => { await step.reportEfficiencyActivity?.(kind, payload); }, maxConcurrency: effective.executionPolicy.maxConcurrency, ...(step.remainingBudget().maxDurationMs === undefined ? {} : { deadline: Date.now() + step.remainingBudget().maxDurationMs }) });
+                    receipt = await run();
+                    precondition = receipt.valid ? undefined : preconditionBlock(context, receipt);
+                    if (precondition)
+                        return hostBlocked(precondition);
                 }
             }
             const evidence = {
                 valid: receipt.valid, ...(receipt.reason ? { reason: receipt.reason } : {}), receiptId: receipt.id, unverifiedRepositories: uncovered,
                 commands: receipt.commands.map(({ evidenceId, repositoryId, command, args, exitCode, output }) => ({ ...(evidenceId ? { evidenceId } : {}), repositoryId, command, args, exitCode, output: output.slice(-2000) })),
             };
-            if (!receipt.valid) {
-                note('fixer', `Verification failed (${receipt.reason ?? 'a command failed'}); handing the exact output to the fixer.`);
-                return { status: 'succeeded', next: 'fixer', update: { verifyResult: evidence }, output: evidence, usage: NO_SPEND };
-            }
+            const outcome = (passed, finding) => ({ at: new Date().toISOString(), candidateHash: receipt.candidateHash, planHash: effective.planHash, passed, ...(passed ? {} : describeFailure(receipt, roots, finding)) });
+            /** Hands a failure to the fixer unless the correction loop has stopped converging. */
+            const toFixer = (record, message, finding) => {
+                const failure = outcome(false, finding);
+                const loop = divergence(recent, failure);
+                if (loop) {
+                    note('fixer', 'The correction loop is not converging; stopping instead of starting another round.');
+                    return { status: 'blocked', error: `Correction loop stopped: ${loop} Inspect the evidence, fix what lies outside the change (or adjust the request), then resume.`, output: record, usage: NO_SPEND };
+                }
+                note('fixer', message);
+                return { status: 'succeeded', next: 'fixer', update: { verifyResult: record, verifyHistory: [failure] }, output: record, usage: NO_SPEND };
+            };
+            if (!receipt.valid)
+                return toFixer(evidence, `Verification failed (${receipt.reason ?? 'a command failed'}); handing the exact output to the fixer.`);
             // Exit 0 with "3 failed" in the output is a broken harness, not a pass.
             if (guardrailEnabled(config.guardrails, 'exit-code-honesty')) {
                 const findings = receipt.commands.flatMap(command => { const found = exitCodeContradiction(command.exitCode, command.output); return found ? [{ ...found, command: [command.command, ...command.args].join(' ') }] : []; });
                 if (findings.length) {
                     const reason = exitHonestyReason(findings);
-                    note('fixer', `Verification exited 0 but reported failures (${findings.map(item => item.sample).join(' | ')}); handing it to the fixer as a failure.`);
-                    const dishonest = { ...evidence, valid: false, reason };
-                    return { status: 'succeeded', next: 'fixer', update: { verifyResult: dishonest }, output: dishonest, usage: NO_SPEND };
+                    return toFixer({ ...evidence, valid: false, reason }, `Verification exited 0 but reported failures (${findings.map(item => item.sample).join(' | ')}); handing it to the fixer as a failure.`, reason);
                 }
             }
             // Every command exited 0 — but did any of them RUN the tests the
@@ -299,14 +445,12 @@ function verifyNode(deps) {
                 const unreached = context.repositories.flatMap(repository => unreachedTestFiles(repository.path, plan.filter(command => command.repositoryId === repository.id).map(({ command, args, cwd }) => ({ command, args, ...(cwd ? { cwd } : {}) })), reported).map(file => context.repositories.length > 1 ? `${repository.id}:${file}` : file));
                 if (unreached.length) {
                     const reason = unreachedTestsReason(unreached);
-                    note('fixer', `Verification incomplete: ${unreached.join(', ')} ${unreached.length === 1 ? 'is' : 'are'} not run by any verification command; handing it to the fixer.`);
-                    const incomplete = { ...evidence, valid: false, reason };
-                    return { status: 'succeeded', next: 'fixer', update: { verifyResult: incomplete }, output: incomplete, usage: NO_SPEND };
+                    return toFixer({ ...evidence, valid: false, reason }, `Verification incomplete: ${unreached.join(', ')} ${unreached.length === 1 ? 'is' : 'are'} not run by any verification command; handing it to the fixer.`, reason);
                 }
             }
             transitionPipeline(context, 'developer', 'done');
             note('developer', plan.length ? `Verification passed: ${plural(plan.length, 'command')} exited 0.` : 'No verification commands available; relying on task completion and review.');
-            return { status: 'succeeded', next: 'reviewer', update: { verifyResult: evidence }, output: evidence, usage: NO_SPEND };
+            return { status: 'succeeded', next: 'reviewer', update: { verifyResult: evidence, verifyHistory: [outcome(true)] }, output: evidence, usage: NO_SPEND };
         },
     };
 }
@@ -365,9 +509,12 @@ function reviewerNode(deps) {
                 : undefined;
             if (reReview)
                 note('reviewer', `Re-review: ${plural(reReview.changes.length, 'file')} changed since the previous verdict; certifying the previous issues instead of re-reading the candidate.`);
-            const prompt = roleInstructions('reviewer', context, change, { definition: config.rolePrompts?.reviewer, feedback: feedbackFor(state), verification: state.plan, policy, criteria, developer: state.development, ...(reReview ? { reReview } : {}) });
+            // The reviewer judges the change itself, measured from git — not the whole checkout.
+            const changes = measuredChange(context, change);
+            const prompt = roleInstructions('reviewer', context, change, { definition: config.rolePrompts?.reviewer, feedback: feedbackFor(state), verification: state.plan, policy, criteria, developer: state.development, ...(changes ? { changeSet: changes } : {}), ...(reReview ? { reReview } : {}) });
             const incremental = config.efficiency?.reviewMode !== 'full' && delta.mode === 'incremental' && state.review?.sessionId;
             const followup = correctionInstructions('reviewer', feedbackFor(state)) + '\nChanges since YOUR previous reviewed candidate:\n' + JSON.stringify(delta.changes)
+                + (changes ? '\nThe complete change under review (from git, against the run\'s base) — review these files only:\n' + changes.join('\n') : '')
                 + '\nRecertify EVERY current acceptance criterion; previous met results are not current evidence:\n' + JSON.stringify(criteria)
                 + '\nCurrent developer handoff:\n' + JSON.stringify(state.development);
             const outcome = await invoke('reviewer', step, { kind: state.review ? 'correction' : 'initial', prompt: incremental ? followup : prompt, ...(incremental ? { resumeSessionId: state.review.sessionId, fallbackPrompt: prompt } : {}), structured: true, outputSchema: REVIEW_OUTPUT_SCHEMA }, output => {
@@ -425,4 +572,3 @@ function archiveNode(deps) {
 export function coreNodes(deps) {
     return { architect: architectNode(deps), developer: developerNode(deps), fixer: fixerNode(deps), verify: verifyNode(deps), reviewer: reviewerNode(deps), archive: archiveNode(deps) };
 }
-//# sourceMappingURL=nodes.js.map

package/dist/agent-runtime/graph/review-policy.js

@@ -29,4 +29,3 @@ export function evaluateReview(raw, policy) {
         && REVIEW_ASPECTS.every(name => scored[name] >= policy.aspects[name]);
     return { record: { approved: raw.approved, summary: raw.summary, issues: raw.issues, score: raw.score, aspects: scored }, approved };
 }
-//# sourceMappingURL=review-policy.js.map

package/dist/agent-runtime/graph/roles.d.ts

@@ -1,10 +1,8 @@
 import { type InvocationKind } from '../role-routing.js';
-import { type PipelineContext } from '../../installer/runtime/pipeline-state.js';
+import { type PipelineContext } from '../../pipeline/pipeline-state.js';
 import type { ExecutorRegistry } from '../executors.js';
-import { type AgentEvent, type AgentEventRole, type AgentResult, type AgentRole, type AgentUsage, type RuntimeConfig, type RuntimeAgentConfig } from '../executor-types.js';
+import { type AgentEvent, type AgentEventRole, type AgentResult, type AgentRole, type RuntimeConfig, type RuntimeAgentConfig } from '../executor-types.js';
 import type { WorkflowStepContext } from '../workflow-types.js';
-/** Executor failures that mean "this session cannot be continued", not "the role failed". */
-export declare const SESSION_FALLBACK_CODES: Set<string>;
 export interface InvokeOptions {
     kind?: InvocationKind;
     prompt: string;
@@ -41,7 +39,6 @@ export interface RoleInvokerDeps {
     /** `fixer` labels the developer step's events during a correction round on the fixer stance, so a log reader sees who is acting. */
     onAgentEvent?: (role: AgentEventRole, event: AgentEvent) => void;
 }
-export declare function sumUsage(a: AgentUsage, b: AgentUsage): AgentUsage;
 /**
  * One role turn against the configured executor: budget-aware request, live
  * event forwarding with repository-relative paths, structured parsing with a

package/dist/agent-runtime/graph/roles.js

@@ -5,18 +5,13 @@ import { selectRoleRoute } from '../role-routing.js';
 import { ROLE_SKILLS, OPENSPEC_VERSION, OpenSpecTools, OpenSpecParticipationError, openSpecRepairPrompt } from '../openspec.js';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { frozenAcceptanceCriteria, pipelineStateDirectory } from '../../installer/runtime/pipeline-state.js';
+import { frozenAcceptanceCriteria, pipelineStateDirectory } from '../../pipeline/pipeline-state.js';
 import { AgentExecutionError, unknownUsage } from '../executor-types.js';
-import { sumCacheUsage } from '../efficiency-types.js';
 import { ROLE_INSTRUCTIONS_VERSION, repairInstructions } from '../prompts.js';
 import { parseAgentObject } from './artifacts.js';
 /** Executor failures that mean "this session cannot be continued", not "the role failed". */
-export const SESSION_FALLBACK_CODES = new Set(['session_not_found', 'session_expired', 'session_unsupported']);
+const SESSION_FALLBACK_CODES = new Set(['session_not_found', 'session_expired', 'session_unsupported']);
 const REPAIRABLE = /Invalid|Expected|requires|Duplicate|malformed/i;
-export function sumUsage(a, b) {
-    const add = (x, y) => x === null || y === null ? null : x + y;
-    return { inputTokens: add(a.inputTokens, b.inputTokens), outputTokens: add(a.outputTokens, b.outputTokens), costUsd: add(a.costUsd, b.costUsd), ...sumCacheUsage([a, b]) };
-}
 /**
  * One role turn against the configured executor: budget-aware request, live
  * event forwarding with repository-relative paths, structured parsing with a
@@ -195,4 +190,3 @@ export function createRoleInvoker(deps) {
         }
     };
 }
-//# sourceMappingURL=roles.js.map

package/dist/agent-runtime/graph/state.d.ts

@@ -1,4 +1,5 @@
-import type { VerificationCommand } from '../../installer/runtime/pipeline-state.js';
+import type { VerificationCommand } from '../../pipeline/pipeline-state.js';
+import type { VerifyOutcome } from './convergence.js';
 export type DesignConfidence = 'high' | 'medium' | 'low';
 export interface ArchitectureRecord {
     planningDepth?: 'focused' | 'full';
@@ -28,6 +29,8 @@ export interface DeveloperRecord {
     }>;
     /** False when the provider returned prose instead of the structured summary. */
     structured: boolean;
+    /** Edits outside the repository scope that Core undid after this turn (repository-qualified when several repositories are in scope). */
+    discarded?: string[];
 }
 export interface VerificationRecord {
     valid: boolean;
@@ -76,6 +79,8 @@ export declare const CoreState: import("@langchain/langgraph").AnnotationRoot<{
     /** Autonomous investigation passes the architect already spent on a low-confidence design. */
     deepenPasses: import("@langchain/langgraph").BaseChannel<number, number | import("@langchain/langgraph").OverwriteValue<number>, unknown>;
     archived: import("@langchain/langgraph").BaseChannel<ArchiveRecord | null, ArchiveRecord | import("@langchain/langgraph").OverwriteValue<ArchiveRecord | null> | null, unknown>;
+    /** Recent verify outcomes (bounded), so the host can tell a converging correction loop from a circular one. */
+    verifyHistory: import("@langchain/langgraph").BaseChannel<VerifyOutcome[], VerifyOutcome[] | import("@langchain/langgraph").OverwriteValue<VerifyOutcome[]>, unknown>;
 }>;
 export type CoreStateType = typeof CoreState.State;
 export type CoreStateUpdate = typeof CoreState.Update;

package/dist/agent-runtime/graph/state.js

@@ -18,7 +18,8 @@ export const CoreState = Annotation.Root({
     /** Autonomous investigation passes the architect already spent on a low-confidence design. */
     deepenPasses: Annotation({ ...replace(), default: () => 0 }),
     archived: Annotation({ ...replace(), default: () => null }),
+    /** Recent verify outcomes (bounded), so the host can tell a converging correction loop from a circular one. */
+    verifyHistory: Annotation({ reducer: (previous, next) => [...previous, ...next].slice(-50), default: () => [] }),
 });
 /** Graph order. `fixer` is the correction node: verify (failed, tasks ticked) and reviewer (rejected) route there; it hands back to verify. */
 export const CORE_NODE_ORDER = ['architect', 'developer', 'fixer', 'verify', 'reviewer', 'archive'];
-//# sourceMappingURL=state.js.map

package/dist/agent-runtime/graph-checkpointer.d.ts

@@ -1,7 +1,7 @@
 import { BaseCheckpointSaver, type ChannelVersions, type Checkpoint, type CheckpointListOptions, type CheckpointMetadata, type CheckpointTuple, type PendingWrite } from '@langchain/langgraph-checkpoint';
 import type { RunnableConfig } from '@langchain/core/runnables';
 /** One serialized LangGraph value: the serializer's type tag plus base64 bytes. */
-export interface SerializedBlob {
+interface SerializedBlob {
     type: string;
     data: string;
 }
@@ -59,3 +59,4 @@ export declare class FileCheckpointSaver extends BaseCheckpointSaver {
     putWrites(config: RunnableConfig, writes: PendingWrite[], taskId: string): Promise<void>;
     deleteThread(threadId: string): Promise<void>;
 }
+export {};

package/dist/agent-runtime/graph-checkpointer.js

@@ -134,4 +134,3 @@ export class FileCheckpointSaver extends BaseCheckpointSaver {
         await this.persist();
     }
 }
-//# sourceMappingURL=graph-checkpointer.js.map

package/dist/agent-runtime/guardrails.d.ts

@@ -1,15 +1,15 @@
 export declare const GUARDRAIL_IDS: readonly ["plan-validation", "genuine-blocking-question", "plan-language-hint", "frozen-plan-writes", "primary-language", "duplicate-sibling", "one-test-per-module", "empty-write", "evidence-gated-ticking", "inventory-retry", "synthetic-corrections", "silent-group-closure", "verify-per-group", "test-reachability", "exit-code-honesty", "environment-repair", "lockfile-repair", "verify-idle-timeout"];
 export type GuardrailId = (typeof GUARDRAIL_IDS)[number];
-export type GuardrailPhase = 'architect' | 'developer' | 'host';
-export interface GuardrailDescriptor {
+type GuardrailPhase = 'architect' | 'developer' | 'host';
+interface GuardrailDescriptor {
     id: GuardrailId;
     phase: GuardrailPhase;
 }
 export type GuardrailSettings = Partial<Record<GuardrailId, boolean>>;
 /** Stable catalog (phase order = pipeline order); labels/descriptions live in the host UI so they can be localized. */
 export declare const GUARDRAIL_CATALOG: readonly GuardrailDescriptor[];
-export declare function isGuardrailId(value: unknown): value is GuardrailId;
 /** A guardrail is on unless the settings say `false` explicitly. */
 export declare function guardrailEnabled(settings: GuardrailSettings | undefined, id: GuardrailId): boolean;
 /** Validates a raw `guardrails` object: only known ids, only booleans. Returns the normalized settings (unset ⇒ omitted). */
 export declare function validateGuardrailSettings(value: unknown, path?: string): GuardrailSettings;
+export {};

package/dist/agent-runtime/guardrails.js

@@ -52,7 +52,7 @@ export const GUARDRAIL_CATALOG = [
     { id: 'lockfile-repair', phase: 'host' },
     { id: 'verify-idle-timeout', phase: 'host' },
 ];
-export function isGuardrailId(value) {
+function isGuardrailId(value) {
     return typeof value === 'string' && GUARDRAIL_IDS.includes(value);
 }
 /** A guardrail is on unless the settings say `false` explicitly. */
@@ -73,4 +73,3 @@ export function validateGuardrailSettings(value, path = 'guardrails') {
     }
     return out;
 }
-//# sourceMappingURL=guardrails.js.map

package/dist/agent-runtime/index.d.ts

@@ -17,5 +17,5 @@ export { FileCheckpointSaver, type GraphStoreIO, type SerializedGraphStore } fro
 export { ARCHITECT_OUTPUT_SCHEMA, DEVELOPER_OUTPUT_SCHEMA, REVIEW_OUTPUT_SCHEMA, ROLE_INSTRUCTIONS_VERSION, rolePromptDefaults, correctionInstructions, deepenInstructions, repairInstructions, roleInstructions, type FrozenCriterion, type RoleFeedback, type RoleInstructionOptions, } from './prompts.js';
 export { OPENSPEC_VERSION, ROLE_SKILLS, type OpenSpecRoleContext } from './openspec.js';
 export * from './efficiency-summary.js';
-export { readVerificationEvidence, type VerificationEvidenceQuery } from '../installer/runtime/pipeline-state.js';
+export { readVerificationEvidence, type VerificationEvidenceQuery } from '../pipeline/pipeline-state.js';
 export { runRecovery, recoveryRequestSchema, type RecoveryRequest } from './recovery.js';

package/dist/agent-runtime/index.js

@@ -17,6 +17,5 @@ export { FileCheckpointSaver } from './graph-checkpointer.js';
 export { ARCHITECT_OUTPUT_SCHEMA, DEVELOPER_OUTPUT_SCHEMA, REVIEW_OUTPUT_SCHEMA, ROLE_INSTRUCTIONS_VERSION, rolePromptDefaults, correctionInstructions, deepenInstructions, repairInstructions, roleInstructions, } from './prompts.js';
 export { OPENSPEC_VERSION, ROLE_SKILLS } from './openspec.js';
 export * from './efficiency-summary.js';
-export { readVerificationEvidence } from '../installer/runtime/pipeline-state.js';
+export { readVerificationEvidence } from '../pipeline/pipeline-state.js';
 export { runRecovery, recoveryRequestSchema } from './recovery.js';
-//# sourceMappingURL=index.js.map

package/dist/agent-runtime/kimi-acp.js

@@ -1,5 +1,5 @@
 import { toolEvent } from './tool-event.js';
-import { normalizeKimiCliModel } from '../installer/runtime/kimi.js';
+import { normalizeKimiCliModel } from './kimi-model.js';
 import { AgentExecutionError, unknownUsage, validateAgentRequest } from './executor-types.js';
 import { runCliProcess } from './cli-process.js';
 import { parseStructuredText } from './openai-executor.js';
@@ -187,4 +187,3 @@ export async function executeKimiReadonlyAcp(request, options = {}) {
     request.onEvent?.({ kind: 'usage', usage });
     return { text, usage, sessionId, structured: parseStructuredText(text) };
 }
-//# sourceMappingURL=kimi-acp.js.map

package/dist/agent-runtime/kimi-model.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Configurations keep raw provider ids. At the CLI boundary only the managed
+ * Kimi aliases gain their documented `kimi-code/` namespace; custom and
+ * already-qualified ids stay byte-identical.
+ */
+export declare function normalizeKimiCliModel(model: string): string;

package/dist/agent-runtime/kimi-model.js

@@ -0,0 +1,12 @@
+const OFFICIAL_SHORT_MODEL_IDS = new Set(['k3', 'kimi-for-coding', 'kimi-for-coding-highspeed']);
+const SAFE_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._/:-]{0,127}$/;
+/**
+ * Configurations keep raw provider ids. At the CLI boundary only the managed
+ * Kimi aliases gain their documented `kimi-code/` namespace; custom and
+ * already-qualified ids stay byte-identical.
+ */
+export function normalizeKimiCliModel(model) {
+    if (!SAFE_MODEL_ID.test(model))
+        throw new Error('Kimi model id must be 1-128 characters and match [A-Za-z0-9][A-Za-z0-9._/:-]*');
+    return OFFICIAL_SHORT_MODEL_IDS.has(model) ? `kimi-code/${model}` : model;
+}

package/dist/agent-runtime/openai-executor.d.ts

@@ -9,15 +9,6 @@ export interface OpenAICompatibleOptions {
     idleTimeoutMs?: number;
 }
 export declare function parseStructuredText(text: string): Record<string, unknown> | undefined;
-/** The agent loop an openai-compatible provider runs: compact host-driven pipelines by default. */
-/** The OpenAI `reasoning_effort` tiers a compatible endpoint accepts. */
-export declare const OPENAI_EFFORTS: readonly ["low", "medium", "high"];
-export declare function resolveAgentLoop(provider: ApiProvider): 'compact' | 'free';
-/** Compact runs: abort when NOTHING happens for this long (no tool call, reply or usage) — the real hang detector now that the wall clock is per task group. A non-streaming 16k reply at 20 tok/s is ~13 min, hence the margin. */
-export declare const IDLE_TIMEOUT_MS: number;
-export declare function resolveContextWindow(provider: ApiProvider): number;
-/** The per-turn output budget the connection declares; undefined keeps the loop's default. */
-export declare function resolveOutputBudget(provider: ApiProvider): number | undefined;
 /** No SDK, gateway, tracing backend, paid probe, or mandatory key. */
 export declare class OpenAICompatibleExecutor implements AgentExecutor {
     private readonly provider;

package/dist/agent-runtime/openai-executor.js

@@ -1,4 +1,4 @@
-import { readVerificationEvidence } from '../installer/runtime/pipeline-state.js';
+import { readVerificationEvidence } from '../pipeline/pipeline-state.js';
 import { assertEffortSupported, unknownCapabilities } from './capabilities.js';
 import { OpenSpecTools, OPENSPEC_TOOL_DEFINITION, openSpecPrompt } from './openspec.js';
 import { AgentExecutionError, unknownUsage, validateAgentRequest } from './executor-types.js';
@@ -19,13 +19,13 @@ export function parseStructuredText(text) {
 }
 /** The agent loop an openai-compatible provider runs: compact host-driven pipelines by default. */
 /** The OpenAI `reasoning_effort` tiers a compatible endpoint accepts. */
-export const OPENAI_EFFORTS = ['low', 'medium', 'high'];
-export function resolveAgentLoop(provider) { return provider.agentLoop ?? 'compact'; }
+const OPENAI_EFFORTS = ['low', 'medium', 'high'];
+function resolveAgentLoop(provider) { return provider.agentLoop ?? 'compact'; }
 /** Compact runs: abort when NOTHING happens for this long (no tool call, reply or usage) — the real hang detector now that the wall clock is per task group. A non-streaming 16k reply at 20 tok/s is ~13 min, hence the margin. */
-export const IDLE_TIMEOUT_MS = 20 * 60_000;
-export function resolveContextWindow(provider) { return provider.contextWindowTokens ?? DEFAULT_CONTEXT_WINDOW_TOKENS; }
+const IDLE_TIMEOUT_MS = 20 * 60_000;
+function resolveContextWindow(provider) { return provider.contextWindowTokens ?? DEFAULT_CONTEXT_WINDOW_TOKENS; }
 /** The per-turn output budget the connection declares; undefined keeps the loop's default. */
-export function resolveOutputBudget(provider) { return provider.maxOutputTokens; }
+function resolveOutputBudget(provider) { return provider.maxOutputTokens; }
 /** No SDK, gateway, tracing backend, paid probe, or mandatory key. */
 export class OpenAICompatibleExecutor {
     provider;
@@ -134,4 +134,3 @@ export class OpenAICompatibleExecutor {
         }
     }
 }
-//# sourceMappingURL=openai-executor.js.map

package/dist/agent-runtime/openspec-tool-server.js

@@ -1,4 +1,4 @@
-import { readVerificationEvidence } from '../installer/runtime/pipeline-state.js';
+import { readVerificationEvidence } from '../pipeline/pipeline-state.js';
 import { readFileSync } from 'node:fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -34,4 +34,3 @@ if (context.evidenceScope && context.role !== 'architect')
         }
     });
 await server.connect(new StdioServerTransport());
-//# sourceMappingURL=openspec-tool-server.js.map

package/dist/agent-runtime/openspec.d.ts

@@ -62,7 +62,6 @@ export declare const IMPLEMENTATION_PROGRESS_SCHEMA: z.ZodObject<{
     }, z.core.$strict>>;
     blockers: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
-export declare function renderProgressHandoff(context: OpenSpecRoleContext): string;
 export declare function hash(text: string): string;
 export declare function resolveOpenSpecCli(): string;
 export declare function runOpenSpec(cli: string, root: string, args: string[], signal?: AbortSignal): Promise<string>;
@@ -98,7 +97,6 @@ export declare class OpenSpecTools {
     assertParticipation(after?: number): void;
     assertReady(): Promise<OpenSpecApply>;
 }
-export declare const OPENSPEC_BRIDGE_ENTRY: string;
 export declare const OPENSPEC_TOOL_ACTIONS: readonly ["load_skill", "new", "status", "instructions", "validate", "write_artifact", "read_progress", "write_progress"];
 export declare const OPENSPEC_TOOL_DEFINITION: {
     type: string;