specrails-core 5.5.1 → 6.0.0

package/dist/agent-runtime/cli.js

@@ -5,8 +5,8 @@ import { rolePromptDefaults } from './prompts.js';
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { parseArgs } from '../installer/cli.js';
-import { readVerificationEvidence, inspectPipeline, pipelineStateDirectory, validatePipelineContext } from '../installer/runtime/pipeline-state.js';
+import { parseArgs } from '../shared/args.js';
+import { readVerificationEvidence, inspectPipeline, pipelineStateDirectory, validatePipelineContext } from '../pipeline/pipeline-state.js';
 import { normalizeRuntimeConfig, validateRuntimeConfig } from './config.js';
 import { CORE_PACKAGE_VERSION, CORE_WORKFLOW_VERSION, RUNTIME_API_VERSION, coreRuntimeIdentity, preflightCoreWorkflow, runCoreWorkflow } from './core-host.js';
 import { sameRuntimeIdentity } from './runtime-identity.js';
@@ -14,6 +14,7 @@ import { readWorkflowState } from './workflow.js';
 import { runtimeEfficiency } from './efficiency.js';
 import { configuredCapabilities } from './capabilities.js';
 import { createExecutorRegistry } from './executors.js';
+import { runRecovery } from './recovery.js';
 function read(file) { return JSON.parse(readFileSync(file, 'utf8')); }
 async function readStdin() {
     const chunks = [];
@@ -35,6 +36,12 @@ export function compactState(state) {
         runId: state.runId, traceId: state.traceId, status: state.status, nextStep: state.nextStep, updatedAt: state.updatedAt,
         error: state.error, pendingApproval: state.pendingApproval, pendingQuestion: state.pendingQuestion, usage: state.usage,
         steps: Object.fromEntries(Object.entries(state.steps).map(([id, step]) => [id, { status: step.status, visits: step.visits }])),
+        // Bounded failure history helps hosts distinguish repeated blockers from a
+        // resumable checkpoint without shipping transcripts or invoking a provider.
+        recentFailures: state.history.filter(attempt => attempt.status === 'failed' || attempt.status === 'interrupted').slice(-8).map(attempt => ({
+            stepId: attempt.stepId, status: attempt.status, attempt: attempt.attempt, visit: attempt.visit,
+            at: attempt.completedAt ?? attempt.startedAt, error: attempt.error?.slice(-6000),
+        })),
         metrics: runtimeEfficiency(state),
     };
 }
@@ -81,7 +88,7 @@ function invocationUsage(state, priorCount) {
     return { costUsd: sum('costUsd'), inputTokens: sum('inputTokens'), outputTokens: sum('outputTokens') };
 }
 export async function runRuntimeCommand(flags, positionals, emit = value => process.stdout.write(JSON.stringify(value) + '\n')) {
-    const command = positionals[0] ?? 'help';
+    const command = flags.help === true ? 'help' : positionals[0] ?? 'help';
     if (command === 'prompts') {
         emit({ type: 'runtime-role-prompts', defaults: rolePromptDefaults() });
         return 0;
@@ -114,11 +121,12 @@ export async function runRuntimeCommand(flags, positionals, emit = value => proc
                 'specrails-core runtime run --context <json> --config <json> --change <kebab-case>',
                 'specrails-core runtime status --context <json> [--compact]',
                 'specrails-core runtime resume --context <json> [--approve archive] [--answer <text>] [--recover developer] [--invalidate verify]',
+                'specrails-core runtime recovery --context <json> --stdin',
             ] });
         return 0;
     }
     if (command === 'api') {
-        emit({ type: 'runtime-api', apiVersion: RUNTIME_API_VERSION, coreVersion: CORE_PACKAGE_VERSION, runtimeIdentity: coreRuntimeIdentity(), workflowVersions: [CORE_WORKFLOW_VERSION], capabilities: { efficientRoleExecution: 1, reproducibleVerification: 1, implementationEfficiencyMetrics: 1, compactAgentLoop: 1, configurableGuardrails: 1, compactOutputBudget: 1, roleThinkingControl: 1 }, guardrails: GUARDRAIL_CATALOG });
+        emit({ type: 'runtime-api', apiVersion: RUNTIME_API_VERSION, coreVersion: CORE_PACKAGE_VERSION, runtimeIdentity: coreRuntimeIdentity(), workflowVersions: [CORE_WORKFLOW_VERSION], capabilities: { scopedRecovery: 1, efficientRoleExecution: 1, reproducibleVerification: 1, implementationEfficiencyMetrics: 1, compactAgentLoop: 1, configurableGuardrails: 1, compactOutputBudget: 1, roleThinkingControl: 1 }, guardrails: GUARDRAIL_CATALOG });
         return 0;
     }
     if (command === 'validate') {
@@ -136,6 +144,25 @@ export async function runRuntimeCommand(flags, positionals, emit = value => proc
         emit(readVerificationEvidence(context, query));
         return 0;
     }
+    if (command === 'recovery') {
+        if (flags.stdin !== true || Object.keys(flags).some(key => !['context', 'stdin'].includes(key)))
+            throw new Error('Recovery requires --context and --stdin only');
+        const context = validatePipelineContext(read(stringFlag(flags, 'context')));
+        const request = read(path.join(pipelineStateDirectory(context), 'agent-runtime-request.json'));
+        if (!request.runtimeIdentity || !sameRuntimeIdentity(request.runtimeIdentity, coreRuntimeIdentity()))
+            throw new Error('Recovery requires the retained original runtime identity; do not replace or migrate the saved run');
+        const controller = new AbortController(), abort = () => controller.abort();
+        process.on('SIGINT', abort);
+        process.on('SIGTERM', abort);
+        try {
+            emit({ type: 'runtime-recovery', schemaVersion: 1, runId: context.runId, result: await runRecovery(context, await readStdin(), controller.signal) });
+            return 0;
+        }
+        finally {
+            process.off('SIGINT', abort);
+            process.off('SIGTERM', abort);
+        }
+    }
     if (!['run', 'status', 'resume'].includes(command))
         throw new Error('Unknown runtime operation: ' + command);
     const context = validatePipelineContext(read(stringFlag(flags, 'context')));
@@ -214,4 +241,3 @@ if (process.argv[1] && existsSync(process.argv[1]) && import.meta.url === pathTo
         process.exitCode = 1;
     }
 }
-//# sourceMappingURL=cli.js.map

package/dist/agent-runtime/codex-schema.js

@@ -28,4 +28,3 @@ export function restoreOptionalFields(value, schema) {
     return Object.fromEntries(Object.entries(value).filter(([key, item]) => !(key in properties && item === null && !required.has(key)))
         .map(([key, item]) => [key, properties[key] ? restoreOptionalFields(item, properties[key]) : item]));
 }
-//# sourceMappingURL=codex-schema.js.map

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

@@ -2,38 +2,7 @@ import type { AgentResult } from '../executor-types.js';
 import { type CompactEnv } from './step.js';
 /** The load-bearing tokens of a criterion: identifiers (`createGame`, `applyInput`, `tick`), numbers and hyphenated terms — never prose words. */
 export declare function criterionTokens(text: string): string[];
-export interface Inventory {
-    greenfield: boolean;
-    languages: string[];
-    frameworks: string[];
-    keyFiles: string[];
-    tests: string[];
-    notes: string;
-}
-export interface Proposal {
-    why: string;
-    whatChanges: string[];
-    capabilities: {
-        new: string[];
-        modified: string[];
-    };
-    impact: string[];
-}
-export interface Design {
-    context: string;
-    goals: string[];
-    nonGoals: string[];
-    decisions: {
-        title: string;
-        choice: string;
-        why: string;
-    }[];
-    risks: {
-        risk: string;
-        mitigation: string;
-    }[];
-}
-export interface Spec {
+interface Spec {
     name: string;
     requirements: {
         name: string;
@@ -45,7 +14,7 @@ export interface Spec {
         }[];
     }[];
 }
-export interface Tasks {
+interface Tasks {
     groups: {
         title: string;
         tasks: string[];
@@ -57,245 +26,6 @@ export interface Tasks {
     }[];
     blockingQuestion?: string;
 }
-export declare const INVENTORY_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        greenfield: {
-            type: string;
-        };
-        languages: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        frameworks: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        keyFiles: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        tests: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        notes: {
-            type: string;
-        };
-    };
-};
-export declare const PROPOSAL_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        why: {
-            type: string;
-        };
-        whatChanges: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        capabilities: {
-            type: string;
-            additionalProperties: boolean;
-            required: string[];
-            properties: {
-                new: {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                };
-                modified: {
-                    type: string;
-                    items: {
-                        type: string;
-                    };
-                };
-            };
-        };
-        impact: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-    };
-};
-export declare const DESIGN_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        context: {
-            type: string;
-        };
-        goals: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        nonGoals: {
-            type: string;
-            items: {
-                type: string;
-            };
-        };
-        decisions: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    title: {
-                        type: string;
-                    };
-                    choice: {
-                        type: string;
-                    };
-                    why: {
-                        type: string;
-                    };
-                };
-            };
-        };
-        risks: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    risk: {
-                        type: string;
-                    };
-                    mitigation: {
-                        type: string;
-                    };
-                };
-            };
-        };
-    };
-};
-export declare const SPEC_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        name: {
-            type: string;
-        };
-        requirements: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    name: {
-                        type: string;
-                    };
-                    text: {
-                        type: string;
-                    };
-                    scenarios: {
-                        type: string;
-                        items: {
-                            type: string;
-                            additionalProperties: boolean;
-                            required: string[];
-                            properties: {
-                                name: {
-                                    type: string;
-                                };
-                                when: {
-                                    type: string;
-                                };
-                                then: {
-                                    type: string;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    };
-};
-export declare const TASKS_SCHEMA: {
-    type: string;
-    additionalProperties: boolean;
-    required: string[];
-    properties: {
-        groups: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    title: {
-                        type: string;
-                    };
-                    tasks: {
-                        type: string;
-                        items: {
-                            type: string;
-                        };
-                    };
-                };
-            };
-        };
-        verification: {
-            type: string;
-            items: {
-                type: string;
-                additionalProperties: boolean;
-                required: string[];
-                properties: {
-                    repositoryId: {
-                        type: string;
-                    };
-                    command: {
-                        type: string;
-                    };
-                    args: {
-                        type: string;
-                        items: {
-                            type: string;
-                        };
-                    };
-                };
-            };
-        };
-        blockingQuestion: {
-            type: string;
-        };
-    };
-};
-/** True when no repository holds anything but OpenSpec artifacts and repository boilerplate. */
-export declare function hostGreenfield(roots: string[]): boolean;
-/** Rendered with the exact headings `openspec instructions proposal` returns. */
-export declare function renderProposal(proposal: Proposal, capabilityNames: {
-    new: string[];
-    modified: string[];
-}): string;
-export declare function renderDesign(design: Design, greenfield: boolean): string;
 /** True when any media/font file exists under the roots (bounded walk, dot/dependency dirs skipped). */
 export declare function hasBinaryAssets(roots: readonly string[], limit?: number): boolean;
 /**
@@ -347,3 +77,4 @@ export declare function normalizeTasksForTest(raw: Record<string, unknown>, repo
  * the graph's participation and completeness checks pass unchanged.
  */
 export declare function runCompactArchitect(env: CompactEnv): Promise<AgentResult>;
+export {};

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 {};