stable-harness 0.0.37 → 0.0.39

package/node_modules/@stable-harness/core/dist/runtime/policy/tool-invocation.d.ts

@@ -0,0 +1,45 @@
+import type { RuntimeEvent, RuntimeRequest, WorkspaceAgent } from "../../types.js";
+export type ToolRepeatState = {
+    successfulCalls: Map<string, string>;
+    duplicateCallCounts: Map<string, number>;
+    latestSuccessfulOutputByTool: Map<string, string>;
+    successfulToolCounts: Map<string, number>;
+    toolCallCounts: Map<string, number>;
+    maxDuplicateCallsPerTool?: number;
+    maxCallsPerTool?: number;
+    maxSuccessfulCallsPerTool?: number;
+    maxCallsByTool: Map<string, number>;
+    maxSuccessfulCallsByTool: Map<string, number>;
+    returnPreviousOutputOnRepeatLimit: boolean;
+};
+export type ToolRepeatDecision = {
+    eventOutput: string;
+    modelOutput: string;
+};
+export declare function createToolRepeatState(config: unknown): ToolRepeatState | undefined;
+export declare function beforeToolInvoke(toolId: string, args: unknown, state: ToolRepeatState): ToolRepeatDecision | undefined;
+export declare function afterToolInvoke(input: {
+    toolId: string;
+    args: unknown;
+    output: string;
+    successful: boolean;
+    state: ToolRepeatState;
+}): {
+    eventOutput?: string;
+    modelOutput?: string;
+};
+export declare function isToolRepeatLimitReached(toolId: string, state: ToolRepeatState | undefined): boolean;
+export declare function missingRequiredPlanContent(input: {
+    agent: WorkspaceAgent;
+    events: RuntimeEvent[];
+    toolId: string;
+}): string;
+export declare function missingToolDependencyContent(input: {
+    agent: WorkspaceAgent;
+    events: RuntimeEvent[];
+    toolId: string;
+}): string;
+export declare function toolInvocationEvents(input: {
+    request: RuntimeRequest;
+    getEvents?: () => RuntimeEvent[];
+}): RuntimeEvent[];

package/node_modules/@stable-harness/core/dist/runtime/policy/tool-invocation.js

@@ -0,0 +1 @@
+export function createToolRepeatState(e){if(function repeatGuardEnabled(e){return!0===repeatGuardConfig(e).enabled}(e))return{successfulCalls:new Map,duplicateCallCounts:new Map,latestSuccessfulOutputByTool:new Map,successfulToolCounts:new Map,toolCallCounts:new Map,maxDuplicateCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxDuplicateCallsPerTool)??3,maxCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxCallsPerTool),maxSuccessfulCallsPerTool:readPositiveInteger(repeatGuardConfig(e).maxSuccessfulCallsPerTool),maxCallsByTool:readPositiveIntegerMap(repeatGuardConfig(e).maxCallsByTool),maxSuccessfulCallsByTool:readPositiveIntegerMap(repeatGuardConfig(e).maxSuccessfulCallsByTool),returnPreviousOutputOnRepeatLimit:!0===repeatGuardConfig(e).returnPreviousOutputOnRepeatLimit}}export function beforeToolInvoke(e,t,o){const n=o.toolCallCounts.get(e)??0;o.toolCallCounts.set(e,n+1);const r=o.maxCallsByTool.get(e)??o.maxCallsPerTool;if(void 0!==r&&n>=r){const t=o.latestSuccessfulOutputByTool.get(e),n=repeatedToolCallLimitContent(e,t);return{eventOutput:n,modelOutput:repeatLimitModelOutput(n,t,o)}}const l=o.maxSuccessfulCallsByTool.get(e)??o.maxSuccessfulCallsPerTool;if(void 0!==l&&(o.successfulToolCounts.get(e)??0)>=l){const t=o.latestSuccessfulOutputByTool.get(e),n=repeatedToolCallLimitContent(e,t);return{eventOutput:n,modelOutput:repeatLimitModelOutput(n,t,o)}}const a=stableToolCallKey(e,t),s=o.successfulCalls.get(a);if(void 0!==s){const t=o.duplicateCallCounts.get(a)??0;if(o.duplicateCallCounts.set(a,t+1),void 0!==o.maxDuplicateCallsPerTool&&t>=o.maxDuplicateCallsPerTool){const t=repeatedToolCallLimitContent(e);return{eventOutput:t,modelOutput:t}}const n=function duplicateToolCallContent(e,t){return JSON.stringify({status:"duplicate_tool_call",toolId:e,instruction:"This agent already completed an equivalent tool call. Use the prior evidence instead of calling the tool again.",previousOutput:t})}(e,s);return{eventOutput:n,modelOutput:s}}}export function afterToolInvoke(e){return e.successful?(e.state.successfulCalls.set(stableToolCallKey(e.toolId,e.args),e.output),e.state.latestSuccessfulOutputByTool.set(e.toolId,e.output),e.state.successfulToolCounts.set(e.toolId,(e.state.successfulToolCounts.get(e.toolId)??0)+1),{}):{}}export function isToolRepeatLimitReached(e,t){if(!t)return!1;const o=t.maxCallsByTool.get(e)??t.maxCallsPerTool;if(void 0!==o&&(t.toolCallCounts.get(e)??0)>=o)return!0;const n=t.maxSuccessfulCallsByTool.get(e)??t.maxSuccessfulCallsPerTool;return void 0!==n&&(t.successfulToolCounts.get(e)??0)>=n}export function missingRequiredPlanContent(e){const t=readRecord(e.agent.config.executionContract);if(!0!==t.requiresPlan)return"";const o=readStringArray(t.planEvidenceTools);if(0===o.length||o.includes(e.toolId))return"";const n=new Set(e.events.flatMap(readEvidenceToolId));return o.some(e=>n.has(e))?"":["Status: plan_required",`Evidence tool: ${e.toolId}`,`Blocker: execution contract requires a planning checkpoint from one of: ${o.join(", ")} before evidence tools run.`,"Instruction: call the planning tool first, then retry this atomic evidence tool with repaired arguments."].join("\n")}export function missingToolDependencyContent(e){const t=readRecord(e.agent.config.executionContract),o=readStringArray(readRecord(t.toolDependencies)[e.toolId]);if(0===o.length)return"";const n=new Set(e.events.flatMap(readEvidenceToolId)),r=o.filter(e=>!n.has(e));return 0===r.length?"":["Status: dependency_required",`Evidence tool: ${e.toolId}`,`Blocker: this atomic evidence tool requires completed dependency evidence from: ${r.join(", ")}.`,"Instruction: complete the dependency tool first, evaluate it, then retry this atomic evidence tool."].join("\n")}export function toolInvocationEvents(e){const t=e.getEvents?.();return t??[]}function repeatGuardConfig(e){const t=readRecord(e);return readRecord(t.repeatGuard)}function readPositiveInteger(e){return"number"==typeof e&&Number.isInteger(e)&&e>0?e:void 0}function readPositiveIntegerMap(e){const t=readRecord(e);return new Map(Object.entries(t).map(([e,t])=>[e,readPositiveInteger(t)]).filter(e=>void 0!==e[1]))}function repeatLimitModelOutput(e,t,o){return o.returnPreviousOutputOnRepeatLimit&&void 0!==t&&0!==t.trim().length?t:e}function repeatedToolCallLimitContent(e,t){return JSON.stringify({status:"repeated_tool_call_limit",toolId:e,instruction:"This tool reached the configured repeat limit for this request. Do not call this tool or a substitute tool for the same evidence need again. Use previousOutput and the collected evidence to produce the final answer now, or report the remaining gap explicitly.",...void 0!==t?{previousOutput:t}:{}})}function stableToolCallKey(e,t){return`${e}:${stableJson(t)}`}function stableJson(e){return Array.isArray(e)?`[${e.map(stableJson).join(",")}]`:isRecord(e)?`{${Object.keys(e).sort().map(t=>`${JSON.stringify(t)}:${stableJson(e[t])}`).join(",")}}`:JSON.stringify(e)}function readEvidenceToolId(e){return"runtime.tool.direct.completed"===e.type?[e.toolId]:"runtime.adapter.event"===e.type&&isRecord(e.event)?"agent.tool.result"!==e.event.phase||"string"!=typeof e.event.toolId?[]:function isSuccessfulEvidenceEvent(e){const t=function readString(e){return"string"==typeof e&&e.length>0?e:void 0}(e.controlStatus)??function readOutputStatus(e){if("string"!=typeof e)return;const t=function parseJsonRecord(e){try{const t=JSON.parse(e);return isRecord(t)?t:void 0}catch{return}}(e);return"string"==typeof t?.status?t.status:e.match(/^Status:\s*([A-Za-z0-9_-]+)/imu)?.[1]}(e.output);return!t||/^(?:completed|success|ok|recorded)$/iu.test(t)}(e.event)?[e.event.toolId]:[]:[]}function readRecord(e){return isRecord(e)?e:{}}function readStringArray(e){return Array.isArray(e)?e.filter(e=>"string"==typeof e&&e.length>0):[]}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}

package/node_modules/@stable-harness/core/dist/runtime/progress-narration.d.ts

@@ -0,0 +1,38 @@
+import type { RuntimeEvent } from "./events.js";
+import type { RuntimeCapabilityModule } from "./capabilities.js";
+export type RuntimeProgressNarrationProvider = {
+    name: string;
+    narrate(event: RuntimeEvent, context: RuntimeProgressNarrationContext): RuntimeProgressNarrationResult;
+};
+export type RuntimeProgressNarrationResult = RuntimeProgressNarrationOutput | undefined | Promise<RuntimeProgressNarrationOutput | undefined>;
+export type RuntimeProgressNarrationContext = {
+    style?: string;
+    model?: string;
+};
+export type RuntimeProgressNarrationOutput = {
+    message: string;
+    sourceEventTypes?: string[];
+    sourceEventIds?: string[];
+    model?: string;
+    style?: string;
+};
+export type RuntimeProgressNarrationOptions = {
+    enabled?: boolean;
+    style?: string;
+    model?: string;
+    provider?: RuntimeProgressNarrationProvider;
+};
+export declare function resolveProgressNarrator(input: {
+    options?: RuntimeProgressNarrationOptions | false;
+    policy?: Record<string, unknown>;
+}): RuntimeProgressNarrationProvider | undefined;
+export declare function createProgressNarrationEvent(input: {
+    source: RuntimeEvent;
+    narrator: RuntimeProgressNarrationProvider | undefined;
+    options?: RuntimeProgressNarrationOptions | false;
+    policy?: Record<string, unknown>;
+}): RuntimeEvent | Promise<RuntimeEvent | undefined> | undefined;
+export declare function createProgressNarrationCapability(input: {
+    options?: RuntimeProgressNarrationOptions | false;
+    policy?: Record<string, unknown>;
+}): RuntimeCapabilityModule | undefined;

package/node_modules/@stable-harness/core/dist/runtime/progress-narration.js

@@ -0,0 +1 @@
+export function resolveProgressNarrator(e){if(!1===e.options)return;const t=readProgressPolicy(e.policy);return e.options?.enabled??t.enabled?e.options?.provider??function createTemplateProgressNarrator(){const e=new Map,t=new Map;return{name:"template",narrate(r,n){var o;"runtime.request.started"===r.type&&(e.set(r.requestId,{language:(o=r.input??"",/\p{Script=Han}/u.test(o)?"zh":void 0),input:r.input}),t.delete(r.requestId));const i=function templateMessage(e,t){const r="zh"===t?.language;return"runtime.request.started"===e.type?r?`我开始处理这个请求：${summarizeText(e.input)}`:`I'm starting on this request: ${summarizeText(e.input)}`:"runtime.request.completed"===e.type?r?"我已经完成执行链，正在交付最终结果。":"I've finished the execution chain and am returning the final result.":"runtime.request.failed"===e.type?r?"执行链失败了，我会保留具体错误方便定位。":"The execution chain failed; I'm keeping the concrete error visible for diagnosis.":"runtime.request.cancelled"===e.type?r?"这个请求已取消，后续执行会停止。":"The request was cancelled, so the remaining execution will stop.":"runtime.tool.direct.started"===e.type?r?`我正在运行 ${e.toolId}。`:`I'm running ${e.toolId}.`:"runtime.tool.direct.completed"===e.type?r?`${e.toolId} 已返回结果，我会继续使用这份证据。`:`${e.toolId} returned; I'll keep using that evidence.`:"runtime.workflow.started"===e.type?r?`我正在启动 workflow ${e.workflowId}。`:`I'm starting workflow ${e.workflowId}.`:"runtime.workflow.completed"===e.type?r?`workflow ${e.workflowId} 已完成。`:`Workflow ${e.workflowId} is complete.`:"runtime.specDriven.phase.started"===e.type?r?`我正在进入 spec-driven 阶段 ${e.phaseId}。`:`I'm starting spec-driven phase ${e.phaseId}.`:"runtime.specDriven.phase.blocked"===e.type?r?`spec-driven 阶段 ${e.phaseId} 被 gate 阻塞。`:`Spec-driven phase ${e.phaseId} is blocked by a gate.`:"runtime.specDriven.phase.completed"===e.type?r?`spec-driven 阶段 ${e.phaseId} 已完成。`:`Spec-driven phase ${e.phaseId} is complete.`:"runtime.specDriven.phase.verified"===e.type?r?`spec-driven 阶段 ${e.phaseId} 已验证。`:`Spec-driven phase ${e.phaseId} is verified.`:"runtime.artifact.created"===e.type?r?"我已经保存一份运行产物。":"I've saved a runtime artifact.":"runtime.execution.contract.failed"===e.type?r?"运行证据没有满足执行契约，我会进入恢复或失败路径。":"The run evidence did not satisfy the execution contract, so I'll recover or fail explicitly.":"runtime.inventory.repair"===e.type?inventoryRepairMessage(e.status,e.diagnostic.layer,r):"runtime.skill.candidate.created"===e.type?r?`我发现一个可沉淀的 skill 候选：${e.name}。`:`I found a reusable skill candidate: ${e.name}.`:e.type.startsWith("runtime.memory.")?function memoryMessage(e,t){return"runtime.memory.lifecycle"===e.type?t?`我进入记忆阶段：${e.hook}。`:`I'm in the memory lifecycle phase: ${e.hook}.`:"runtime.memory.recall.completed"===e.type?t?`我召回了 ${e.recordIds.length} 条相关记忆。`:`I recalled ${e.recordIds.length} relevant memory records.`:"runtime.memory.candidate.submitted"===e.type?t?"我提交了一条候选记忆。":"I submitted a memory candidate.":"runtime.memory.approval.requested"===e.type?t?"我提交了记忆审批请求。":"I requested memory approval.":"runtime.memory.plugin.started"===e.type?t?`我正在运行记忆插件 ${e.provider}。`:`I'm running memory plugin ${e.provider}.`:"runtime.memory.plugin.completed"===e.type?t?`记忆插件 ${e.provider} 已完成。`:`Memory plugin ${e.provider} completed.`:"runtime.memory.plugin.failed"===e.type?t?`记忆插件 ${e.provider} 失败了；主任务会继续，不把它当成执行结果。`:`Memory plugin ${e.provider} failed; the main task will continue without treating it as the result.`:"runtime.memory.maintenance.started"===e.type?t?`我正在维护 ${e.target} 记忆。`:`I'm maintaining ${e.target} memory.`:"runtime.memory.maintenance.completed"===e.type?t?`${e.target} 记忆维护完成。`:`${e.target} memory maintenance completed.`:"runtime.memory.maintenance.failed"===e.type?t?`${e.target} 记忆维护失败。`:`${e.target} memory maintenance failed.`:void 0}(e,r):"runtime.adapter.event"===e.type?function adapterMessage(e,t){if(isRecord(e)){if("agent.handoff"===e.phase)return t?"我把请求交给上游 agent backend，让它负责规划和执行。":"I'm handing the request to the upstream agent backend for planning and execution.";if("agent.tool.start"===e.phase&&"string"==typeof e.toolId)return function toolStartMessage(e,t,r){if("task"===e){const e=function readTaskTarget(e){const t=isRecord(e)?e:{};return readString(t.subagent_type)??readString(t.subagentType)}(t),n=function readDescription(e){const t=isRecord(e)?e:{};return summarizeText(readString(t.description)??readString(t.task))}(t);if(e&&n)return r?`我正在请求 task 工具委派给 ${e}：${n}`:`I'm asking the task tool to delegate to ${e}: ${n}`;if(e)return r?`我正在请求 task 工具委派给 ${e}。`:`I'm asking the task tool to delegate to ${e}.`}return r?`我正在运行 ${e} 收集证据。`:`I'm running ${e} to gather evidence.`}(e.toolId,e.args,t);if("agent.tool.result"===e.phase&&"string"==typeof e.toolId)return function toolResultMessage(e,t,r,n,o){if(r)return o?`${e} 返回错误：${summarizeText(String(r))}`:`${e} returned an error: ${summarizeText(String(r))}`;const i="string"==typeof n?n:function readToolControlStatus(e){const t=function parseToolOutputRecord(e){if(isRecord(e))return e;if("string"==typeof e)try{const t=JSON.parse(e);return isRecord(t)?t:void 0}catch{return}}(e);return"string"==typeof t?.status?t.status:"string"==typeof t?.error?t.error:"string"==typeof e&&e.startsWith("Task delegation target is not in the workspace inventory")?"task_inventory_blocked":void 0}(t);if(i)return function toolControlMessage(e,t,r){return"duplicate_tool_call"===t?r?`${e} 重复调用已复用已有证据。`:`${e} repeated an equivalent call, so the existing evidence was reused.`:"repeated_tool_call_limit"===t?r?`${e} 出现重复调用循环，我会基于已有证据继续收敛。`:`${e} entered a repeated-call loop, so I'll continue from the evidence already collected.`:"tool_argument_error"===t||"tool_argument_validation_failed"===t?r?`${e} 参数被工具 schema 拒绝，我会让 agent 修正参数或改用合适工具。`:`${e} arguments were rejected by the tool schema; I'll have the agent repair them or choose a suitable tool.`:"task_inventory_blocked"===t?r?"task 委派目标不在当前 workspace inventory 中，已被运行时策略阻止。":"The task delegation target is not in the current workspace inventory and was blocked by runtime policy.":r?`${e} 返回运行时控制状态：${t}。`:`${e} returned runtime control status: ${t}.`}(e,i,o);if("task"===e)return o?"委派任务已返回结果，我会基于这些证据继续推进。":"The delegated task returned; I'll keep going with that evidence.";const a=function summarizeToolOutput(e){if("string"==typeof e)return summarizeText(e);if(isRecord(e)){if("string"==typeof e.status)return summarizeText(e.status);if("string"==typeof e.summary)return summarizeText(e.summary)}}(t);return o?`${e} 已返回${a?`：${a}`:"，我会继续判断下一步。"}`:`${e} returned${a?`: ${a}`:"; I'll decide the next step from here."}`}(e.toolId,e.output,e.error,e.controlStatus,t);if("agent.langgraph.invoke"===e.phase)return t?"我正在调用 workflow backend。":"I'm invoking the workflow backend.";if("agent.node.completed"===e.phase&&"string"==typeof e.nodeId)return t?`节点 ${e.nodeId} 已完成。`:`Node ${e.nodeId} is complete.`;if("inventory.repair"===e.phase&&"string"==typeof e.status){const r=isRecord(e.diagnostic)?e.diagnostic:{};return inventoryRepairMessage(e.status,readString(r.layer)??"selection",t)}}}(e.event,r):void 0}(r,e.get(r.requestId));if(i&&i!==t.get(r.requestId))return t.set(r.requestId,i),"runtime.request.failed"!==r.type&&"runtime.request.cancelled"!==r.type||(e.delete(r.requestId),t.delete(r.requestId)),function pruneRequestState(e,t){for(;e.size>200;){const r=e.keys().next().value;if(!r)break;e.delete(r),t.delete(r)}}(e,t),{message:i,style:n.style,model:n.model}}}}():void 0}export function createProgressNarrationEvent(e){if(!e.narrator||"runtime.progress.narration"===e.source.type)return;const t=readProgressPolicy(e.policy),r=!1===e.options?void 0:e.options,n=e.narrator.narrate(e.source,{style:r?.style??t.style,model:r?.model??t.model});return function isPromiseLike(e){return isRecord(e)&&"function"==typeof e.then}(n)?n.then(t=>toNarrationEvent(e.source,e.narrator,t)):toNarrationEvent(e.source,e.narrator,n)}export function createProgressNarrationCapability(e){const t=resolveProgressNarrator(e);if(t)return{id:"runtime.progress.narration",onEvent(r,n){try{const o=createProgressNarrationEvent({source:r,narrator:t,options:e.options,policy:e.policy});!function isRuntimeEventPromise(e){return isRecord(e)&&"function"==typeof e.then}(o)?o&&n(o):o.then(e=>{e&&n(e)}).catch(()=>{})}catch{return}}}}function toNarrationEvent(e,t,r){if(r?.message.trim())return{type:"runtime.progress.narration",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agentId,message:r.message,provider:t.name,sourceEventTypes:r.sourceEventTypes??[e.type],sourceEventIds:r.sourceEventIds,model:r.model,style:r.style}}function inventoryRepairMessage(e,t,r){return"repaired"===e?r?`${t} 选择已按 workspace inventory 修正。`:`${t} selection was repaired against the workspace inventory.`:r?`${t} 选择不在 workspace inventory 中，已被阻止。`:`${t} selection was blocked because it is outside the workspace inventory.`}function summarizeText(e){const t=e?.replace(/\s+/gu," ").trim();return t?t.length>120?`${t.slice(0,117)}...`:t:""}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}function readProgressPolicy(e){const t=isRecord(e?.progress)?e.progress:{},r=isRecord(t.narration)?t.narration:{};return{enabled:"boolean"==typeof r.enabled?r.enabled:void 0,style:"string"==typeof r.style?r.style:void 0,model:"string"==typeof r.model?r.model:void 0}}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}

package/node_modules/@stable-harness/core/dist/runtime/selection-repair.d.ts

@@ -0,0 +1,24 @@
+import type { CallCandidate, CallSelectionDiagnostics } from "@botbotgo/better-call";
+import type { RuntimeEvent, RuntimeInventoryRepairDiagnostic, RuntimeInventoryRepairLayer } from "./events.js";
+export type RuntimeSelectionRepairResult = {
+    ok: true;
+    id: string;
+    diagnostics?: CallSelectionDiagnostics;
+} | {
+    ok: false;
+    reason: string;
+    diagnostics?: CallSelectionDiagnostics;
+};
+export type RuntimeSelectionRepairTrace = {
+    layer: RuntimeInventoryRepairLayer;
+    owner: RuntimeInventoryRepairDiagnostic["owner"];
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    emit: (event: RuntimeEvent) => void;
+};
+export declare function repairRuntimeSelection(input: {
+    id: string;
+    candidates: CallCandidate[];
+    trace?: RuntimeSelectionRepairTrace;
+}): Promise<RuntimeSelectionRepairResult>;

package/node_modules/@stable-harness/core/dist/runtime/selection-repair.js

@@ -0,0 +1 @@
+import{repairCallSelection as e}from"@botbotgo/better-call";export async function repairRuntimeSelection(i){const a=await e({rawIntent:i.id,candidates:i.candidates,mode:"repair"});return a.ok?(emitSelectionRepair(i,"repaired",a.candidateId,a.diagnostics),{ok:!0,id:a.candidateId,diagnostics:a.diagnostics}):(emitSelectionRepair(i,"blocked",void 0,a.diagnostics,a.reason),{ok:!1,reason:a.reason,diagnostics:a.diagnostics})}function emitSelectionRepair(e,i,a,t,n){const d=e.trace;d&&d.emit({type:"runtime.inventory.repair",requestId:d.requestId,sessionId:d.sessionId,agentId:d.agentId,status:i,diagnostic:{layer:d.layer,owner:d.owner,originalId:t?.originalId??e.id,repairedId:t?.repairedId??a,candidateIds:e.candidates.map(e=>e.id),reason:n,matchSource:t?.matchSource,confidence:t?.confidence}})}

package/node_modules/@stable-harness/core/dist/runtime/tool-failure.d.ts

@@ -0,0 +1,41 @@
+import type { RuntimeEvent } from "./events.js";
+export type RuntimeToolFailureKind = "transient" | "business" | "control" | "unknown";
+export type RuntimeToolFailureReason = "timeout" | "network" | "rate_limit" | "server_error" | "invalid_input" | "not_found" | "permission_denied" | "approval_required" | "schema_repair_failed" | "repeat_limit" | "tool_execution_failed" | "unknown";
+export type RuntimeToolFailureClassification = {
+    kind: RuntimeToolFailureKind;
+    reason: RuntimeToolFailureReason;
+    retryable: boolean;
+    message: string;
+};
+export type RuntimeToolFailurePolicy = {
+    enabled?: boolean;
+    circuitBreaker?: {
+        enabled?: boolean;
+        failureThreshold?: number;
+    };
+};
+export type RuntimeToolFailureTracker = {
+    isCircuitOpen(toolId: string): boolean;
+    recordFailure(toolId: string): boolean;
+    recordSuccess(toolId: string): void;
+};
+export declare function createToolFailureTracker(policy: RuntimeToolFailurePolicy | undefined): RuntimeToolFailureTracker;
+export declare function classifyToolFailure(error: unknown): RuntimeToolFailureClassification;
+export declare function toolFailureEvent(input: {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    error: unknown;
+}): Extract<RuntimeEvent, {
+    type: "runtime.tool.failure";
+}>;
+export declare function toolCircuitOpenEvent(input: {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    reason: RuntimeToolFailureReason;
+}): Extract<RuntimeEvent, {
+    type: "runtime.tool.circuit.opened";
+}>;

package/node_modules/@stable-harness/core/dist/runtime/tool-failure.js

@@ -0,0 +1 @@
+export function createToolFailureTracker(e){const t=function readCircuitThreshold(e){const t=e?.circuitBreaker,i=t?.failureThreshold;return!1!==e?.enabled&&!0===t?.enabled&&"number"==typeof i&&Number.isInteger(i)&&i>0?i:void 0}(e),i=new Map,r=new Set;return{isCircuitOpen:e=>r.has(e),recordFailure(e){if(void 0===t)return!1;const n=(i.get(e)??0)+1;return i.set(e,n),n>=t&&(r.add(e),!0)},recordSuccess(e){i.delete(e),r.delete(e)}}}export function classifyToolFailure(e){const t=function formatToolFailureMessage(e){return e instanceof Error?e.message:String(e)}(e),i=t.toLowerCase();return/\b(timeout|timed out|etimedout)\b/u.test(i)?classification("transient","timeout",!0,t):/\b(econnreset|econnrefused|enotfound|network|fetch failed)\b/u.test(i)?classification("transient","network",!0,t):/\b(rate.?limit|too many requests|429)\b/u.test(i)?classification("transient","rate_limit",!0,t):/\b(500|502|503|504|server error|bad gateway)\b/u.test(i)?classification("transient","server_error",!0,t):/\b(approval_required|requires approval|permission denied|forbidden|401|403)\b/u.test(i)?classification("business",i.includes("approval")?"approval_required":"permission_denied",!1,t):/\b(schema repair failed|tool_argument_validation_failed|invalid input|expected .* received|validation)\b/u.test(i)?classification("control",i.includes("schema repair")?"schema_repair_failed":"invalid_input",!1,t):/\b(repeated_tool_call_limit|repeat limit)\b/u.test(i)?classification("control","repeat_limit",!1,t):/\b(not found|404)\b/u.test(i)?classification("business","not_found",!1,t):classification("unknown","tool_execution_failed",!1,t)}export function toolFailureEvent(e){const t=classifyToolFailure(e.error);return{type:"runtime.tool.failure",...e,failure:t}}export function toolCircuitOpenEvent(e){return{type:"runtime.tool.circuit.opened",...e}}function classification(e,t,i,r){return{kind:e,reason:t,retryable:i,message:r}}

package/node_modules/@stable-harness/core/dist/runtime/tool-gateway.d.ts

@@ -0,0 +1,59 @@
+export type RuntimeToolCallRequest = {
+    toolId: string;
+    args?: unknown;
+};
+export type RuntimeToolGatewayContext = {
+    workspaceRoot: string;
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    requestInput?: string;
+    observedEvidence?: string;
+    approvalIds?: string[];
+    sandbox?: RuntimeSandboxDecision;
+};
+export type RuntimeSandboxDecision = {
+    action: "allow" | "deny";
+    profile?: string;
+    reason?: string;
+    policyId?: string;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeSandboxPolicyInput = {
+    toolId: string;
+    args?: unknown;
+    context: RuntimeToolGatewayContext;
+};
+export type RuntimeSandboxPolicy = {
+    decide(input: RuntimeSandboxPolicyInput): Promise<RuntimeSandboxDecision> | RuntimeSandboxDecision;
+};
+export type RuntimeToolGatewayTool = {
+    id: string;
+    description?: string;
+    schema?: unknown;
+};
+export type RuntimeToolRepairModel = {
+    invoke(input: unknown): Promise<unknown> | unknown;
+};
+export type RuntimeToolGateway = {
+    get(toolId: string): RuntimeToolGatewayTool | undefined;
+    repairToolCall?(request: {
+        toolId: string;
+        args?: unknown;
+        allowedToolIds?: string[];
+        repairModel?: RuntimeToolRepairModel;
+        context: RuntimeToolGatewayContext;
+    }): Promise<{
+        toolId: string;
+        args: unknown;
+    } | undefined>;
+    invoke(request: {
+        toolId: string;
+        args?: unknown;
+        repairModel?: RuntimeToolRepairModel;
+        context: RuntimeToolGatewayContext;
+    }): Promise<{
+        toolId: string;
+        output: unknown;
+    }>;
+};

package/node_modules/@stable-harness/core/dist/runtime/tool-gateway.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@stable-harness/core/dist/runtime/types.d.ts

@@ -0,0 +1,191 @@
+import type { MemoryCandidate } from "@stable-harness/memory";
+import type { RuntimeWorkflowRequest } from "../workflows/index.js";
+import type { RuntimeEvent } from "./events.js";
+import type { RuntimeToolCallRequest } from "./tool-gateway.js";
+export type RuntimeRecordState = "queued" | "running" | "completed" | "failed" | "cancelled";
+export type RuntimeOutput = {
+    text: string;
+    metadata?: Record<string, unknown>;
+    artifacts?: RuntimeOutputArtifact[];
+};
+export type RuntimeArtifact = {
+    id: string;
+    kind: string;
+    uri?: string;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeOutputArtifact = RuntimeArtifact & {
+    content?: unknown;
+    contentType?: string;
+};
+export type RuntimeArtifactRecord = RuntimeArtifact & {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    createdAt: string;
+    contentType?: string;
+    size?: number;
+};
+export type RuntimeArtifactInput = RuntimeArtifact & {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    content?: unknown;
+    contentType?: string;
+    createdAt?: string;
+};
+export type RuntimeArtifactStore = {
+    createArtifact(input: RuntimeArtifactInput): RuntimeArtifactRecord;
+    listArtifacts(filter?: RuntimeArtifactFilter): RuntimeArtifactRecord[];
+    readArtifact(id: string): unknown;
+};
+export type RuntimeArtifactFilter = {
+    requestId?: string;
+    sessionId?: string;
+    agentId?: string;
+};
+export type RuntimeReplayBundle = {
+    schemaVersion: 1;
+    kind: "stable-harness.replay-bundle";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    createdAt: string;
+    run: RuntimeRunRecord;
+    events: RuntimeEvent[];
+    artifacts: RuntimeArtifactRecord[];
+    integrity: RuntimeReplayBundleIntegrity;
+};
+export type RuntimeReplayBundleIntegrity = {
+    algorithm: "sha256";
+    runHash: string;
+    eventsHash: string;
+    artifactsHash: string;
+    bundleHash: string;
+};
+export type RuntimeRequest = {
+    input: string;
+    agentId?: string;
+    sessionId?: string;
+    requestId?: string;
+    parentRunId?: string;
+    toolCall?: RuntimeToolCallRequest;
+    workflow?: RuntimeWorkflowRequest;
+    memory?: RuntimeRequestMemory;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeRequestMemory = {
+    namespace?: string;
+    recall?: false | {
+        query?: string;
+        limit?: number;
+    };
+    candidates?: RuntimeMemoryCandidateInput[];
+};
+export type RuntimeMemoryCandidateInput = Omit<MemoryCandidate, "namespace"> & {
+    namespace?: string;
+};
+export type RuntimeResponse = {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    state: RuntimeRecordState;
+    output: string;
+    metadata?: Record<string, unknown>;
+    artifacts?: RuntimeArtifact[];
+};
+export type RuntimeRunRecord = {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    input: string;
+    state: RuntimeRecordState;
+    output?: string;
+    error?: string;
+    parentRunId?: string;
+    metadata?: Record<string, unknown>;
+    artifacts: RuntimeArtifact[];
+    startedAt: string;
+    completedAt?: string;
+    events: RuntimeEvent[];
+};
+export type RuntimeStoreRunPatch = Partial<Pick<RuntimeRunRecord, "state" | "output" | "error" | "metadata" | "artifacts" | "completedAt">>;
+export type RuntimeRunFilter = {
+    agentId?: string;
+    sessionId?: string;
+    state?: RuntimeRecordState;
+};
+export type RuntimeStore = {
+    createRun(record: RuntimeRunRecord): void;
+    updateRun(requestId: string, patch: RuntimeStoreRunPatch): RuntimeRunRecord | undefined;
+    appendEvent(event: RuntimeEvent): RuntimeRunRecord | undefined;
+    getRun(requestId: string): RuntimeRunRecord | undefined;
+    listRuns(filter?: RuntimeRunFilter): RuntimeRunRecord[];
+};
+export type RuntimeQueueRecord = {
+    requestId: string;
+    sessionId: string;
+    priority: number;
+    queueKey?: string;
+    enqueuedAt: string;
+    availableAt: string;
+    claimedBy?: string;
+    claimedAt?: string;
+    leaseExpiresAt?: string;
+    attemptCount: number;
+    lastError?: string;
+};
+export type RuntimeRequestControlRecord = {
+    requestId: string;
+    cancelRequested: boolean;
+    cancelReason?: string;
+    cancelRequestedAt?: string;
+    heartbeatAt?: string;
+    workerId?: string;
+    workerStartedAt?: string;
+};
+export type RuntimeRecoveryIntent = {
+    requestId: string;
+    sessionId: string;
+    kind: "approval-decision" | "restart-request";
+    savedAt: string;
+    checkpointRef?: string;
+    resumePayload?: unknown;
+    attempts: number;
+};
+export type RuntimeQueueStore = {
+    enqueue(record: Omit<RuntimeQueueRecord, "attemptCount" | "enqueuedAt"> & {
+        attemptCount?: number;
+        enqueuedAt?: string;
+    }): RuntimeQueueRecord;
+    listQueue(): RuntimeQueueRecord[];
+    getQueuedRequest(requestId: string): RuntimeQueueRecord | undefined;
+    claimNext(input: RuntimeQueueClaimInput): RuntimeQueueRecord | undefined;
+    heartbeat(input: RuntimeHeartbeatInput): RuntimeRequestControlRecord | undefined;
+    requestCancel(input: RuntimeCancelIntentInput): RuntimeRequestControlRecord;
+    getControl(requestId: string): RuntimeRequestControlRecord | undefined;
+    listStuck(input: RuntimeStuckRequestInput): RuntimeQueueRecord[];
+    saveRecoveryIntent(intent: RuntimeRecoveryIntent): RuntimeRecoveryIntent;
+    getRecoveryIntent(requestId: string): RuntimeRecoveryIntent | undefined;
+    clearRecoveryIntent(requestId: string): boolean;
+};
+export type RuntimeQueueClaimInput = {
+    workerId: string;
+    now?: string;
+    leaseMs: number;
+    queueKey?: string;
+};
+export type RuntimeHeartbeatInput = {
+    requestId: string;
+    workerId: string;
+    now?: string;
+};
+export type RuntimeCancelIntentInput = {
+    requestId: string;
+    reason?: string;
+    now?: string;
+};
+export type RuntimeStuckRequestInput = {
+    now?: string;
+    staleAfterMs: number;
+};

package/node_modules/@stable-harness/core/dist/runtime/types.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@stable-harness/core/dist/runtime.d.ts

@@ -0,0 +1,21 @@
+import type { ApprovalQueue } from "@stable-harness/governance";
+import type { MemoryProvider, RuntimeMemoryStore } from "@stable-harness/memory";
+import type { QualityReviewModel } from "./quality/index.js";
+import type { CompiledWorkspace, RuntimeCapabilityModule, RuntimeToolGateway, RuntimeAdapter, RuntimeArtifactStore, RuntimeSandboxPolicy, RuntimeStore, RuntimeProgressNarrationOptions, RuntimeWorkflowAdapter, StableHarnessRuntime } from "./types.js";
+type RuntimeFactoryInput = {
+    workspace: CompiledWorkspace;
+    adapters: RuntimeAdapter[];
+    workflowAdapters?: RuntimeWorkflowAdapter[];
+    memory?: RuntimeMemoryStore;
+    memoryProviders?: MemoryProvider[];
+    approvals?: ApprovalQueue;
+    toolGateway?: RuntimeToolGateway;
+    sandbox?: RuntimeSandboxPolicy | false;
+    store?: RuntimeStore;
+    artifacts?: RuntimeArtifactStore;
+    progressNarration?: RuntimeProgressNarrationOptions | false;
+    qualityReviewModel?: QualityReviewModel;
+    capabilities?: RuntimeCapabilityModule[];
+};
+export declare function createStableHarnessRuntime(input: RuntimeFactoryInput): StableHarnessRuntime;
+export {};

package/node_modules/@stable-harness/core/dist/runtime.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{assertExecutionContract as t}from"./execution-contract.js";import{assertNoRawToolCallOutput as r,assertNoToolExecutionErrorOutput as a,buildAdapterErrorRecoveryPrompt as s,buildEvidenceSynthesisOutput as o,buildExecutionContractRecoveryRequest as n,buildResultRecoveryRequest as i,containsRawToolCallOutput as u,isRecoverableAdapterError as c,rawToolCallFailureMessage as l,toolCallRecoveryEnabled as p}from"./recovery/tool-call.js";import{recoverQualityReview as d,resolveQualityPolicy as m}from"./quality/index.js";import{completeRun as w,failRun as y}from"./runtime/completion.js";import{runDirectToolCall as f}from"./runtime/direct-tool-call.js";import{createApprovalGatedToolGateway as g}from"./runtime/governance/approval-gate.js";import{createSandboxedToolGateway as I}from"./runtime/governance/sandbox.js";import{createRuntimeInspectionMethods as q}from"./runtime/inspection/methods.js";import{createRuntimeCapabilityRegistry as R,normalizeAdapterResult as v}from"./runtime/capabilities.js";import{createMemoryRuntimeCapability as b}from"./runtime/memory.js";import{createInMemoryRuntimeStore as k}from"./runtime/persistence/stores.js";import{createProgressNarrationCapability as A}from"./runtime/progress-narration.js";import{repairRuntimeSelection as C}from"./runtime/selection-repair.js";import{createToolFailureTracker as x}from"./runtime/tool-failure.js";import{runWorkflowRequest as h}from"./workflows/runtime.js";export function createStableHarnessRuntime(t){const r=new Set,a=t.store??k(),o=R([b(t),A({options:t.progressNarration,policy:t.workspace.runtime}),...t.capabilities??[]]),emitBase=e=>{a.appendEvent(e);for(const t of r)t(e)},emit=e=>{emitBase(e),o.emitSideEffects(e,emitBase)},i=I({gateway:g({gateway:t.toolGateway,approvals:t.approvals,workspace:t.workspace,emit:emit}),workspace:t.workspace,sandbox:t.sandbox,emit:emit}),u={...t,toolGateway:i},l=x(function readToolFailurePolicy(e){if("object"!=typeof e||null===e||Array.isArray(e))return;const t=e.failurePolicy;return"object"!=typeof t||null===t||Array.isArray(t)?void 0:t}(t.workspace.runtime.toolGateway));return{request:async t=>async function runRuntimeRequest(t){const r=t.request.requestId??e(),a=t.request.sessionId??e(),o=[],{agent:i,adapter:u}=await async function resolveExecution(e,t,r){const a=t.agentId?await async function resolveRequestedAgentId(e,t,r){if(e.agents.has(t))return t;const a=await C({id:t,candidates:[...e.agents.values()].map(e=>({id:e.id,description:e.description})),trace:{...r,agentId:t,layer:"agent",owner:"stable_runtime_policy"}});return a.ok?a.id:t}(e.workspace,t.agentId,r):function resolveRoutedAgentId(e,t){for(const r of e.runtime.routes??[])if(routeMatches(r,t))return r.agentId;return e.runtime.defaultAgentId}(e.workspace,t.input),s=e.workspace.agents.get(a);if(!s)throw new Error(`Agent ${a} is not defined in the workspace`);if(t.toolCall||t.workflow)return{agent:s,adapter:void 0};const o=e.adapters.find(e=>e.canRun(s));if(!o)throw new Error(`No runtime adapter can run backend ${s.backend} for agent ${s.id}`);return{agent:s,adapter:o}}(t.input,t.request,{requestId:r,sessionId:a,emit:e=>o.push(e)});t.store.createRun(function createRunRecord(e,t,r,a){return{requestId:t,sessionId:r,agentId:a.id,input:e.input,state:"running",parentRunId:e.parentRunId,metadata:e.metadata,artifacts:[],startedAt:(new Date).toISOString(),events:[]}}(t.request,r,a,i)),o.forEach(t.emit),t.emit({type:"runtime.request.started",requestId:r,sessionId:a,agentId:i.id,input:t.request.input});try{if(t.request.workflow){const e=await h({workspace:t.input.workspace,adapters:t.input.workflowAdapters??[],toolGateway:t.input.toolGateway,request:{input:t.request.input,...t.request.workflow},requestId:r,sessionId:a,agentId:i.id,emit:t.emit});return w({store:t.store,emit:t.emit,requestId:r,sessionId:a,agent:i,result:e,artifacts:t.input.artifacts})}if(t.request.toolCall){const e=await f({gateway:t.input.toolGateway,workspace:t.input.workspace,emit:t.emit,request:t.request,requestId:r,sessionId:a,agent:i,toolFailureTracker:t.toolFailureTracker});return w({store:t.store,emit:t.emit,requestId:r,sessionId:a,agent:i,result:e,artifacts:t.input.artifacts})}return await async function runAdapterRequest(e){if(!e.adapter)throw new Error(`No runtime adapter can run backend ${e.agent.backend} for agent ${e.agent.id}`);const t=e.adapter,r=await e.capabilities.beforeAdapterRun(createCapabilityContext(e)),a=r.memory,o=r.pluginMemories??[],i=e.input.workspace.runtime,u=m(e.input.workspace.runtime,e.agent),l=new Map;let p;try{p=await runAdapterOnce(e,t,e.request,a,o,l)}catch(r){if(!c(r,i))throw r;p=await runAdapterOnce(e,t,s(e.request,r,i),a,o,l)}p=await recoverAdapterResultOutput(e,t,e.request,p,a,o,i,l),p=await d(createQualityRuntimeInput(e,a,o,l),e.request,p,u),await e.capabilities.beforeAdapterResultContract({...createCapabilityContext(e),result:p});try{assertRequestExecutionContract(e)}catch(r){const s=n({request:e.request,events:e.store.getRun(e.requestId)?.events??[],policy:i});if(!s)throw r;p=await runAdapterOnce(e,t,s,a,o,l),p=await recoverAdapterResultOutput(e,t,s,p,a,o,i,l),p=await d(createQualityRuntimeInput(e,a,o,l),s,p,u),assertRequestExecutionContract(e)}const y=w({store:e.store,emit:e.emit,requestId:e.requestId,sessionId:e.sessionId,agent:e.agent,result:p,artifacts:e.input.artifacts});return await e.capabilities.afterAdapterResponse({...createCapabilityContext(e),result:p,response:y}),y}({...t,adapter:u,requestId:r,sessionId:a,agent:i})}catch(e){return y({store:t.store,emit:t.emit,requestId:r,sessionId:a,agent:i,error:e})}}({input:u,capabilities:o,store:a,emit:emit,request:t,toolFailureTracker:l}),subscribe:e=>(r.add(e),()=>r.delete(e)),...q({workspace:t.workspace,store:a,artifacts:t.artifacts,approvals:t.approvals,emit:emit}),cancel(e,t){const r=a.getRun(e);r&&"running"===r.state&&(a.updateRun(e,{state:"cancelled",completedAt:(new Date).toISOString()}),emit({type:"runtime.request.cancelled",requestId:e,sessionId:r.sessionId,agentId:r.agentId,reason:t}))},async stop(){await o.stop(),r.clear()}}}function createCapabilityContext(e){return{workspace:e.input.workspace,store:e.store,emit:e.emit,request:e.request,requestId:e.requestId,sessionId:e.sessionId,agent:e.agent}}function createQualityRuntimeInput(e,t,r,a){return{workspace:e.input.workspace,agent:e.agent,request:e.request,requestId:e.requestId,sessionId:e.sessionId,events:e.store.getRun(e.requestId)?.events??[],emit:e.emit,getEvents:()=>e.store.getRun(e.requestId)?.events??[],runAdapter:s=>runAdapterOnce(e,e.adapter,s,t,r,a),reviewModel:e.input.qualityReviewModel,memory:t,pluginMemories:r}}async function recoverAdapterResultOutput(e,t,s,n,c,d,m,w){let y=s;const f=function resultRecoveryAttempts(e){const t="object"!=typeof e||null===e||Array.isArray(e)?void 0:e.recovery,r="object"!=typeof t||null===t||Array.isArray(t)?void 0:t.toolCall,a="object"!=typeof r||null===r||Array.isArray(r)?void 0:r.maxResultRecoveryAttempts;return"number"==typeof a&&Number.isInteger(a)&&a>0?a:3}(m);let g=0;for(let r=0;r<f;r+=1){const r=e.store.getRun(e.requestId)?.events??[],a=i({request:y,output:n.text,events:r.slice(g),availableToolIds:e.agent.tools,policy:m});if(!a)break;y=a,g=e.store.getRun(e.requestId)?.events.length??0,n=await runAdapterOnce(e,t,a,c,d,w)}if(p(m)){let t=!1;u(n.text,m)&&function rawToolCallFailureReturnsMessage(e){return"message"===("object"!=typeof e?.toolCallRecovery||null===e.toolCallRecovery||Array.isArray(e.toolCallRecovery)?{}:e.toolCallRecovery).onFailure}(s.metadata)&&(n={...n,text:l(),metadata:{...n.metadata,toolCallRecovery:{failed:!0,reason:"raw_tool_call_output"}}});const i=o({request:s,output:n.text,events:e.store.getRun(e.requestId)?.events??[],policy:m});i&&(t=!0,n={...n,text:i,metadata:{...n.metadata,toolCallRecovery:{synthesized:!0,reason:"raw_tool_call_output_with_evidence"}}}),t||(r(n.text,m),a(n.text,m))}return n}function assertRequestExecutionContract(e){t({store:e.store,emit:e.emit,requestId:e.requestId,sessionId:e.sessionId,agent:e.agent,metadata:e.request.metadata})}async function runAdapterOnce(e,t,r,a,s,o){return v(await t.run({workspace:e.input.workspace,agent:e.agent,request:r,requestId:e.requestId,sessionId:e.sessionId,memory:a,pluginMemories:s,toolGateway:e.input.toolGateway,toolFailureTracker:e.input.toolFailureTracker,requestState:o,getEvents:()=>e.store.getRun(e.requestId)?.events??[],emit:e.emit}))}function routeMatches(e,t){if(e.pattern)try{if(new RegExp(e.pattern,"iu").test(t))return!0}catch{return!1}const r=t.toLowerCase();return(e.keywords??[]).some(e=>r.includes(e.toLowerCase()))}

package/node_modules/@stable-harness/core/dist/spec-driven/config.d.ts

@@ -0,0 +1,4 @@
+import type { WorkspaceSpecDrivenPhase, WorkspaceSpecDrivenWorkflowPolicy } from "./types.js";
+export declare const DEFAULT_SPEC_DRIVEN_PHASES: WorkspaceSpecDrivenPhase[];
+export declare function createSpecDrivenWorkflowPolicy(input?: Partial<WorkspaceSpecDrivenWorkflowPolicy>): WorkspaceSpecDrivenWorkflowPolicy;
+export declare function assertSpecDrivenWorkflowPolicy(policy: WorkspaceSpecDrivenWorkflowPolicy): void;

package/node_modules/@stable-harness/core/dist/spec-driven/config.js

@@ -0,0 +1 @@
+export const DEFAULT_SPEC_DRIVEN_PHASES=[{id:"constitution",artifactKind:"constitution",required:!0},{id:"specify",artifactKind:"spec",required:!0},{id:"plan",artifactKind:"plan",required:!0},{id:"contracts",artifactKind:"contract"},{id:"research",artifactKind:"research"},{id:"tasks",artifactKind:"tasks",required:!0},{id:"implement",artifactKind:"execution"},{id:"verify",artifactKind:"evidence",required:!0}];export function createSpecDrivenWorkflowPolicy(i){return{enabled:i?.enabled??!1,...i?.constitution?{constitution:i.constitution}:{},artifactsDir:i?.artifactsDir??"specs",phases:(t=i?.phases,(t&&t.length>0?t:DEFAULT_SPEC_DRIVEN_PHASES).map(i=>({id:i.id,...i.artifactKind?{artifactKind:i.artifactKind}:{},...void 0!==i.required?{required:i.required}:{},...i.gate?{gate:i.gate}:{},...i.config?{config:i.config}:{}}))),...i?.gates?{gates:i.gates}:{},...i?.config?{config:i.config}:{}};var t}export function assertSpecDrivenWorkflowPolicy(i){const t=new Set;for(const e of i.phases){if(!e.id.trim())throw new Error("specDrivenWorkflow phases require non-empty id");if(t.has(e.id))throw new Error(`specDrivenWorkflow phase is duplicated: ${e.id}`);t.add(e.id)}}

package/node_modules/@stable-harness/core/dist/spec-driven/events.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeEvent } from "../runtime/events.js";
+import type { RuntimeArtifact } from "../runtime/types.js";
+import type { SpecDrivenPhaseTransition } from "./types.js";
+export type SpecDrivenEventContext = {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    workflowId?: string;
+};
+export declare function createSpecDrivenPhaseEvent(context: SpecDrivenEventContext, transition: SpecDrivenPhaseTransition): RuntimeEvent;
+export declare function createSpecDrivenArtifactEvent(context: SpecDrivenEventContext, phaseId: string, artifact: RuntimeArtifact): RuntimeEvent;

package/node_modules/@stable-harness/core/dist/spec-driven/events.js

@@ -0,0 +1 @@
+export function createSpecDrivenPhaseEvent(e,t){const r={requestId:e.requestId,sessionId:e.sessionId,agentId:e.agentId,phaseId:t.phaseId,...e.workflowId?{workflowId:e.workflowId}:{}};return"started"===t.status?{type:"runtime.specDriven.phase.started",...r}:"completed"===t.status?{type:"runtime.specDriven.phase.completed",...r,artifact:t.artifact}:"verified"===t.status?{type:"runtime.specDriven.phase.verified",...r,artifact:t.artifact}:{type:"runtime.specDriven.phase.blocked",...r,reason:t.reason??"unspecified"}}export function createSpecDrivenArtifactEvent(e,t,r){return{type:"runtime.artifact.created",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agentId,artifact:{...r,metadata:{...r.metadata,phaseId:t,workflowKind:"spec-driven"}}}}

package/node_modules/@stable-harness/core/dist/spec-driven/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./config.js";
+export * from "./events.js";
+export * from "./lifecycle.js";
+export * from "./types.js";

package/node_modules/@stable-harness/core/dist/spec-driven/index.js

@@ -0,0 +1 @@
+export*from"./config.js";export*from"./events.js";export*from"./lifecycle.js";export*from"./types.js";

package/node_modules/@stable-harness/core/dist/spec-driven/lifecycle.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeArtifact } from "../runtime/types.js";
+import type { SpecDrivenPhaseTransition, SpecDrivenWorkflowState, WorkspaceSpecDrivenWorkflowPolicy } from "./types.js";
+export declare function createSpecDrivenWorkflowState(policy: WorkspaceSpecDrivenWorkflowPolicy): SpecDrivenWorkflowState;
+export declare function applySpecDrivenPhaseTransition(state: SpecDrivenWorkflowState, transition: SpecDrivenPhaseTransition): SpecDrivenWorkflowState;
+export declare function createSpecDrivenArtifact(input: {
+    id: string;
+    phaseId: string;
+    artifactKind: string;
+    uri?: string;
+    metadata?: Record<string, unknown>;
+}): RuntimeArtifact;

package/node_modules/@stable-harness/core/dist/spec-driven/lifecycle.js

@@ -0,0 +1 @@
+export function createSpecDrivenWorkflowState(t){return{enabled:t.enabled,artifactsDir:t.artifactsDir,...t.constitution?{constitution:t.constitution}:{},phases:t.phases.map(t=>({id:t.id,status:"pending",updatedAt:new Date(0).toISOString()}))}}export function applySpecDrivenPhaseTransition(t,a){if(!new Set(t.phases.map(t=>t.id)).has(a.phaseId))throw new Error(`Spec-driven workflow phase is not configured: ${a.phaseId}`);return{...t,phases:t.phases.map(t=>function updatePhase(t,a){return t.id!==a.phaseId?t:{id:t.id,status:a.status,...a.artifact?{artifact:a.artifact}:t.artifact?{artifact:t.artifact}:{},...a.reason?{reason:a.reason}:{},updatedAt:a.timestamp??(new Date).toISOString()}}(t,a))}}export function createSpecDrivenArtifact(t){return{id:t.id,kind:`spec-driven.${t.artifactKind}`,...t.uri?{uri:t.uri}:{},metadata:{phaseId:t.phaseId,...t.metadata}}}

package/node_modules/@stable-harness/core/dist/spec-driven/types.d.ts

@@ -0,0 +1,38 @@
+import type { RuntimeArtifact } from "../runtime/types.js";
+export type SpecDrivenPhaseId = string;
+export type SpecDrivenPhaseStatus = "pending" | "started" | "blocked" | "completed" | "verified";
+export type WorkspaceSpecDrivenPhase = {
+    id: string;
+    artifactKind?: string;
+    required?: boolean;
+    gate?: string;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceSpecDrivenWorkflowPolicy = {
+    enabled: boolean;
+    constitution?: string;
+    artifactsDir: string;
+    phases: WorkspaceSpecDrivenPhase[];
+    gates?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+};
+export type SpecDrivenPhaseRecord = {
+    id: string;
+    status: SpecDrivenPhaseStatus;
+    artifact?: RuntimeArtifact;
+    reason?: string;
+    updatedAt: string;
+};
+export type SpecDrivenWorkflowState = {
+    enabled: boolean;
+    artifactsDir: string;
+    constitution?: string;
+    phases: SpecDrivenPhaseRecord[];
+};
+export type SpecDrivenPhaseTransition = {
+    phaseId: string;
+    status: Exclude<SpecDrivenPhaseStatus, "pending">;
+    artifact?: RuntimeArtifact;
+    reason?: string;
+    timestamp?: string;
+};

package/node_modules/@stable-harness/core/dist/spec-driven/types.js

@@ -0,0 +1 @@
+export{};

package/node_modules/@stable-harness/core/dist/trace.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeEvent, RuntimeRunRecord } from "./types.js";
+export type PlanTodoItem = {
+    content: string;
+    status: string;
+};
+export type RuntimeTraceEntry = {
+    type: "request" | "tool" | "workflow" | "spec" | "adapter" | "memory" | "artifact" | "progress" | "plan" | "delegation";
+    label: string;
+    agentId: string;
+    requestId: string;
+    detail?: Record<string, unknown>;
+};
+export type RuntimeAdapterTraceProjection = {
+    traceType: RuntimeTraceEntry["type"];
+    traceLabel: string;
+} & Record<string, unknown>;
+export declare function createDelegationTraceProjection(label: "delegation.start" | "delegation.completed", detail?: Record<string, unknown>): RuntimeAdapterTraceProjection;
+export declare function createPlanTraceProjection(label: "plan.updated", detail?: Record<string, unknown>): RuntimeAdapterTraceProjection;
+export declare function projectRuntimeTrace(run: RuntimeRunRecord): RuntimeTraceEntry[];
+export declare function projectEvent(event: RuntimeEvent): RuntimeTraceEntry | undefined;
+export declare function readPlanTodos(output: unknown): PlanTodoItem[];

package/node_modules/@stable-harness/core/dist/trace.js

@@ -0,0 +1 @@
+export function createDelegationTraceProjection(e,t={}){return{traceType:"delegation",traceLabel:e,...t}}export function createPlanTraceProjection(e,t={}){return{traceType:"plan",traceLabel:e,...t}}export function projectRuntimeTrace(e){return e.events.map(projectEvent).filter(isTraceEntry)}export function projectEvent(e){return"runtime.request.started"===e.type||"runtime.request.completed"===e.type||"runtime.request.failed"===e.type?base(e,"request",e.type):"runtime.request.cancelled"===e.type?base(e,"request",e.type,{reason:e.reason}):"runtime.execution.contract.failed"===e.type?base(e,"request",e.type,{reason:e.reason,missingEvidenceTools:e.missingEvidenceTools}):"runtime.inventory.repair"===e.type?base(e,"adapter","runtime.inventory.repair",{status:e.status,...e.diagnostic}):"runtime.tool.direct.started"===e.type?base(e,"tool","runtime.tool.direct.started",{toolId:e.toolId}):"runtime.tool.direct.completed"===e.type?base(e,"tool","runtime.tool.direct.completed",{toolId:e.toolId}):"runtime.sandbox.decision"===e.type?base(e,"tool","runtime.sandbox.decision",{toolId:e.toolId,...e.decision}):"runtime.tool.failure"===e.type?base(e,"tool","runtime.tool.failure",{toolId:e.toolId,...e.failure}):"runtime.tool.circuit.opened"===e.type?base(e,"tool","runtime.tool.circuit.opened",{toolId:e.toolId,reason:e.reason}):"runtime.workflow.started"===e.type||"runtime.workflow.completed"===e.type?base(e,"workflow",e.type,{workflowId:e.workflowId,adapter:e.adapter}):function isSpecDrivenPhaseEvent(e){return e.type.startsWith("runtime.specDriven.phase.")}(e)?base(e,"spec",e.type,{phaseId:e.phaseId,..."workflowId"in e&&e.workflowId?{workflowId:e.workflowId}:{},..."reason"in e?{reason:e.reason}:{},..."artifact"in e&&e.artifact?{artifact:e.artifact}:{}}):"runtime.adapter.event"===e.type?function adapterTrace(e){const t=e.event;if(isRecord(t)&&"string"==typeof t.phase){const r=function semanticAdapterTrace(e,t){if("inventory.repair"===t.phase)return base(e,"adapter","runtime.inventory.repair",{status:t.status,...isRecord(t.diagnostic)?t.diagnostic:{}});const r=function readTraceType(e){const t=readString(e);return"request"===t||"tool"===t||"workflow"===t||"spec"===t||"adapter"===t||"memory"===t||"artifact"===t||"progress"===t||"plan"===t||"delegation"===t?t:void 0}(t.traceType),o=readString(t.traceLabel);return r&&o?base(e,r,o,t):void 0}(e,t);return r||base(e,"adapter",t.phase.startsWith("agent.")?t.phase:`adapter.${t.phase}`,t)}return base(e,"adapter","runtime.adapter.event",{event:t})}(e):"runtime.artifact.created"===e.type?base(e,"artifact","runtime.artifact.created",{artifact:e.artifact}):e.type.startsWith("runtime.memory.")?base(e,"memory",e.type):"runtime.progress.narration"===e.type?base(e,"progress",e.type,{message:e.message,provider:e.provider,sourceEventTypes:e.sourceEventTypes}):void 0}export function readPlanTodos(e){const t=function readPlanRecord(e){if(isRecord(e))return e;if("string"==typeof e)try{const t=JSON.parse(e);return isRecord(t)?t:void 0}catch{return}}(e),r=function readTodosArray(e){const t=isRecord(e?.args)?e.args:void 0;return Array.isArray(e?.todos)?e.todos:Array.isArray(t?.todos)?t.todos:[]}(t);return r.map(readTodo).filter(isPlanTodoItem)}function readTodo(e){if(isRecord(e)&&"string"==typeof e.content)return{content:e.content,status:"string"==typeof e.status?e.status:"pending"}}function isPlanTodoItem(e){return void 0!==e}function base(e,t,r,o){return{type:t,label:r,agentId:e.agentId,requestId:e.requestId,detail:o}}function isTraceEntry(e){return void 0!==e}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}