specrails-core 5.6.0 → 6.0.1

package/dist/agent-runtime/compact/architect.js

@@ -29,18 +29,18 @@ const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const NON_SOURCE = new Set(['openspec', 'README.md', 'README', 'LICENSE', 'LICENSE.md', '.gitignore', '.gitattributes', '.editorconfig', 'CLAUDE.md', 'AGENTS.md', 'GEMINI.md', '.DS_Store']);
 const HIDDEN = /^\./;
 const stringList = { type: 'array', items: { type: 'string' } };
-export const INVENTORY_SCHEMA = { type: 'object', additionalProperties: false, required: ['greenfield', 'languages', 'frameworks', 'keyFiles', 'tests', 'notes'], properties: { greenfield: { type: 'boolean' }, languages: stringList, frameworks: stringList, keyFiles: stringList, tests: stringList, notes: { type: 'string' } } };
-export const PROPOSAL_SCHEMA = { type: 'object', additionalProperties: false, required: ['why', 'whatChanges', 'capabilities', 'impact'], properties: { why: { type: 'string' }, whatChanges: stringList, capabilities: { type: 'object', additionalProperties: false, required: ['new', 'modified'], properties: { new: stringList, modified: stringList } }, impact: stringList } };
-export const DESIGN_SCHEMA = { type: 'object', additionalProperties: false, required: ['context', 'goals', 'nonGoals', 'decisions', 'risks'], properties: { context: { type: 'string' }, goals: stringList, nonGoals: stringList, decisions: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['title', 'choice', 'why'], properties: { title: { type: 'string' }, choice: { type: 'string' }, why: { type: 'string' } } } }, risks: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['risk', 'mitigation'], properties: { risk: { type: 'string' }, mitigation: { type: 'string' } } } } } };
-export const SPEC_SCHEMA = { type: 'object', additionalProperties: false, required: ['name', 'requirements'], properties: { name: { type: 'string' }, requirements: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['name', 'text', 'scenarios'], properties: { name: { type: 'string' }, text: { type: 'string' }, scenarios: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['name', 'when', 'then'], properties: { name: { type: 'string' }, when: { type: 'string' }, then: { type: 'string' } } } } } } } } };
+const INVENTORY_SCHEMA = { type: 'object', additionalProperties: false, required: ['greenfield', 'languages', 'frameworks', 'keyFiles', 'tests', 'notes'], properties: { greenfield: { type: 'boolean' }, languages: stringList, frameworks: stringList, keyFiles: stringList, tests: stringList, notes: { type: 'string' } } };
+const PROPOSAL_SCHEMA = { type: 'object', additionalProperties: false, required: ['why', 'whatChanges', 'capabilities', 'impact'], properties: { why: { type: 'string' }, whatChanges: stringList, capabilities: { type: 'object', additionalProperties: false, required: ['new', 'modified'], properties: { new: stringList, modified: stringList } }, impact: stringList } };
+const DESIGN_SCHEMA = { type: 'object', additionalProperties: false, required: ['context', 'goals', 'nonGoals', 'decisions', 'risks'], properties: { context: { type: 'string' }, goals: stringList, nonGoals: stringList, decisions: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['title', 'choice', 'why'], properties: { title: { type: 'string' }, choice: { type: 'string' }, why: { type: 'string' } } } }, risks: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['risk', 'mitigation'], properties: { risk: { type: 'string' }, mitigation: { type: 'string' } } } } } };
+const SPEC_SCHEMA = { type: 'object', additionalProperties: false, required: ['name', 'requirements'], properties: { name: { type: 'string' }, requirements: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['name', 'text', 'scenarios'], properties: { name: { type: 'string' }, text: { type: 'string' }, scenarios: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['name', 'when', 'then'], properties: { name: { type: 'string' }, when: { type: 'string' }, then: { type: 'string' } } } } } } } } };
 /** Names the repository's primary language for the plan, so task file names use its extension (a greenfield repository has none yet). */
 function languageLine(roots) {
     const profile = languageProfile(roots);
     return profile ? `\nPrimary language of the repository: ${profile.primary}${profile.others.length ? ` (also present: ${profile.others.join(', ')})` : ''} — name new source files with its extension.` : '';
 }
-export const TASKS_SCHEMA = { type: 'object', additionalProperties: false, required: ['groups'], properties: { groups: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['title', 'tasks'], properties: { title: { type: 'string' }, tasks: stringList } } }, verification: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['repositoryId', 'command', 'args'], properties: { repositoryId: { type: 'string' }, command: { type: 'string' }, args: stringList } } }, blockingQuestion: { type: 'string' } } };
+const TASKS_SCHEMA = { type: 'object', additionalProperties: false, required: ['groups'], properties: { groups: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['title', 'tasks'], properties: { title: { type: 'string' }, tasks: stringList } } }, verification: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['repositoryId', 'command', 'args'], properties: { repositoryId: { type: 'string' }, command: { type: 'string' }, args: stringList } } }, blockingQuestion: { type: 'string' } } };
 /** True when no repository holds anything but OpenSpec artifacts and repository boilerplate. */
-export function hostGreenfield(roots) {
+function hostGreenfield(roots) {
     return roots.every(root => {
         if (!existsSync(root))
             return true;
@@ -50,12 +50,12 @@ export function hostGreenfield(roots) {
 function slug(value) { return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60); }
 function bullets(items, fallback) { return items.length ? items.map(item => `- ${item}`).join('\n') : `- ${fallback}`; }
 /** Rendered with the exact headings `openspec instructions proposal` returns. */
-export function renderProposal(proposal, capabilityNames) {
+function renderProposal(proposal, capabilityNames) {
     return ['## Why', '', proposal.why, '', '## What Changes', '', bullets(proposal.whatChanges, 'See the requirements in the specs of this change.'), '', '## Capabilities', '', '### New Capabilities',
         ...(capabilityNames.new.length ? capabilityNames.new.map(name => `- \`${name}\`: ${name.replace(/-/g, ' ')}`) : ['- (none)']), '', '### Modified Capabilities',
         ...(capabilityNames.modified.length ? capabilityNames.modified.map(name => `- \`${name}\`: requirements extended by this change`) : ['- (none)']), '', '## Impact', '', bullets(proposal.impact, 'Limited to the repositories in scope.'), ''].join('\n');
 }
-export function renderDesign(design, greenfield) {
+function renderDesign(design, greenfield) {
     return ['## Context', '', ...(greenfield ? ['The repository has no application code; the spec means building it from scratch.', ''] : []), design.context, '', '## Goals / Non-Goals', '', '**Goals:**', bullets(design.goals, 'Deliver the requested work.'), '', '**Non-Goals:**', bullets(design.nonGoals, 'Anything outside the frozen scope.'), '', '## Decisions', '',
         ...(design.decisions.length ? design.decisions.map(item => `- **${item.title}**: ${item.choice} — ${item.why}`) : ['- Follow the existing conventions of the repository.']), '', '## Risks / Trade-offs', '', ...(design.risks.length ? design.risks.map(item => `- [${item.risk}] → ${item.mitigation}`) : ['- [Scope creep] → implement only the listed tasks.']), '', '## Local reference patterns', '', greenfield ? 'No existing implementation to reference: the repository is empty.' : 'See the key files listed in the inventory of this change; no equivalent implementation was verified beyond them.', ''].join('\n');
 }
@@ -368,4 +368,3 @@ export async function runCompactArchitect(env) {
     env.onEvent?.({ kind: 'text', text: `Compact architect: ${specs.length} spec${specs.length === 1 ? '' : 's'}, ${tasks.groups.reduce((total, group) => total + group.tasks.length, 0)} tasks, ${inventoryLoop.toolCalls} inventory tool calls.` });
     return { text: result, usage: env.client.usage, structured };
 }
-//# sourceMappingURL=architect.js.map

package/dist/agent-runtime/compact/chat-client.d.ts

@@ -10,11 +10,11 @@ export type ChatMessage = Record<string, unknown>;
  */
 export declare function ensurePatientDispatcher(): Promise<void>;
 export declare function patientFetchInit(): Pick<RequestInit, 'dispatcher'>;
-export interface ChatCompletion {
+interface ChatCompletion {
     message: Record<string, unknown>;
     finishReason: unknown;
 }
-export interface ChatClientOptions {
+interface ChatClientOptions {
     endpoint: URL;
     headers: Record<string, string>;
     fetch: typeof globalThis.fetch;
@@ -80,4 +80,4 @@ export declare class ChatClient {
  * non-streaming shape: `{ choices: [{ message, finish_reason }], usage }`.
  */
 export declare function readCompletionResponse(response: Response): Promise<unknown>;
-export declare function readBoundedResponse(response: Response): Promise<unknown>;
+export {};

package/dist/agent-runtime/compact/chat-client.js

@@ -281,7 +281,7 @@ export async function readCompletionResponse(response) {
         message.tool_calls = toolCalls;
     return { choices: [{ message, finish_reason: finishReason ?? (toolCalls.length ? 'tool_calls' : 'stop') }], ...(usage ? { usage } : {}) };
 }
-export async function readBoundedResponse(response) {
+async function readBoundedResponse(response) {
     if (!response.body)
         throw new Error('Missing response body');
     const reader = response.body.getReader(), chunks = [];
@@ -304,4 +304,3 @@ export async function readBoundedResponse(response) {
     }
     return JSON.parse(Buffer.concat(chunks).toString('utf8'));
 }
-//# sourceMappingURL=chat-client.js.map

package/dist/agent-runtime/compact/developer.d.ts

@@ -1,50 +1,7 @@
 import type { ChatMessage } from './chat-client.js';
 import { type AgentResult } from '../executor-types.js';
 import { type CompactEnv } from './step.js';
-/** Tool calls one task group may spend before it must report. */
-export declare const DEFAULT_TASK_TOOL_BUDGET = 25;
-export declare const TASK_RESULT_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        summary: {
-            type: string;
-        };
-        files: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        tests: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        verification: {
-            type: string;
-        };
-        incomplete: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    task: {
-                        type: string;
-                    };
-                    reason: {
-                        type: string;
-                    };
-                };
-            };
-        };
-    };
-};
-export interface TaskGroup {
+interface TaskGroup {
     index: number;
     title: string;
     tasks: {
@@ -66,9 +23,7 @@ export declare function namedFiles(task: string): string[];
  * Generic Node/Jest/TS and Python signatures; anything else passes through.
  */
 export declare function diagnoseVerificationFailure(feedback: string, roots: readonly string[]): string[];
-/** Application source/test files under the roots (bounded), excluding plans, deps and dot dirs. */
-export declare function repositoryInventory(roots: readonly string[], limit?: number): string[];
-export interface LanguageProfile {
+interface LanguageProfile {
     primary: string;
     others: string[];
 }
@@ -95,8 +50,6 @@ export declare function duplicateSibling(roots: readonly string[], file: string,
  * adding .tsx is fine).
  */
 export declare function foreignLanguageFile(roots: readonly string[], file: string, languages: LanguageProfile): string | undefined;
-/** Existing test directories (relative, POSIX) among the conventional names, e.g. `tests`, `test`, `__tests__`, `spec`. */
-export declare function existingTestDirs(roots: readonly string[]): string[];
 /**
  * A NEW test file outside the directory the repository already keeps its
  * tests in (`src/hold.test.js` next to an existing `tests/`): the reason to
@@ -112,8 +65,6 @@ export declare function misplacedTestFile(roots: readonly string[], file: string
 export declare function siblingTestFile(roots: readonly string[], file: string): string | undefined;
 /** The absolute path a task-named file resolves to: the exact path, else the same stem in a sibling extension of the same language family. */
 export declare function locateNamedFile(roots: readonly string[], file: string): string | undefined;
-/** Extra tool calls a correction group gets on top of the task budget: it must read AND patch, and the feedback is long. */
-export declare const CORRECTION_BUDGET_BONUS = 10;
 /**
  * Source excerpts around every `file:line` the feedback names (Jest/Babel
  * `path/file.js: … (30:56)`, TS `file.ts(12,3)` / `file.ts:12:3`, mocha
@@ -125,27 +76,8 @@ export declare function feedbackExcerpts(feedback: string, roots: readonly strin
     context?: number;
     maxBytes?: number;
 }): string;
-/** An existing file this long is edited with apply_patch, never regenerated whole (observed: a 1.4k-line test rewritten twice in one group, ~25 minutes of generation). */
-export declare const REWRITE_MAX_LINES = 150;
-/** Above this many lines, `read_file` answers with an outline (head + index of definitions) instead of the whole file. */
-export declare const OUTLINE_MIN_LINES = 400;
-/**
- * A large file as an outline: the first lines (imports, top-level state) and
- * an index of definitions with their line numbers, so the model asks for the
- * range it needs with read_lines instead of putting 15k tokens of test file
- * into the transcript on every read (observed: 4-minute prefills).
- */
-export declare function outlineLargeFile(file: string, content: string): string | undefined;
-/** Files a model writes to narrate its own work; never part of a task, always noise for the reviewer (observed: fix_summary.json, task-summary.json in the repository root). */
-export declare const NARRATION_FILE: RegExp;
 /** Media/binary extensions a text-only tool can never produce correctly. */
 export declare const BINARY_ASSET: RegExp;
-/** Extra write-only calls a task group gets when it spent its whole budget reading. */
-export declare const WRITE_EXTENSION_CALLS = 6;
-/** Tool calls the in-place fix round after a failed group check may spend. */
-export declare const GROUP_FIX_BUDGET = 20;
-/** Test files among `reported` that the repository's own test command (per root) does not execute; empty when no command is detected. */
-export declare function unreachedGroupTests(roots: readonly string[], reported: readonly string[]): string[];
 /** A source file that exists but carries no implementation: a handful of lines, a placeholder import, or only TODOs. */
 export declare function isStubFile(file: string, minLines?: number): boolean;
 /** Ticks the given task ids; every other byte of tasks.md is preserved, as the developer write rule requires. */
@@ -158,3 +90,4 @@ export declare function tickTasks(markdown: string, ids: Set<string>): string;
 export declare function runCompactDeveloper(env: CompactEnv, options?: {
     taskToolBudget?: number;
 }): Promise<AgentResult>;
+export {};

package/dist/agent-runtime/compact/developer.js

@@ -4,16 +4,16 @@ import { unreachedTestFiles, unreachedTestsReason } from './test-reachability.js
 import path from 'node:path';
 import { AgentExecutionError } from '../executor-types.js';
 import { artifactPath } from '../openspec.js';
-import { readVerificationEvidence } from '../../installer/runtime/pipeline-state.js';
+import { readVerificationEvidence } from '../../pipeline/pipeline-state.js';
 import { bounded } from './prompt-inputs.js';
 import { finalJson, on, openspecCall, strings, text, toolStep } from './step.js';
 /** Tool calls one task group may spend before it must report. */
-export const DEFAULT_TASK_TOOL_BUDGET = 25;
+const DEFAULT_TASK_TOOL_BUDGET = 25;
 /** Frozen planning artifacts: the developer edits application code, never the plan. */
 const FROZEN_PATH = /(?:^|[\\/])openspec[\\/]/i;
 const DEVELOPER_TOOLS = ['list_files', 'read_file', 'read_lines', 'search_text', 'get_diff', 'write_file', 'apply_patch'];
 const stringList = { type: 'array', items: { type: 'string' } };
-export const TASK_RESULT_SCHEMA = { type: 'object', additionalProperties: false, required: ['summary', 'files', 'tests', 'verification', 'incomplete'], properties: { summary: { type: 'string' }, files: stringList, tests: stringList, verification: { type: 'string' }, incomplete: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['task', 'reason'], properties: { task: { type: 'string' }, reason: { type: 'string' } } } } } };
+const TASK_RESULT_SCHEMA = { type: 'object', additionalProperties: false, required: ['summary', 'files', 'tests', 'verification', 'incomplete'], properties: { summary: { type: 'string' }, files: stringList, tests: stringList, verification: { type: 'string' }, incomplete: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['task', 'reason'], properties: { task: { type: 'string' }, reason: { type: 'string' } } } } } };
 /** Parses the `## N. Title` / `- [ ] N.M text` layout the OpenSpec tasks template prescribes. */
 export function parseTaskGroups(markdown) {
     const groups = [];
@@ -133,7 +133,7 @@ function findFiles(root, base, depth = 0) {
     return out;
 }
 /** Application source/test files under the roots (bounded), excluding plans, deps and dot dirs. */
-export function repositoryInventory(roots, limit = 60) {
+function repositoryInventory(roots, limit = 60) {
     const out = [];
     const walk = (dir, rel, depth) => {
         if (depth > 6 || out.length >= limit)
@@ -247,7 +247,7 @@ export function foreignLanguageFile(roots, file, languages) {
     return `"${file}" is ${language}, but this repository is ${languages.primary}-only. Write the same behaviour in ${languages.primary} inside the existing modules; do not add a second language.`;
 }
 /** Existing test directories (relative, POSIX) among the conventional names, e.g. `tests`, `test`, `__tests__`, `spec`. */
-export function existingTestDirs(roots) {
+function existingTestDirs(roots) {
     const names = ['tests', 'test', '__tests__', 'spec', 'specs'];
     return [...new Set(roots.flatMap(root => names.filter(name => { try {
             return statSync(path.join(root, name)).isDirectory();
@@ -317,7 +317,7 @@ export function locateNamedFile(roots, file) {
     return undefined;
 }
 /** Extra tool calls a correction group gets on top of the task budget: it must read AND patch, and the feedback is long. */
-export const CORRECTION_BUDGET_BONUS = 10;
+const CORRECTION_BUDGET_BONUS = 10;
 /**
  * Source excerpts around every `file:line` the feedback names (Jest/Babel
  * `path/file.js: … (30:56)`, TS `file.ts(12,3)` / `file.ts:12:3`, mocha
@@ -369,9 +369,9 @@ export function feedbackExcerpts(feedback, roots, options = {}) {
     return chunks.join('\n\n');
 }
 /** An existing file this long is edited with apply_patch, never regenerated whole (observed: a 1.4k-line test rewritten twice in one group, ~25 minutes of generation). */
-export const REWRITE_MAX_LINES = 150;
+const REWRITE_MAX_LINES = 150;
 /** Above this many lines, `read_file` answers with an outline (head + index of definitions) instead of the whole file. */
-export const OUTLINE_MIN_LINES = 400;
+const OUTLINE_MIN_LINES = 400;
 const OUTLINE_HEAD_LINES = 120;
 const DEFINITION_LINE = /^\s*(?:(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*\w+|(?:export\s+)?class\s+\w+|(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|\w+\s*=>)|(?:static\s+|async\s+|get\s+|set\s+)?[A-Za-z_$][\w$]*\s*\([^)]*\)\s*\{|(?:describe|it|test|suite|context)\s*\(|def\s+\w+|func\s+(?:\([^)]*\)\s*)?\w+|(?:pub\s+)?fn\s+\w+)/;
 /**
@@ -380,7 +380,7 @@ const DEFINITION_LINE = /^\s*(?:(?:export\s+)?(?:default\s+)?(?:async\s+)?functi
  * range it needs with read_lines instead of putting 15k tokens of test file
  * into the transcript on every read (observed: 4-minute prefills).
  */
-export function outlineLargeFile(file, content) {
+function outlineLargeFile(file, content) {
     const lines = content.split('\n');
     if (lines.length <= OUTLINE_MIN_LINES)
         return undefined;
@@ -391,13 +391,13 @@ export function outlineLargeFile(file, content) {
     return JSON.stringify({ outline: true, path: file, totalLines: lines.length, head: lines.slice(0, OUTLINE_HEAD_LINES).join('\n'), definitions: index, note: `${file} has ${lines.length} lines; this is its first ${OUTLINE_HEAD_LINES} lines plus an index of definitions. Read only the range you need with read_lines(path, startLine, endLine); do not read the whole file.` });
 }
 /** Files a model writes to narrate its own work; never part of a task, always noise for the reviewer (observed: fix_summary.json, task-summary.json in the repository root). */
-export const NARRATION_FILE = /(?:^|\/)(?:[\w.-]*(?:summary|progress|scratch|handoff)[\w.-]*)\.(?:json|md|txt)$/i;
+const NARRATION_FILE = /(?:^|\/)(?:[\w.-]*(?:summary|progress|scratch|handoff)[\w.-]*)\.(?:json|md|txt)$/i;
 /** Media/binary extensions a text-only tool can never produce correctly. */
 export const BINARY_ASSET = /\.(?:wav|mp3|ogg|flac|m4a|aac|png|jpe?g|gif|webp|bmp|ico|woff2?|ttf|otf|eot|mp4|webm|mov|zip|gz|tar|pdf|wasm)$/i;
 /** Extra write-only calls a task group gets when it spent its whole budget reading. */
-export const WRITE_EXTENSION_CALLS = 6;
+const WRITE_EXTENSION_CALLS = 6;
 /** Tool calls the in-place fix round after a failed group check may spend. */
-export const GROUP_FIX_BUDGET = 20;
+const GROUP_FIX_BUDGET = 20;
 /**
  * One bounded correction round for a group whose check just failed: the exact
  * output plus host-read excerpts around every reported file:line, the group's
@@ -465,7 +465,7 @@ async function fixGroupInPlace(env, group, output, budget, evidence, extraTools,
     return [...new Set(written)];
 }
 /** Test files among `reported` that the repository's own test command (per root) does not execute; empty when no command is detected. */
-export function unreachedGroupTests(roots, reported) {
+function unreachedGroupTests(roots, reported) {
     return roots.flatMap(root => { const check = detectCheckCommand(root); return check ? unreachedTestFiles(root, [check], reported) : []; });
 }
 /** A source file that exists but carries no implementation: a handful of lines, a placeholder import, or only TODOs. */
@@ -820,4 +820,3 @@ export async function runCompactDeveloper(env, options = {}) {
     const structured = { summary: summaries.join('\n'), files: [...files], tests: [...tests], verification: verification.length ? verification.join('; ') : 'none', incomplete };
     return { text: JSON.stringify(structured), usage: env.client.usage, structured };
 }
-//# sourceMappingURL=developer.js.map

package/dist/agent-runtime/compact/environment.d.ts

@@ -1,24 +1,34 @@
 import type { spawnSync } from 'node:child_process';
-export interface EnvironmentInstall {
+interface EnvironmentInstall {
     ecosystem: 'node' | 'python' | 'go' | 'rust';
     root: string;
     command: string;
     args: string[];
 }
-export interface InstallOutcome extends EnvironmentInstall {
+/** `precondition`: the install failed for a reason only the host can repair (see hostPreconditionFailure). */
+interface InstallOutcome extends EnvironmentInstall {
     ok: boolean;
     detail: string;
+    precondition?: string;
 }
 /** True when a verification failure looks like a missing toolchain/dependency rather than a code defect. */
 export declare function isEnvironmentFailure(exitCode: number | null | undefined, output: string): boolean;
+/**
+ * Failures that no edit to the change can repair, because the verification
+ * process itself lacks something only the host can grant: an environment
+ * variable a configuration file references, registry credentials, registry
+ * network access, git credentials for a dependency. Feeding them to a fixer
+ * makes it edit package-manager configuration to route around the missing
+ * secret (observed: `.yarnrc.yml` rewritten, reverted by review, rewritten
+ * again). Returns a short host-facing reason, or undefined.
+ */
+export declare function hostPreconditionFailure(output: string): string | undefined;
 /** Packages a failure output names explicitly (`Try \`npm i --save-dev @types/jest\``); the host installs exactly those. */
 export declare function suggestedPackages(output: string): string[];
 /** Dependencies package.json declares that node_modules does not hold (bounded). */
 export declare function missingNodeDependencies(root: string): string[];
 /** The installs a repository root needs, judged from its manifests and the absence of their install output. */
 export declare function plannedInstalls(root: string, failureOutput?: string): EnvironmentInstall[];
-/** Rewrites an exact, unpublished version in package.json to `^<major>.0.0`; true when something changed. */
-export declare function relaxManifestPin(root: string, name: string, version: string): boolean;
 /** Runs each planned install once, bounded; never throws. */
 export declare function installEnvironment(roots: readonly string[], io?: {
     spawn?: typeof spawnSync;
@@ -37,7 +47,7 @@ export declare function detectCheckCommand(root: string): {
     command: string;
     args: string[];
 } | undefined;
-export interface GroupCheckOutcome {
+interface GroupCheckOutcome {
     ran: boolean;
     ok: boolean;
     command?: string;
@@ -60,3 +70,4 @@ export declare function runGroupCheck(roots: readonly string[], io?: {
         text?: string;
     }) => void;
 }): GroupCheckOutcome;
+export {};

package/dist/agent-runtime/compact/environment.js

@@ -19,6 +19,8 @@ const ENVIRONMENT_SIGNATURES = [
     /jest: not found|vitest: not found|mocha: not found|tsc: not found|pytest: not found/i,
     /TS2582|Do you need to install type definitions|Try `npm i --save-dev @types\//i,
     /Module (?:[\w@./-]+) in the \w+ option was not found|Preset [\w@./-]+ not found|Cannot find module '(?:ts-jest|babel-jest|@swc\/jest|ts-node|tsx)'/i,
+    // Yarn Berry refuses to run scripts in a checkout that was never installed.
+    /doesn't seem to have been installed - running an install there might help|Couldn't find the node_modules state file - running an install might help/i,
 ];
 /** True when a verification failure looks like a missing toolchain/dependency rather than a code defect. */
 export function isEnvironmentFailure(exitCode, output) {
@@ -27,6 +29,33 @@ export function isEnvironmentFailure(exitCode, output) {
     const tail = output.slice(-6000);
     return ENVIRONMENT_SIGNATURES.some(pattern => pattern.test(tail));
 }
+const REGISTRY = String.raw `(?:registry|npmjs\.org|yarnpkg\.com|npm\.pkg\.github\.com|pkgs\.dev\.azure\.com|jfrog|artifactory|nexus|pypi\.org|crates\.io|proxy\.golang\.org)`;
+/**
+ * Failures that no edit to the change can repair, because the verification
+ * process itself lacks something only the host can grant: an environment
+ * variable a configuration file references, registry credentials, registry
+ * network access, git credentials for a dependency. Feeding them to a fixer
+ * makes it edit package-manager configuration to route around the missing
+ * secret (observed: `.yarnrc.yml` rewritten, reverted by review, rewritten
+ * again). Returns a short host-facing reason, or undefined.
+ */
+export function hostPreconditionFailure(output) {
+    const text = output.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, '').slice(-16_000);
+    const variable = /Environment variable not found \(([A-Za-z_][A-Za-z0-9_]*)\)/.exec(text);
+    if (variable)
+        return `the environment variable ${variable[1]} is not available to verification commands, and a package-manager configuration file requires it`;
+    if (/\bYN0041\b/.test(text) || /YN0035[\s\S]{0,400}?Response Code: 40[13]\b/.test(text) || /Response code 40[13] \((?:Unauthorized|Forbidden)\)/i.test(text)
+        || /npm (?:ERR!|error) code (?:E401|E403|ENEEDAUTH)\b/.test(text) || /ERR_PNPM_FETCH_40[13]\b/.test(text)
+        || new RegExp(String.raw `\b40[13] (?:Unauthorized|Forbidden)\b[^\n]{0,80}https?://[^\s]*${REGISTRY}`, 'i').test(text)
+        || /\b(?:401|403) Client Error: (?:Unauthorized|Forbidden) for url/.test(text))
+        return 'the package registry rejected the credentials available to verification commands (HTTP 401/403)';
+    if (/npm (?:ERR!|error) code (?:ENOTFOUND|EAI_AGAIN|ECONNREFUSED|ETIMEDOUT|ECONNRESET)\b/.test(text) || /ERR_PNPM_META_FETCH_FAIL\b/.test(text)
+        || new RegExp(String.raw `\b(?:ENOTFOUND|EAI_AGAIN)\b[^\n]{0,200}${REGISTRY}|${REGISTRY}[^\n]{0,200}\b(?:ENOTFOUND|EAI_AGAIN)\b`, 'i').test(text))
+        return 'the package registry cannot be reached from the verification environment';
+    if (/fatal: could not read (?:Username|Password) for/.test(text) || /Permission denied \(publickey\)/.test(text))
+        return 'git credentials needed to fetch a dependency are not available to verification commands';
+    return undefined;
+}
 /** Packages a failure output names explicitly (`Try \`npm i --save-dev @types/jest\``); the host installs exactly those. */
 export function suggestedPackages(output) {
     const packages = new Set();
@@ -89,7 +118,7 @@ export function plannedInstalls(root, failureOutput = '') {
     return plans;
 }
 /** Rewrites an exact, unpublished version in package.json to `^<major>.0.0`; true when something changed. */
-export function relaxManifestPin(root, name, version) {
+function relaxManifestPin(root, name, version) {
     const file = path.join(root, 'package.json');
     let manifest;
     try {
@@ -155,7 +184,8 @@ export function installEnvironment(roots, io = {}) {
             const ok = result.status === 0;
             const detail = ok ? `installed ${plan.ecosystem} dependencies in ${path.basename(root)}` : `${plan.command} ${plan.args.join(' ')} failed in ${path.basename(root)}: ${String(result.stderr || result.error?.message || `exit ${result.status}`).trim().slice(0, 400)}`;
             io.onEvent?.({ kind: 'text', text: `Environment: ${detail}` });
-            outcomes.push({ ...plan, ok, detail });
+            const precondition = ok ? undefined : hostPreconditionFailure(`${result.stdout ?? ''}\n${result.stderr ?? ''}`);
+            outcomes.push({ ...plan, ok, detail, ...(precondition ? { precondition } : {}) });
         }
     }
     return outcomes;
@@ -210,4 +240,3 @@ export function runGroupCheck(roots, io = {}) {
     }
     return { ran: false, ok: true, output: '' };
 }
-//# sourceMappingURL=environment.js.map

package/dist/agent-runtime/compact/exit-code-honesty.d.ts

@@ -1,4 +1,4 @@
-export interface ExitHonestyFinding {
+interface ExitHonestyFinding {
     command: string;
     failures: number | null;
     sample: string;
@@ -6,3 +6,4 @@ export interface ExitHonestyFinding {
 /** A failure count in a runner summary, or a failure-marker line, despite exit 0. */
 export declare function exitCodeContradiction(exitCode: number | null, output: string): ExitHonestyFinding | null;
 export declare function exitHonestyReason(findings: ReadonlyArray<ExitHonestyFinding>): string;
+export {};

package/dist/agent-runtime/compact/exit-code-honesty.js

@@ -75,4 +75,3 @@ export function exitHonestyReason(findings) {
     const parts = findings.map(item => `\`${item.command}\` exited 0 but its output reports ${item.failures !== null ? `${item.failures} failing test${item.failures === 1 ? '' : 's'}` : 'a failure'} (${JSON.stringify(item.sample)})`);
     return `The verification command passed by exit code while reporting failures: ${parts.join('; ')}. A test runner that does not exit non-zero on failure hides broken tests: make the harness set \`process.exitCode = 1\` (or throw) when any test fails, then fix the failing tests.`;
 }
-//# sourceMappingURL=exit-code-honesty.js.map

package/dist/agent-runtime/compact/guarded-loop.d.ts

@@ -1,11 +1,7 @@
 import { type AgentEvent } from '../executor-types.js';
 import { type ChatClient, type ChatMessage } from './chat-client.js';
 export declare const DEFAULT_CONTEXT_WINDOW_TOKENS = 32768;
-/** Consecutive identical calls answered with an error instead of executing. */
-export declare const REPEAT_WARN_AT = 3;
-/** Total identical calls that abort the step. */
-export declare const REPEAT_ABORT_AT = 5;
-export interface ToolLoopOptions {
+interface ToolLoopOptions {
     client: ChatClient;
     /** Mutated in place: assistant, tool and nudge messages are appended. */
     messages: ChatMessage[];
@@ -34,25 +30,12 @@ export interface ToolLoopOptions {
         extraCalls: number;
     };
 }
-/** Default output budget of one tool turn. A tool turn should emit a tool call or a short reply, so this is a runaway guard, not a ceiling for real work; a connection whose model thinks privately (that counts against `max_tokens`) raises it with `maxOutputTokens`. */
-export declare const TOOL_TURN_MAX_OUTPUT = 8192;
-/**
- * `max_tokens` counts INSIDE the context window (prompt + output ≤ window), so
- * a budget wider than what remains makes llama.cpp refuse the request
- * ("exceeds the available context size") instead of helping. Bound every
- * request to the room actually left; never below a minimal useful reply.
- */
-export declare function boundedOutputBudget(requested: number, contextWindowTokens: number, messages: readonly ChatMessage[]): number;
-/** Consecutive rewrites of one path (no other tool call between them) before the loop refuses the next one. */
-export declare const REWRITE_WARN_AT = 3;
 export interface ToolLoopResult {
     text: string;
     toolCalls: number;
 }
 /** Estimated tokens for the transcript: chars/4, which is what small local servers count against. */
 export declare function estimateTokens(messages: ChatMessage[]): number;
-/** One correct example the model can copy when its arguments were rejected. */
-export declare function toolExample(name: string): string;
 /** Schema-level argument repair: returns the error the model receives instead of executing. */
 export declare function validateToolArguments(name: string, raw: string, available: Set<string>): {
     args: Record<string, unknown>;
@@ -71,3 +54,4 @@ export declare function compactMessages(messages: ChatMessage[], contextWindowTo
  * context compaction against the provider's window.
  */
 export declare function runToolLoop(options: ToolLoopOptions): Promise<ToolLoopResult>;
+export {};

package/dist/agent-runtime/compact/guarded-loop.js

@@ -4,15 +4,15 @@ import { AgentExecutionError } from '../executor-types.js';
 import { record } from './chat-client.js';
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 32_768;
 /** Consecutive identical calls answered with an error instead of executing. */
-export const REPEAT_WARN_AT = 3;
+const REPEAT_WARN_AT = 3;
 /** Total identical calls that abort the step. */
-export const REPEAT_ABORT_AT = 5;
+const REPEAT_ABORT_AT = 5;
 const COMPACTION_RATIO = 0.7;
 const PROTECTED_TAIL = 4;
 const PLACEHOLDER_QUERIES = new Set(['.', '*', '**', '.*', '..', '?', 'query', '<query>']);
 const NUDGE = 'Your reply was empty. Reply with the final result now, as requested; do not call tools.';
 /** Default output budget of one tool turn. A tool turn should emit a tool call or a short reply, so this is a runaway guard, not a ceiling for real work; a connection whose model thinks privately (that counts against `max_tokens`) raises it with `maxOutputTokens`. */
-export const TOOL_TURN_MAX_OUTPUT = 8192;
+const TOOL_TURN_MAX_OUTPUT = 8192;
 /** Headroom kept between the transcript and the context window when bounding an output budget. */
 const OUTPUT_HEADROOM_TOKENS = 512;
 /**
@@ -21,7 +21,7 @@ const OUTPUT_HEADROOM_TOKENS = 512;
  * ("exceeds the available context size") instead of helping. Bound every
  * request to the room actually left; never below a minimal useful reply.
  */
-export function boundedOutputBudget(requested, contextWindowTokens, messages) {
+function boundedOutputBudget(requested, contextWindowTokens, messages) {
     const remaining = contextWindowTokens - estimateTokens(messages) - OUTPUT_HEADROOM_TOKENS;
     return Math.max(256, Math.min(requested, remaining));
 }
@@ -29,7 +29,7 @@ const EFFORT_STEP_DOWN = { high: 'medium', medium: 'low' };
 /** Tools whose result is a pure function of the workspace: safe to answer a repeated call with a pointer to the earlier identical result. */
 const READ_TOOLS = new Set(['read_file', 'read_lines', 'search_text', 'get_diff', 'list_files']);
 /** Consecutive rewrites of one path (no other tool call between them) before the loop refuses the next one. */
-export const REWRITE_WARN_AT = 3;
+const REWRITE_WARN_AT = 3;
 /** Whole-file rewrites only: iterating a file with apply_patch between reads is the normal edit flow. */
 const WRITE_TOOLS = new Set(['write_file']);
 /** The rewrite streak keys on the file NAME: a model alternating `tests/x.test.js` with an invented `repo/tests/x.test.js` (observed, 7 rewrites) is still rewriting one file. */
@@ -58,7 +58,7 @@ export function estimateTokens(messages) {
     return Math.ceil(messages.reduce((total, message) => total + JSON.stringify(message).length, 0) / 4);
 }
 /** One correct example the model can copy when its arguments were rejected. */
-export function toolExample(name) {
+function toolExample(name) {
     switch (name) {
         case 'search_text': return '{"path":".","query":"functionName"}';
         case 'read_lines': return '{"path":"src/index.ts","startLine":1,"endLine":120}';
@@ -235,7 +235,7 @@ export async function runToolLoop(options) {
                 options.onToolCall?.();
                 calls.set(item.id, { name: item.name, args: item.arguments });
                 options.onEvent?.(toolEvent(item.name, item.arguments));
-                const key = item.name + '' + item.arguments.replace(/\s+/g, '');
+                const key = item.name + '\0' + item.arguments.replace(/\s+/g, '');
                 consecutive = key === previous ? consecutive + 1 : 1;
                 previous = key;
                 const total = (totals.get(key) ?? 0) + 1;
@@ -317,4 +317,3 @@ export async function runToolLoop(options) {
     }
     throw new AgentExecutionError(`Agent exhausted ${options.maxTurns} turns without a final result`, 'max_turns', client.usage);
 }
-//# sourceMappingURL=guarded-loop.js.map

package/dist/agent-runtime/compact/prompt-inputs.d.ts

@@ -36,7 +36,5 @@ export interface PromptInputs {
         status: 'added' | 'changed' | 'deleted';
     }>;
 }
-/** Text of one `## Heading` section up to the next heading (or terminator), without the heading line. */
-export declare function section(prompt: string, heading: string): string;
 export declare function bounded(text: string, limit: number): string;
 export declare function extractPromptInputs(prompt: string): PromptInputs;

package/dist/agent-runtime/compact/prompt-inputs.js

@@ -1,7 +1,7 @@
 import { RE_REVIEW_MARKER } from '../prompts.js';
 const STOP = /^(## |Planning policy:|Current frozen acceptance obligations)/;
 /** Text of one `## Heading` section up to the next heading (or terminator), without the heading line. */
-export function section(prompt, heading) {
+function section(prompt, heading) {
     const lines = prompt.split('\n');
     const start = lines.findIndex(line => line.trim() === heading);
     if (start < 0)
@@ -56,4 +56,3 @@ export function extractPromptInputs(prompt) {
         reReviewChanges: parseReReviewChanges(prompt),
     };
 }
-//# sourceMappingURL=prompt-inputs.js.map

package/dist/agent-runtime/compact/reviewer.d.ts

@@ -1,18 +1,5 @@
 import type { AgentResult } from '../executor-types.js';
 import { type CompactEnv } from './step.js';
-/** Tool calls the reviewer may spend inspecting beyond the supplied diff. */
-export declare const DEFAULT_REVIEW_TOOL_BUDGET = 15;
-/** A re-review only opens the changed files. */
-export declare const RE_REVIEW_TOOL_BUDGET = 6;
-/** Working-tree changes of every allowed root against HEAD, plus the content of new files, bounded. `only` restricts the diff and the new-file listing to those repository-relative paths (a re-review reads just what the fixer touched). */
-export declare function collectDiff(roots: string[], only?: readonly string[]): string;
-/** The gate thresholds the host rendered into the reviewer prompt (`score is at least N`, `aspect ≥ N`). */
-export declare function reviewGateThresholds(gate: string): {
-    minScore: number;
-    aspects: Record<string, number>;
-};
-/** Files named by the previous review's issues (`path: what must change` lines under `## Previous review`). */
-export declare function previousIssueFiles(feedback: string): string[];
 /**
  * The compact reviewer: the host supplies the diff and the frozen criteria, the
  * model inspects read-only within a small budget, and the verdict is forced

package/dist/agent-runtime/compact/reviewer.js

@@ -8,14 +8,14 @@ import { hasBinaryAssets } from './architect.js';
 import { bounded } from './prompt-inputs.js';
 import { finalJson, openspecCall, strings, text, toolStep } from './step.js';
 /** Tool calls the reviewer may spend inspecting beyond the supplied diff. */
-export const DEFAULT_REVIEW_TOOL_BUDGET = 15;
+const DEFAULT_REVIEW_TOOL_BUDGET = 15;
 /** A re-review only opens the changed files. */
-export const RE_REVIEW_TOOL_BUDGET = 6;
+const RE_REVIEW_TOOL_BUDGET = 6;
 const DIFF_LIMIT = 40 * 1024;
 const UNTRACKED_LIMIT = 8 * 1024;
 const MAX_UNTRACKED = 12;
 /** Working-tree changes of every allowed root against HEAD, plus the content of new files, bounded. `only` restricts the diff and the new-file listing to those repository-relative paths (a re-review reads just what the fixer touched). */
-export function collectDiff(roots, only) {
+function collectDiff(roots, only) {
     // Pathspec magic stays enabled so openspec/ artifacts are excluded from the reviewed diff.
     const env = { ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.toUpperCase().startsWith('GIT_'))), GIT_OPTIONAL_LOCKS: '0' };
     const options = { encoding: 'utf8', env, windowsHide: true, timeout: 10_000, maxBuffer: 4 * 1024 * 1024 };
@@ -62,7 +62,7 @@ export function collectDiff(roots, only) {
     return sections.join('\n\n');
 }
 /** The gate thresholds the host rendered into the reviewer prompt (`score is at least N`, `aspect ≥ N`). */
-export function reviewGateThresholds(gate) {
+function reviewGateThresholds(gate) {
     const minScore = Number(/score\` is at least (\d+)/.exec(gate)?.[1] ?? 0);
     const aspects = {};
     for (const match of gate.matchAll(/`([a-z_]+)` ≥ (\d+)/g))
@@ -70,7 +70,7 @@ export function reviewGateThresholds(gate) {
     return { minScore, aspects };
 }
 /** Files named by the previous review's issues (`path: what must change` lines under `## Previous review`). */
-export function previousIssueFiles(feedback) {
+function previousIssueFiles(feedback) {
     const section = feedback.split('## Previous review')[1] ?? '';
     return [...new Set([...section.matchAll(/(?:^|[\s-])((?:[\w.-]+\/)*[\w.-]+\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|swift|cs|rb|php|c|cc|cpp|h|hpp|vue|svelte|html|css|scss|json|ya?ml|md))(?=[\s:,;)]|$)/g)].map(match => match[1].replace(/\\/g, '/')))];
 }
@@ -175,4 +175,3 @@ export async function runCompactReviewer(env, options = {}) {
     };
     return { text: JSON.stringify(structured), usage: env.client.usage, structured };
 }
-//# sourceMappingURL=reviewer.js.map