specrails-core 5.5.1 → 6.0.0

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

@@ -2,7 +2,7 @@ import { guardrailEnabled } from '../guardrails.js';
 import { addDeveloperChecks, bindPlan, expandedPlanCommands, initializeVerificationPlan, readVerificationPlan, validateProposedChecks } from '../verification-plan.js';
 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, 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';
@@ -425,4 +425,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,4 @@
-import type { VerificationCommand } from '../../installer/runtime/pipeline-state.js';
+import type { VerificationCommand } from '../../pipeline/pipeline-state.js';
 export type DesignConfidence = 'high' | 'medium' | 'low';
 export interface ArchitectureRecord {
     planningDepth?: 'focused' | 'full';

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

@@ -21,4 +21,3 @@ export const CoreState = Annotation.Root({
 });
 /** 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,4 +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,5 +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';
-//# sourceMappingURL=index.js.map
+export { readVerificationEvidence } from '../pipeline/pipeline-state.js';
+export { runRecovery, recoveryRequestSchema } from './recovery.js';

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;

package/dist/agent-runtime/openspec.js

@@ -36,10 +36,6 @@ function readProgress(context) {
         return { notice: PROGRESS_NOTICE + ' Saved progress is unavailable or invalid; inspect the current diff and tasks before continuing.', record: null };
     }
 }
-export function renderProgressHandoff(context) {
-    const saved = readProgress(context);
-    return saved.record ? `\n## Saved implementation progress\n${saved.notice}\n${JSON.stringify(saved.record)}\n` : saved.notice.includes('unavailable') ? '\n' + saved.notice + '\n' : '';
-}
 function writeProgress(context, input) {
     if (context.role !== 'developer')
         throw new Error('Only the developer may write implementation progress');
@@ -78,7 +74,8 @@ export async function runOpenSpec(cli, root, args, signal) {
     }
     catch (error) {
         const result = error;
-        throw new Error(`OpenSpec ${args[0]} failed (${result.status ?? 'process error'}): ${String(result.stderr || result.stdout || '').slice(-6000)}`);
+        const detail = [result.stdout, result.stderr].filter(Boolean).join('\n').slice(-6000);
+        throw new Error(`OpenSpec ${args[0]} failed (${result.status ?? result.code ?? 'process error'}): ${detail}`);
     }
 }
 /** Reject symlink traversal even when the final destination does not exist. */
@@ -300,7 +297,7 @@ export class OpenSpecTools {
         return apply;
     }
 }
-export const OPENSPEC_BRIDGE_ENTRY = fileURLToPath(new URL('./openspec-tool-server.js', import.meta.url));
+const OPENSPEC_BRIDGE_ENTRY = fileURLToPath(new URL('./openspec-tool-server.js', import.meta.url));
 export const OPENSPEC_TOOL_ACTIONS = ['load_skill', 'new', 'status', 'instructions', 'validate', 'write_artifact', 'read_progress', 'write_progress'];
 export const OPENSPEC_TOOL_DEFINITION = { type: 'function', function: { name: 'openspec_workflow', description: 'Run the official OpenSpec role workflow. Load the skill first (developer/reviewer also receive real status, apply context and saved progress), then use its CLI instructions and write artifacts within the fixed change. Developer may save a bounded advisory handoff with write_progress; read_progress refreshes it. Progress never substitutes for verification.', parameters: { type: 'object', additionalProperties: false, required: ['action'], properties: { action: { type: 'string', enum: OPENSPEC_TOOL_ACTIONS }, artifact: { type: 'string' }, path: { type: 'string' }, content: { type: 'string' }, progress: {
                     type: 'object', additionalProperties: false, required: ['summary', 'completedTasks', 'nextTasks', 'checks', 'blockers'], properties: {
@@ -326,4 +323,3 @@ export function openSpecRepairPrompt(context) {
     return `The previous ${context.role} result cannot be accepted because you omitted the required official OpenSpec workflow. Do not merely resend the JSON. Continue this same role with the work already available. Load ${ROLE_SKILLS[context.role]} using the scoped workflow tool (action=load_skill), consult status and instructions ${context.role === 'architect' ? 'tasks' : 'apply'}, and execute the complete returned skill procedure against the current artifacts and code. Reconcile your previous conclusions with that procedure; correct your report if necessary. Do not rerun the implementation or the host verification commands. ${context.role === 'reviewer' ? 'Stay read-only; do not modify code or artifacts.' : 'Keep already-correct work and respect the same frozen scope.'} Finish with the originally requested JSON report.
 `;
 }
-//# sourceMappingURL=openspec.js.map

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

@@ -1,5 +1,5 @@
 import type { AgentRole } from './executor-types.js';
-import type { PipelineContext, VerificationCommand } from '../installer/runtime/pipeline-state.js';
+import type { PipelineContext, VerificationCommand } from '../pipeline/pipeline-state.js';
 import { type ReviewPolicy } from './graph/review-policy.js';
 import type { DeveloperRecord } from './graph/state.js';
 /** Bump whenever the wording changes: the version is part of the frozen run identity. */
@@ -15,7 +15,7 @@ export interface FrozenCriterion {
     requirement: string;
 }
 /** Roles with an editable definition: the three pipeline agents plus the FIXER stance the developer role takes on a correction round. */
-export type PromptRole = AgentRole | 'fixer';
+type PromptRole = AgentRole | 'fixer';
 export interface RoleInstructionOptions {
     definition?: string;
     /** `fixer`: the developer invocation is a correction round on the fixer stance (own definition, no plan dump). */
@@ -39,7 +39,7 @@ export declare const DEVELOPER_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const REVIEW_OUTPUT_SCHEMA: Record<string, unknown>;
 /** Actual editable task definitions; dynamic scope and output contracts are assembled separately. */
 export declare function rolePromptDefaults(): Record<PromptRole, string>;
-export interface ReReviewContext {
+interface ReReviewContext {
     changes: Array<{
         repositoryId: string;
         path: string;
@@ -61,3 +61,4 @@ export declare function correctionInstructions(role: AgentRole, feedback: RoleFe
 export declare function deepenInstructions(question: string | undefined): string;
 /** Asks a structured role to resend a malformed reply without repeating its work. */
 export declare function repairInstructions(role: AgentRole, problem: string): string;
+export {};

package/dist/agent-runtime/prompts.js

@@ -357,4 +357,3 @@ export function deepenInstructions(question) {
 export function repairInstructions(role, problem) {
     return `Your previous reply could not be used: ${problem}\n\nDo not redo the ${role} work. Reply again with exactly one JSON object matching the output contract, with no prose before or after it and no Markdown fence.\n`;
 }
-//# sourceMappingURL=prompts.js.map

package/dist/agent-runtime/provider-diagnostic.js

@@ -1,4 +1,4 @@
-import { redactRuntimeText } from '../installer/runtime/pipeline-state.js';
+import { redactRuntimeText } from '../pipeline/pipeline-state.js';
 import { stripVTControlCharacters } from 'node:util';
 /** Keep provider errors visible without dumping full output, prompts or credentials. */
 export function providerDiagnostic(stdout, stderr, env = process.env) {
@@ -22,4 +22,3 @@ export function providerDiagnostic(stdout, stderr, env = process.env) {
     message = stripVTControlCharacters(message);
     return redactRuntimeText(message, env).replace(/\s+/g, ' ').slice(0, 1200).trim();
 }
-//# sourceMappingURL=provider-diagnostic.js.map

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const recoveryRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"inspect">;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"history">;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    path: z.ZodString;
+    action: z.ZodLiteral<"list_files">;
+}, z.core.$strict>, z.ZodObject<{
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    repositoryId: z.ZodString;
+    path: z.ZodString;
+    action: z.ZodLiteral<"read_file">;
+}, z.core.$strict>, z.ZodObject<{
+    repositoryId: z.ZodString;
+    path: z.ZodString;
+    action: z.ZodLiteral<"diff">;
+}, z.core.$strict>, z.ZodObject<{
+    expectedHash: z.ZodString;
+    oldText: z.ZodString;
+    newText: z.ZodString;
+    operationId: z.ZodString;
+    reason: z.ZodString;
+    acknowledgeInterrupted: z.ZodOptional<z.ZodBoolean>;
+    changedPrecondition: z.ZodOptional<z.ZodString>;
+    repositoryId: z.ZodString;
+    path: z.ZodString;
+    action: z.ZodLiteral<"patch">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        openspec: "openspec";
+        verification: "verification";
+    }>;
+    checkId: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodString;
+    reason: z.ZodString;
+    acknowledgeInterrupted: z.ZodOptional<z.ZodBoolean>;
+    changedPrecondition: z.ZodOptional<z.ZodString>;
+    action: z.ZodLiteral<"check">;
+}, z.core.$strict>], "action">;
+export type RecoveryRequest = z.infer<typeof recoveryRequestSchema>;
+/** Uses the SAME cross-process lease as resume. No provider calls or checkpoint editing. */
+export declare function runRecovery(contextInput: unknown, input: unknown, signal?: AbortSignal): Promise<unknown>;

package/dist/agent-runtime/recovery.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { acquireWorkflowLease, fingerprint, readWorkflowState } from './durable-store.js';
+import { WorkspaceTools } from './workspace-tools.js';
+import { artifactPath, hash, resolveOpenSpecCli, runOpenSpec } from './openspec.js';
+import { write } from './graph/artifacts.js';
+import { expandedPlanCommands, readVerificationPlan } from './verification-plan.js';
+import { inspectPipeline, pipelineStateDirectory, validatePipelineContext, verifyPipeline } from '../pipeline/pipeline-state.js';
+const file = { repositoryId: z.string().min(1).max(128), path: z.string().min(1).max(1024) };
+const operation = { operationId: z.string().uuid(), reason: z.string().trim().min(1).max(2000), acknowledgeInterrupted: z.boolean().optional(), changedPrecondition: z.string().trim().min(1).max(2000).optional() };
+export const recoveryRequestSchema = z.discriminatedUnion('action', [
+    z.object({ action: z.literal('inspect') }).strict(),
+    z.object({ action: z.literal('history'), offset: z.number().int().nonnegative().optional() }).strict(),
+    z.object({ action: z.literal('list_files'), ...file }).strict(),
+    z.object({ action: z.literal('read_file'), ...file, startLine: z.number().int().positive().optional(), endLine: z.number().int().positive().optional() }).strict(),
+    z.object({ action: z.literal('diff'), ...file }).strict(),
+    z.object({ action: z.literal('patch'), ...file, ...operation, expectedHash: z.string().regex(/^[a-f0-9]{64}$/), oldText: z.string().min(1).max(16_384), newText: z.string().max(16_384) }).strict(),
+    z.object({ action: z.literal('check'), ...operation, kind: z.enum(['openspec', 'verification']), checkId: z.string().min(1).max(256).optional() }).strict(),
+]);
+/** Recovery never accepts absolute paths or aliases for control/secret files. */
+function safePath(raw, mutation) {
+    const parts = raw.split('/');
+    if (raw !== '.' && (path.isAbsolute(raw) || raw.includes('\\') || raw.includes(':') || parts.some(p => !p || p === '.' || p === '..' || /[\x00-\x1f]/.test(p) || /[. ]$/.test(p) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(p))))
+        throw new Error('Recovery needs a repository-relative path without traversal or platform aliases');
+    const lower = parts.map(p => p.toLowerCase());
+    if (lower.some(p => ['.git', '.specrails', '.claude', '.codex', '.gemini', '.kimi-code', '.agents', '.ssh', '.aws', 'node_modules'].includes(p) || /^\.env(?:\.|$)/.test(p)))
+        throw new Error('Recovery cannot access runtime metadata, dependencies or secret files');
+    if (mutation && (lower[0] === 'openspec' && lower[1] !== 'specs' || lower.some(p => ['agents.md', 'claude.md', 'gemini.md'].includes(p))))
+        throw new Error('Recovery cannot change frozen plans, archives or agent instructions');
+    return raw;
+}
+/** Uses the SAME cross-process lease as resume. No provider calls or checkpoint editing. */
+export async function runRecovery(contextInput, input, signal) {
+    const context = validatePipelineContext(contextInput), request = recoveryRequestSchema.parse(input);
+    const directory = pipelineStateDirectory(context), workflowDirectory = path.join(directory, 'agent-workflow');
+    if (!await readWorkflowState(workflowDirectory, context.runId))
+        throw new Error('Recovery requires an existing saved run');
+    const release = await acquireWorkflowLease(workflowDirectory, context.runId);
+    try {
+        const state = (await readWorkflowState(workflowDirectory, context.runId));
+        const inspection = inspectPipeline(context); // verifies the frozen scope against the journal
+        const historyPath = artifactPath(directory, 'recovery-history.json');
+        const history = existsSync(historyPath) ? JSON.parse(readFileSync(historyPath, 'utf8')) : [];
+        if (!Array.isArray(history) || history.length > 100)
+            throw new Error('Invalid recovery history');
+        const plan = readVerificationPlan(context);
+        if (request.action === 'history') {
+            const offset = request.offset ?? 0, ordered = [...history].reverse();
+            return { attempts: ordered.slice(offset, offset + 20), total: history.length, ...(offset + 20 < history.length ? { nextOffset: offset + 20 } : {}) };
+        }
+        if (request.action === 'inspect')
+            return {
+                runId: context.runId, status: state.status, nextStep: state.nextStep, repositories: context.repositories,
+                verification: { valid: inspection.verification.valid, reasons: inspection.verification.reasons },
+                checks: plan?.entries.map(entry => ({ id: entry.id, label: entry.label, repositoryId: entry.command.repositoryId, command: entry.command.command, args: entry.command.args, cwd: entry.command.cwd })) ?? [],
+                attempts: history.slice(-10),
+            };
+        let workspace;
+        if ('repositoryId' in request) {
+            const repository = context.repositories.find(repo => repo.id === request.repositoryId);
+            if (!repository)
+                throw new Error('Repository does not belong to this run');
+            safePath(request.path, request.action === 'patch');
+            const target = path.join(repository.path, request.path);
+            if (existsSync(target))
+                safePath(path.relative(repository.path, realpathSync(target)).split(path.sep).join('/') || '.', request.action === 'patch');
+            workspace = new WorkspaceTools(repository.path, [repository.path], 'developer');
+        }
+        if (request.action === 'read_file')
+            return JSON.parse(workspace.execute('read_lines', { path: request.path, ...(request.startLine ? { startLine: request.startLine } : {}), ...(request.endLine ? { endLine: request.endLine } : {}) }));
+        if (request.action === 'diff')
+            return JSON.parse(workspace.execute('get_diff', { path: request.path }));
+        if (request.action === 'list_files') {
+            const result = JSON.parse(workspace.execute('list_files', { path: request.path }));
+            result.entries = result.entries.filter(entry => { try {
+                safePath(request.path === '.' ? entry.name : request.path + '/' + entry.name, false);
+                return true;
+            }
+            catch {
+                return false;
+            } });
+            return result;
+        }
+        if (state.status === 'succeeded' || inspection.phases.archive.status === 'done')
+            throw new Error('Completed or archived runs cannot be repaired; inspect their delivery instead');
+        if ((state.status === 'running' || Object.values(state.steps).some(step => ['running', 'interrupted'].includes(step.status))) && !request.acknowledgeInterrupted)
+            throw new Error('Inspect interrupted writes and explicitly acknowledge them before repairing');
+        if (request.action === 'check' && (request.kind === 'verification' ? !request.checkId : request.checkId !== undefined))
+            throw new Error('Verification requires a saved checkId; OpenSpec validation does not accept one');
+        const save = () => write(historyPath, JSON.stringify(history, null, 2) + '\n');
+        const requestHash = fingerprint(request);
+        const previous = history.find(attempt => attempt.operationId === request.operationId);
+        if (previous) {
+            if (previous.requestHash !== requestHash)
+                throw new Error('operationId was already used for a different request');
+            if (previous.status === 'pending') {
+                // Crash after atomic file publication but before recording completion.
+                if (request.action === 'patch') {
+                    const current = JSON.parse(workspace.execute('read_lines', { path: request.path, endLine: 1 }));
+                    previous.status = current.hash === previous.afterHash ? 'applied' : 'interrupted';
+                }
+                else
+                    previous.status = 'interrupted';
+                previous.completedAt = new Date().toISOString();
+                save();
+            }
+            return { ...previous, replayed: true, notice: 'Recorded outcome; inspect current files/evidence before continuing.' };
+        }
+        if (history.length >= 100)
+            throw new Error('Recovery attempt limit reached; inspect the history before continuing manually');
+        const checkId = request.action === 'check' ? request.checkId ?? 'openspec' : undefined;
+        const lastCheck = history.filter(attempt => attempt.action === 'check' && attempt.checkId === checkId && attempt.candidateHash === inspection.candidateHash).at(-1);
+        if (request.action === 'check' && lastCheck && ['failed', 'interrupted', 'pending'].includes(lastCheck.status) && !request.changedPrecondition)
+            throw new Error('This check already failed or was interrupted on this candidate; state the changed precondition before retrying');
+        const attempt = { operationId: request.operationId, requestHash, action: request.action, reason: request.reason,
+            startedAt: new Date().toISOString(), status: 'pending', candidateHash: inspection.candidateHash,
+            ...(checkId ? { checkId } : {}), ...(request.changedPrecondition ? { changedPrecondition: request.changedPrecondition } : {}),
+        };
+        if (request.action === 'patch') {
+            const before = workspace.execute('read_file', { path: request.path });
+            if (hash(before) !== request.expectedHash)
+                throw new Error('File changed since inspection; read it again before patching');
+            const at = before.indexOf(request.oldText);
+            if (at < 0 || before.indexOf(request.oldText, at + 1) >= 0 || request.oldText === request.newText)
+                throw new Error('Patch requires exactly one matching fragment and an actual change');
+            const after = before.slice(0, at) + request.newText + before.slice(at + request.oldText.length);
+            Object.assign(attempt, { repositoryId: request.repositoryId, path: request.path, beforeHash: request.expectedHash, afterHash: hash(after) });
+        }
+        history.push(attempt);
+        save(); // write-ahead record: an uncertain attempt is never blindly replayed
+        try {
+            signal?.throwIfAborted();
+            if (request.action === 'patch') {
+                workspace.execute('apply_patch', { path: request.path, expectedHash: request.expectedHash, oldText: request.oldText, newText: request.newText });
+                attempt.status = 'applied';
+            }
+            else if (request.kind === 'openspec') {
+                const output = await runOpenSpec(resolveOpenSpecCli(), context.artifactRoot, ['validate', '--all', '--strict', '--no-interactive', '--json'], signal);
+                attempt.output = output.slice(-16_000);
+                const report = JSON.parse(output);
+                if (!report.items?.length || report.items.some(item => item.valid !== true) || report.summary?.totals?.failed !== 0)
+                    throw new Error('OpenSpec did not report successful validation of any specs/changes; inspect the saved output');
+                attempt.status = 'passed';
+            }
+            else {
+                if (!plan)
+                    throw new Error('No saved verification plan is available');
+                const command = expandedPlanCommands(context, plan).find(item => item.key === request.checkId);
+                if (!command)
+                    throw new Error('checkId does not belong to the saved verification plan');
+                const receipt = await verifyPipeline(context, { kind: 'scoped', planHash: plan.planHash, commands: [command] }, text => { attempt.output = ((attempt.output ?? '') + text).slice(-16_000); }, signal, { deadline: Date.now() + 45_000 });
+                attempt.status = receipt.valid ? 'passed' : 'failed';
+                if (!receipt.valid)
+                    attempt.error = receipt.reason ?? 'Verification failed';
+            }
+        }
+        catch (error) {
+            attempt.status = 'failed';
+            attempt.error = (error instanceof Error ? error.message : String(error)).slice(-6000);
+        }
+        attempt.completedAt = new Date().toISOString();
+        save();
+        return { ...attempt, notice: 'A repair/check is not workflow completion. Resume revalidates all required gates in the original run.' };
+    }
+    finally {
+        await release();
+    }
+}

package/dist/agent-runtime/repository-context.d.ts

@@ -1,4 +1,4 @@
-import type { PipelineContext } from '../installer/runtime/pipeline-state.js';
+import type { PipelineContext } from '../pipeline/pipeline-state.js';
 /** Small, provider-independent map of facts from the admitted checkout. Never
  * follows a documentation link out of scope or invents verification commands. */
 export interface RepositoryContextEntry {

package/dist/agent-runtime/repository-context.js

@@ -124,4 +124,3 @@ export function renderRepositoryContext(current, previous) {
     ].join('\n\n');
 }
 export function repositoryContext(context) { return renderRepositoryContext(repositoryContextSnapshot(context)); }
-//# sourceMappingURL=repository-context.js.map

package/dist/agent-runtime/review-context.d.ts

@@ -1,4 +1,4 @@
-import type { CandidateManifest } from '../installer/runtime/pipeline-state.js';
+import type { CandidateManifest } from '../pipeline/pipeline-state.js';
 export interface ReviewManifest extends CandidateManifest {
     truncated: boolean;
 }

package/dist/agent-runtime/review-context.js

@@ -38,4 +38,3 @@ export function reviewChanges(previous, current) {
     const transversal = changes.some(change => TRANSVERSAL.test(change.path));
     return { mode: transversal ? 'full' : 'incremental', reason: transversal ? 'A shared contract, build, dependency or security input changed' : 'Changes since the previous reviewed candidate', changes };
 }
-//# sourceMappingURL=review-context.js.map

package/dist/agent-runtime/role-routing.js

@@ -27,4 +27,3 @@ export function selectRoleRoute(role, selected, kind, checkpoint, previous) {
             ...(selected.escalation.effort === undefined ? {} : { effort: selected.escalation.effort }),
         } };
 }
-//# sourceMappingURL=role-routing.js.map

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

@@ -21,4 +21,3 @@ export function writeRoleState(directory, data) {
         throw new Error('Role execution state exceeds its size limit');
     write(path.join(directory, 'role-execution.json'), content);
 }
-//# sourceMappingURL=role-state.js.map