stable-harness 0.0.37 → 0.0.38

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

@@ -0,0 +1,47 @@
+import type { RuntimeMemoryContext } from "../types.js";
+import type { RuntimeEvent, RuntimeEmit } from "./events.js";
+import type { RuntimeOutput, RuntimeRequest, RuntimeResponse, RuntimeStore } from "./types.js";
+import type { CompiledWorkspace, WorkspaceAgent } from "../workspace/types.js";
+export type RuntimeCapabilityState = {
+    memory?: RuntimeMemoryContext;
+    pluginMemories?: RuntimeMemoryContext[];
+};
+export type RuntimeCapabilityContext = {
+    workspace: CompiledWorkspace;
+    store: RuntimeStore;
+    emit: RuntimeEmit;
+    request: RuntimeRequest;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    state: RuntimeCapabilityState;
+};
+export type RuntimeCapabilityModule = {
+    id: string;
+    onEvent?(event: RuntimeEvent, emit: RuntimeEmit): void;
+    beforeAdapterRun?(context: RuntimeCapabilityContext): Promise<Partial<RuntimeCapabilityState> | void> | Partial<RuntimeCapabilityState> | void;
+    beforeAdapterResultContract?(context: RuntimeCapabilityContext & {
+        result: RuntimeOutput;
+    }): Promise<void> | void;
+    afterAdapterResponse?(context: RuntimeCapabilityContext & {
+        result: RuntimeOutput;
+        response: RuntimeResponse;
+    }): Promise<void> | void;
+    stop?(): Promise<void> | void;
+};
+export type RuntimeCapabilityRegistry = {
+    modules: RuntimeCapabilityModule[];
+    state: RuntimeCapabilityState;
+    emitSideEffects(event: RuntimeEvent, emit: RuntimeEmit): void;
+    beforeAdapterRun(context: Omit<RuntimeCapabilityContext, "state">): Promise<RuntimeCapabilityState>;
+    beforeAdapterResultContract(context: Omit<RuntimeCapabilityContext, "state"> & {
+        result: RuntimeOutput;
+    }): Promise<void>;
+    afterAdapterResponse(context: Omit<RuntimeCapabilityContext, "state"> & {
+        result: RuntimeOutput;
+        response: RuntimeResponse;
+    }): Promise<void>;
+    stop(): Promise<void>;
+};
+export declare function createRuntimeCapabilityRegistry(modules: Array<RuntimeCapabilityModule | undefined>): RuntimeCapabilityRegistry;
+export declare function normalizeAdapterResult(result: string | RuntimeOutput): RuntimeOutput;

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

@@ -0,0 +1 @@
+export function createRuntimeCapabilityRegistry(e){const t=e.filter(e=>Boolean(e)),o={};return{modules:t,state:o,emitSideEffects(e,o){for(const r of t)try{r.onEvent?.(e,o)}catch{continue}},async beforeAdapterRun(e){for(const r of t){const t=await(r.beforeAdapterRun?.({...e,state:o}));mergeCapabilityState(o,t)}return o},async beforeAdapterResultContract(e){for(const r of t)await(r.beforeAdapterResultContract?.({...e,state:o}))},async afterAdapterResponse(e){for(const r of t)await(r.afterAdapterResponse?.({...e,state:o}))},async stop(){await Promise.all(t.map(e=>e.stop?.()))}}}export function normalizeAdapterResult(e){return"string"==typeof e?{text:e}:e}function mergeCapabilityState(e,t){t&&(void 0!==t.memory&&(e.memory=t.memory),t.pluginMemories&&(e.pluginMemories=[...e.pluginMemories??[],...t.pluginMemories]))}

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

@@ -0,0 +1,18 @@
+import type { RuntimeArtifactStore, RuntimeEvent, RuntimeOutput, RuntimeResponse, RuntimeStore, WorkspaceAgent } from "../types.js";
+export declare function completeRun(input: {
+    store: RuntimeStore;
+    emit: (event: RuntimeEvent) => void;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    result: RuntimeOutput;
+    artifacts?: RuntimeArtifactStore;
+}): RuntimeResponse;
+export declare function failRun(input: {
+    store: RuntimeStore;
+    emit: (event: RuntimeEvent) => void;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    error: unknown;
+}): RuntimeResponse;

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

@@ -0,0 +1 @@
+export function completeRun(t){const e=t.store.getRun(t.requestId);if("cancelled"===e?.state)return response(t,"cancelled",e.artifacts);const s=(t.result.artifacts??[]).map(toPublicArtifact);e&&t.store.updateRun(t.requestId,{state:"completed",output:t.result.text,metadata:{...e.metadata,...t.result.metadata},artifacts:mergeArtifacts(e.artifacts,s),completedAt:(new Date).toISOString()});for(const e of t.result.artifacts??[])t.artifacts?.createArtifact({...e,requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id});for(const e of s)t.emit({type:"runtime.artifact.created",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,artifact:e});return t.emit({type:"runtime.request.completed",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,output:t.result.text}),response(t,"completed",t.store.getRun(t.requestId)?.artifacts)}export function failRun(t){const e=t.error instanceof Error?t.error.message:String(t.error);return t.store.getRun(t.requestId)&&t.store.updateRun(t.requestId,{state:"failed",error:e,completedAt:(new Date).toISOString()}),t.emit({type:"runtime.request.failed",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,error:e}),{requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,state:"failed",output:e}}function response(t,e,s){return{requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,state:e,output:t.result.text,metadata:t.result.metadata,artifacts:s??t.result.artifacts}}function mergeArtifacts(t,e){const s=new Map;for(const r of[...t??[],...e??[]])s.set(r.id,r);return[...s.values()]}function toPublicArtifact(t){return{id:t.id,kind:t.kind,...t.uri?{uri:t.uri}:{},...t.metadata?{metadata:t.metadata}:{}}}

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

@@ -0,0 +1,11 @@
+import type { CompiledWorkspace, RuntimeEvent, RuntimeOutput, RuntimeRequest, RuntimeToolFailureTracker, RuntimeToolGateway, WorkspaceAgent } from "../types.js";
+export declare function runDirectToolCall(input: {
+    gateway: RuntimeToolGateway | undefined;
+    workspace: CompiledWorkspace;
+    emit: (event: RuntimeEvent) => void;
+    request: RuntimeRequest;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    toolFailureTracker?: RuntimeToolFailureTracker;
+}): Promise<RuntimeOutput>;

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

@@ -0,0 +1 @@
+import{toolCircuitOpenEvent as o,toolFailureEvent as t}from"./tool-failure.js";export async function runDirectToolCall(o){const t=o.request.toolCall;if(!t)throw new Error("Direct tool call request is missing");if(!o.gateway)throw new Error("Runtime tool gateway is not configured");const e=await async function resolveDirectToolCall(o){if(o.agent.tools.includes(o.toolId)&&o.gateway.get(o.toolId))return{toolId:o.toolId,args:o.args};const t=await(o.gateway.repairToolCall?.({toolId:o.toolId,args:o.args,allowedToolIds:o.agent.tools,context:{workspaceRoot:o.workspace.root,requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,requestInput:o.request.input,approvalIds:readApprovalIds(o.request.metadata)}}));if(t&&o.agent.tools.includes(t.toolId)&&o.gateway.get(t.toolId))return emitToolRepair(o,"repaired",t.toolId),t;if(!o.agent.tools.includes(o.toolId))throw emitToolRepair(o,"blocked",void 0,`Tool ${o.toolId} is not assigned to agent ${o.agent.id}`),new Error(`Tool ${o.toolId} is not assigned to agent ${o.agent.id}`);throw emitToolRepair(o,"blocked",void 0,`Tool is not registered: ${o.toolId}`),new Error(`Tool is not registered: ${o.toolId}`)}({gateway:o.gateway,workspace:o.workspace,requestId:o.requestId,sessionId:o.sessionId,agent:o.agent,emit:o.emit,request:o.request,toolId:t.toolId,args:t.args});if(o.emit({type:"runtime.tool.direct.started",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,toolId:e.toolId}),o.toolFailureTracker?.isCircuitOpen(e.toolId)){const t=new Error(`Tool circuit is open: ${e.toolId}`);throw emitToolFailure(o,e.toolId,t),t}const r=await async function invokeToolWithFailureEvents(o,t){try{return await o.gateway.invoke({toolId:t.toolId,args:t.args,context:{workspaceRoot:o.workspace.root,requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,requestInput:o.request.input,approvalIds:readApprovalIds(o.request.metadata)}})}catch(e){throw emitToolFailure(o,t.toolId,e),e}}(o,e);return o.toolFailureTracker?.recordSuccess(r.toolId),o.emit({type:"runtime.tool.direct.completed",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,toolId:r.toolId,output:r.output}),{text:(s=r.output,"string"==typeof s?s:JSON.stringify(s)),metadata:{toolCall:{toolId:r.toolId}}};var s}function emitToolFailure(e,r,s){const a=t({requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,toolId:r,error:s});e.emit(a),e.toolFailureTracker?.recordFailure(r)&&e.emit(o({requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,toolId:r,reason:"runtime.tool.failure"===a.type?a.failure.reason:"unknown"}))}function emitToolRepair(o,t,e,r){o.emit({type:"runtime.inventory.repair",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,status:t,diagnostic:{layer:"tool",owner:"stable_runtime_policy",originalId:o.toolId,repairedId:e,candidateIds:o.agent.tools,reason:r}})}function readApprovalIds(o){const t=o?.approvalIds??o?.approvalId;return"string"==typeof t&&t.trim()?[t.trim()]:Array.isArray(t)?t.filter(o=>"string"==typeof o&&o.trim().length>0):void 0}

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

@@ -0,0 +1,295 @@
+import type { MemoryCandidate, MemoryDecision, MemoryRecord } from "@stable-harness/memory";
+import type { ApprovalRequest } from "@stable-harness/governance";
+import type { RuntimeArtifact } from "../types.js";
+import type { RuntimeSandboxDecision } from "./tool-gateway.js";
+import type { RuntimeToolFailureClassification, RuntimeToolFailureReason } from "./tool-failure.js";
+export type RuntimeInventoryRepairLayer = "agent" | "workflow_route" | "workflow" | "tool" | "task" | "skill";
+export type RuntimeInventoryRepairStatus = "repaired" | "blocked";
+export type RuntimeInventoryRepairDiagnostic = {
+    layer: RuntimeInventoryRepairLayer;
+    owner: "stable_runtime_policy" | "protocol_adapter" | "upstream_backend" | "workspace_config";
+    originalId?: string;
+    repairedId?: string;
+    candidateIds: string[];
+    reason?: string;
+    matchSource?: string;
+    confidence?: number;
+};
+export type RuntimeEvent = {
+    type: "runtime.request.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    input?: string;
+} | {
+    type: "runtime.request.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    output: string;
+} | {
+    type: "runtime.request.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    error: string;
+} | {
+    type: "runtime.request.cancelled";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    reason?: string;
+} | {
+    type: "runtime.artifact.created";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    artifact: RuntimeArtifact;
+} | {
+    type: "runtime.execution.contract.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    reason: string;
+    missingEvidenceTools?: string[];
+} | {
+    type: "runtime.inventory.repair";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    status: RuntimeInventoryRepairStatus;
+    diagnostic: RuntimeInventoryRepairDiagnostic;
+} | {
+    type: "runtime.tool.direct.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+} | {
+    type: "runtime.tool.direct.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    output: unknown;
+} | {
+    type: "runtime.sandbox.decision";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    decision: RuntimeSandboxDecision;
+} | {
+    type: "runtime.approval.requested";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    approval: ApprovalRequest;
+} | {
+    type: "runtime.approval.resolved";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    approval: ApprovalRequest;
+} | {
+    type: "runtime.tool.failure";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    error: unknown;
+    failure: RuntimeToolFailureClassification;
+} | {
+    type: "runtime.tool.circuit.opened";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    reason: RuntimeToolFailureReason;
+} | {
+    type: "runtime.workflow.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    workflowId: string;
+    adapter: string;
+} | {
+    type: "runtime.workflow.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    workflowId: string;
+    adapter: string;
+} | {
+    type: "runtime.specDriven.phase.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    phaseId: string;
+    workflowId?: string;
+} | {
+    type: "runtime.specDriven.phase.blocked";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    phaseId: string;
+    workflowId?: string;
+    reason: string;
+} | {
+    type: "runtime.specDriven.phase.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    phaseId: string;
+    workflowId?: string;
+    artifact?: RuntimeArtifact;
+} | {
+    type: "runtime.specDriven.phase.verified";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    phaseId: string;
+    workflowId?: string;
+    artifact?: RuntimeArtifact;
+} | {
+    type: "runtime.memory.lifecycle";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    hook: RuntimeMemoryHook;
+} | {
+    type: "runtime.memory.recall.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    namespace: string;
+    recordIds: string[];
+    context: string;
+} | {
+    type: "runtime.memory.candidate.submitted";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    candidate: MemoryCandidate;
+    decision: MemoryDecision;
+    record?: MemoryRecord;
+} | {
+    type: "runtime.memory.approval.requested";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    approval: ApprovalRequest;
+} | {
+    type: "runtime.memory.plugin.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+} | {
+    type: "runtime.memory.plugin.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+    candidateCount: number;
+} | {
+    type: "runtime.memory.plugin.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+    error: string;
+} | {
+    type: "runtime.memory.maintenance.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+} | {
+    type: "runtime.memory.maintenance.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+    operationCount: number;
+} | {
+    type: "runtime.memory.maintenance.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+    error: string;
+} | {
+    type: "runtime.skill.candidate.created";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    candidateId: string;
+    name: string;
+    confidence: number;
+    evidenceCount: number;
+    status: string;
+    proposedPath?: string;
+} | {
+    type: "runtime.progress.narration";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    message: string;
+    provider: string;
+    sourceEventTypes: string[];
+    sourceEventIds?: string[];
+    model?: string;
+    style?: string;
+} | {
+    type: "runtime.quality.planning.reviewed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    verdict: string;
+    issues: Array<{
+        code: string;
+        message: string;
+        recoverable: boolean;
+    }>;
+} | {
+    type: "runtime.quality.execution.reviewed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    verdict: string;
+    issues: Array<{
+        code: string;
+        message: string;
+        recoverable: boolean;
+    }>;
+} | {
+    type: "runtime.quality.recovery.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    phase: "planning" | "execution";
+    attempt: number;
+    verdict: string;
+} | {
+    type: "runtime.quality.synthesis.created";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    mode: "evidence_only";
+} | {
+    type: "runtime.adapter.event";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    event: unknown;
+};
+export type RuntimeMemoryHook = "read-before-plan" | "read-before-finalize" | "write-after-run";
+export type RuntimeEventListener = (event: RuntimeEvent) => void;
+export type RuntimeEmit = (event: RuntimeEvent) => void;

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

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

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

@@ -0,0 +1,8 @@
+import type { ApprovalQueue } from "@stable-harness/governance";
+import type { CompiledWorkspace, RuntimeEvent, RuntimeToolGateway } from "../../types.js";
+export declare function createApprovalGatedToolGateway(input: {
+    gateway?: RuntimeToolGateway;
+    approvals?: ApprovalQueue;
+    workspace: CompiledWorkspace;
+    emit: (event: RuntimeEvent) => void;
+}): RuntimeToolGateway | undefined;

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

@@ -0,0 +1 @@
+export function createApprovalGatedToolGateway(e){if(!e.gateway)return;const t=function readRequiredToolIds(e){const t=readRecord(e);return new Set(function readStringArray(e){return Array.isArray(e)?e.filter(e=>"string"==typeof e&&e.trim().length>0):[]}(t?.requiredToolIds??t?.approvalRequiredToolIds))}(e.workspace.runtime.approvals);return 0===t.size?e.gateway:{get:t=>e.gateway?.get(t),repairToolCall:e.gateway.repairToolCall?.bind(e.gateway),async invoke(o){if(!t.has(o.toolId))return e.gateway.invoke(o);const r=await async function resolveApprovedToolInvocation(e,t,o){if(e&&o.approvalIds?.length)for(const r of o.approvalIds){const o=await e.get(r);if("tool_invocation"===o?.kind&&readRecord(o.subject)?.toolId===t){if("approved"===o.status)return"approved";if("rejected"===o.status)return"rejected"}}}(e.approvals,o.toolId,o.context);if("approved"===r)return e.gateway.invoke(o);if("rejected"===r)return{toolId:o.toolId,output:approvalRequiredOutput(o.toolId,"rejected","The linked approval was rejected.")};if(!e.approvals)return{toolId:o.toolId,output:approvalRequiredOutput(o.toolId,"approval_queue_missing","Tool approval is required, but no approval queue is configured.")};const a=await e.approvals.create({kind:"tool_invocation",reason:`Tool '${o.toolId}' requires explicit approval.`,requestId:o.context.requestId,sessionId:o.context.sessionId,agentId:o.context.agentId,subject:{toolId:o.toolId,args:o.args,requestInput:o.context.requestInput}});return e.emit({type:"runtime.approval.requested",requestId:o.context.requestId,sessionId:o.context.sessionId,agentId:o.context.agentId,approval:a}),{toolId:o.toolId,output:approvalRequiredOutput(o.toolId,"pending",a.reason,a.id)}}}}function approvalRequiredOutput(e,t,o,r){return{status:"approval_required",toolId:e,state:t,reason:o,...r?{approvalId:r}:{}}}function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}

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

@@ -0,0 +1,9 @@
+import type { CompiledWorkspace, RuntimeEvent, RuntimeToolGateway } from "../../types.js";
+import type { RuntimeSandboxPolicy } from "../tool-gateway.js";
+export declare function createSandboxedToolGateway(input: {
+    gateway?: RuntimeToolGateway;
+    workspace: CompiledWorkspace;
+    sandbox?: RuntimeSandboxPolicy | false;
+    emit: (event: RuntimeEvent) => void;
+}): RuntimeToolGateway | undefined;
+export declare function createWorkspaceSandboxPolicy(config: unknown): RuntimeSandboxPolicy | undefined;

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

@@ -0,0 +1 @@
+export function createSandboxedToolGateway(e){const o=!1===e.sandbox?void 0:e.sandbox??createWorkspaceSandboxPolicy(e.workspace.runtime.sandbox);return e.gateway&&o?{get:o=>e.gateway.get(o),repairToolCall:e.gateway.repairToolCall?o=>e.gateway.repairToolCall(o):void 0,async invoke(t){const n=await o.decide({toolId:t.toolId,args:t.args,context:t.context});return function emitDecision(e,o,t){e({type:"runtime.sandbox.decision",requestId:o.context.requestId,sessionId:o.context.sessionId,agentId:o.context.agentId,toolId:o.toolId,decision:t})}(e.emit,t,n),"deny"===n.action?{toolId:t.toolId,output:sandboxDeniedOutput(t.toolId,n)}:e.gateway.invoke({...t,context:{...t.context,sandbox:n}})}}:e.gateway}export function createWorkspaceSandboxPolicy(e){const o=readRecord(e);if(!o||!1===o.enabled)return;const t=function readRuleMap(e){const o=readRecord(e);return o?new Map(Object.entries(o).map(([e,o])=>[e,readRule(o)])):new Map}(o.byToolId??o.sandboxByToolId??o.profilesByToolId),n=new Set(function readStringArray(e){return Array.isArray(e)?e.filter(e=>"string"==typeof e&&e.trim().length>0):[]}(o.denyToolIds)),a=function fallbackDecision(e){const o=readAction(e.defaultAction)??"allow",t=readString(e.defaultProfile)??readString(e.profile);return{action:o,...t?{profile:t}:{},reason:"allow"===o?"No sandbox rule matched; default allow applied.":"No sandbox rule matched; default deny applied."}}(o);return{decide:e=>n.has(e.toolId)?{action:"deny",reason:"Tool is denied by sandbox policy."}:t.get(e.toolId)??a}}function sandboxDeniedOutput(e,o){return{status:"sandbox_denied",toolId:e,reason:o.reason??"Tool execution was denied by sandbox policy.",...o.profile?{profile:o.profile}:{},...o.policyId?{policyId:o.policyId}:{}}}function readRule(e){if("string"==typeof e&&e.trim())return{action:"allow",profile:e.trim()};const o=readRecord(e);if(!o)return{action:"allow"};const t=readAction(o.action)??(!0===o.deny?"deny":"allow"),n=readString(o.profile),a=readString(o.reason),r=readString(o.policyId),d=readRecord(o.metadata);return{action:t,...n?{profile:n}:{},...a?{reason:a}:{},...r?{policyId:r}:{},...d?{metadata:d}:{}}}function readAction(e){return"allow"===e||"deny"===e?e:void 0}function readString(e){return"string"==typeof e&&e.trim()?e.trim():void 0}function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}

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

@@ -0,0 +1,15 @@
+import type { RuntimeArtifactFilter, RuntimeArtifactRecord, RuntimeArtifactStore, RuntimeStore } from "../types.js";
+export declare function listRuntimeArtifacts(input: {
+    store: RuntimeStore;
+    artifacts?: RuntimeArtifactStore;
+    filter?: RuntimeArtifactFilter;
+}): RuntimeArtifactRecord[];
+export declare function getRuntimeArtifact(input: {
+    store: RuntimeStore;
+    artifacts?: RuntimeArtifactStore;
+    id: string;
+}): RuntimeArtifactRecord | undefined;
+export declare function readRuntimeArtifact(input: {
+    artifacts?: RuntimeArtifactStore;
+    id: string;
+}): unknown | undefined;

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

@@ -0,0 +1 @@
+export function listRuntimeArtifacts(t){return t.artifacts?t.artifacts.listArtifacts(t.filter):t.store.listRuns().flatMap(e=>function projectRunArtifacts(t,e){return function matchesFilter(t,e){return!(e&&(e.requestId&&e.requestId!==t.requestId||e.sessionId&&e.sessionId!==t.sessionId||e.agentId&&e.agentId!==t.agentId))}(t,e)?t.artifacts.map(e=>({...e,requestId:t.requestId,sessionId:t.sessionId,agentId:t.agentId,createdAt:t.completedAt??t.startedAt})):[]}(e,t.filter))}export function getRuntimeArtifact(t){return listRuntimeArtifacts(t).find(e=>e.id===t.id)}export function readRuntimeArtifact(t){try{return t.artifacts?.readArtifact(t.id)}catch{return}}

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

@@ -0,0 +1,11 @@
+import type { ApprovalQueue } from "@stable-harness/governance";
+import type { CompiledWorkspace, RuntimeArtifactStore, RuntimeEvent, RuntimeStore, StableHarnessRuntime } from "../../types.js";
+type RuntimeInspectionMethods = Pick<StableHarnessRuntime, "inspect" | "getRuntimePolicy" | "getWorkflow" | "getRun" | "listArtifacts" | "getArtifact" | "readArtifact" | "exportReplayBundle" | "listRequests" | "listSessions" | "inspectRequest" | "listApprovals" | "getApproval" | "resolveApproval">;
+export declare function createRuntimeInspectionMethods(input: {
+    workspace: CompiledWorkspace;
+    store: RuntimeStore;
+    artifacts?: RuntimeArtifactStore;
+    approvals?: ApprovalQueue;
+    emit: (event: RuntimeEvent) => void;
+}): RuntimeInspectionMethods;
+export {};

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

@@ -0,0 +1 @@
+import{projectRequestInspection as t,projectRequestSummary as e,projectSessionSummaries as s}from"../persistence/inspection.js";import{getRuntimeArtifact as r,listRuntimeArtifacts as o,readRuntimeArtifact as a}from"./artifacts.js";import{exportRuntimeReplayBundle as i}from"./replay.js";export function createRuntimeInspectionMethods(n){return{inspect:()=>{return{workspaceRoot:n.workspace.root,agents:[...n.workspace.agents.keys()].sort(),workflows:[...n.workspace.workflows.keys()].sort(),...n.workspace.runtime.specDrivenWorkflow?{specDrivenWorkflow:(t=n.workspace.runtime.specDrivenWorkflow,{enabled:t.enabled,artifactsDir:t.artifactsDir,...t.constitution?{constitution:t.constitution}:{},phases:t.phases.map(t=>t.id)})}:{},evaluations:[...n.workspace.evaluations?.keys()??[]].sort(),...n.workspace.runtime.workflowRouting?.defaultWorkflowId?{defaultWorkflowId:n.workspace.runtime.workflowRouting.defaultWorkflowId}:{},workflowRoutes:(n.workspace.runtime.workflowRouting?.routes??[]).map(t=>t.id).sort(),models:[...n.workspace.models.keys()].sort(),tools:[...n.workspace.tools.keys()].sort(),runs:n.store.listRuns()};var t},getRuntimePolicy:()=>n.workspace.runtime,getWorkflow:t=>n.workspace.workflows.get(t),getRun:t=>n.store.getRun(t),listArtifacts:t=>o({store:n.store,artifacts:n.artifacts,filter:t}),getArtifact:t=>r({store:n.store,artifacts:n.artifacts,id:t}),readArtifact:t=>a({artifacts:n.artifacts,id:t}),exportReplayBundle:t=>i({store:n.store,artifacts:n.artifacts,requestId:t}),listRequests:t=>n.store.listRuns(t).map(e),listSessions:()=>s(n.store.listRuns()),inspectRequest:e=>{const s=n.store.getRun(e);return s?t(n.workspace,s):void 0},listApprovals:t=>n.approvals?.list(t)??Promise.resolve([]),getApproval:t=>n.approvals?.get(t)??Promise.resolve(void 0),resolveApproval:async(t,e)=>{const s=await(n.approvals?.resolve(t,e));return s&&n.emit({type:"runtime.approval.resolved",requestId:s.requestId??"",sessionId:s.sessionId??"",agentId:s.agentId??"",approval:s}),s}}}

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

@@ -0,0 +1,6 @@
+import type { RuntimeArtifactStore, RuntimeReplayBundle, RuntimeStore } from "../types.js";
+export declare function exportRuntimeReplayBundle(input: {
+    store: RuntimeStore;
+    artifacts?: RuntimeArtifactStore;
+    requestId: string;
+}): RuntimeReplayBundle | undefined;

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

@@ -0,0 +1 @@
+import{createHash as t}from"node:crypto";import{listRuntimeArtifacts as e}from"./artifacts.js";export function exportRuntimeReplayBundle(t){const s=t.store.getRun(t.requestId);if(!s)return;const r=e({store:t.store,artifacts:t.artifacts,filter:{requestId:t.requestId}}),a={schemaVersion:1,kind:"stable-harness.replay-bundle",requestId:s.requestId,sessionId:s.sessionId,agentId:s.agentId,createdAt:s.completedAt??s.startedAt,run:s,events:s.events,artifacts:r};return{...a,integrity:{algorithm:"sha256",runHash:digest(s),eventsHash:digest(s.events),artifactsHash:digest(r),bundleHash:digest(a)}}}function digest(e){return t("sha256").update(function stableJson(t){return JSON.stringify(sortValue(t))}(e)).digest("hex")}function sortValue(t){return Array.isArray(t)?t.map(sortValue):t&&"object"==typeof t?Object.fromEntries(Object.entries(t).sort(([t],[e])=>t.localeCompare(e)).map(([t,e])=>[t,sortValue(e)])):t}

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

@@ -0,0 +1,29 @@
+import type { ApprovalQueue } from "@stable-harness/governance";
+import type { MemoryProvider, RuntimeMemoryStore } from "@stable-harness/memory";
+import type { CompiledWorkspace, RuntimeEvent, RuntimeMemoryContext, RuntimeRequest, WorkspaceAgent } from "../types.js";
+import type { RuntimeCapabilityModule } from "./capabilities.js";
+export declare function emitMemoryLifecycle(memory: RuntimeMemoryStore | undefined, emit: (event: RuntimeEvent) => void, requestId: string, sessionId: string, agentId: string, hook: "read-before-plan" | "read-before-finalize" | "write-after-run"): void;
+export declare function runMemoryRecall(input: {
+    memory: RuntimeMemoryStore | undefined;
+    emit: (event: RuntimeEvent) => void;
+    request: RuntimeRequest;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    workspace: CompiledWorkspace;
+}): Promise<RuntimeMemoryContext | undefined>;
+export declare function submitMemoryCandidates(input: {
+    memory: RuntimeMemoryStore | undefined;
+    approvals: ApprovalQueue | undefined;
+    emit: (event: RuntimeEvent) => void;
+    request: RuntimeRequest;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    workspace: CompiledWorkspace;
+}): Promise<void>;
+export declare function createMemoryRuntimeCapability(input: {
+    memory?: RuntimeMemoryStore;
+    memoryProviders?: MemoryProvider[];
+    approvals?: ApprovalQueue;
+}): RuntimeCapabilityModule;

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

@@ -0,0 +1 @@
+import{recallMemoryPlugins as e,runMemoryPlugins as r}from"../memory-plugins.js";export function emitMemoryLifecycle(e,r,s,t,o,a){e&&r({type:"runtime.memory.lifecycle",requestId:s,sessionId:t,agentId:o,hook:a})}export async function runMemoryRecall(e){if(!e.memory)return;if(emitMemoryLifecycle(e.memory,e.emit,e.requestId,e.sessionId,e.agent.id,"read-before-plan"),!1===e.request.memory?.recall)return;const r=resolveMemoryNamespace(e.workspace,e.agent,e.request),s=e.request.memory?.recall?.query??e.request.input,t=await e.memory.recall({namespace:r,query:s,limit:e.request.memory?.recall?.limit});return e.emit({type:"runtime.memory.recall.completed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,namespace:r,recordIds:t.records.map(e=>e.id),context:t.context}),{namespace:r,records:t.records,context:t.context}}export async function submitMemoryCandidates(e){if(!e.memory||!e.request.memory?.candidates?.length)return;emitMemoryLifecycle(e.memory,e.emit,e.requestId,e.sessionId,e.agent.id,"write-after-run");const r=resolveMemoryNamespace(e.workspace,e.agent,e.request);for(const s of e.request.memory.candidates){const t={...s,namespace:s.namespace??r},o=await e.memory.submitCandidate(t);if(e.emit({type:"runtime.memory.candidate.submitted",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,candidate:o.candidate,decision:o.decision,record:o.record}),"review"===o.decision.action&&e.approvals){const r=await e.approvals.create({kind:"memory_write",reason:o.decision.reason,requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,subject:{candidate:o.candidate,decision:o.decision}});e.emit({type:"runtime.memory.approval.requested",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,approval:r})}}}export function createMemoryRuntimeCapability(s){return{id:"runtime.memory",beforeAdapterRun:async r=>({memory:await runMemoryRecall({memory:s.memory,emit:r.emit,request:r.request,requestId:r.requestId,sessionId:r.sessionId,agent:r.agent,workspace:r.workspace}),pluginMemories:await e({providers:s.memoryProviders,request:r.request,agent:r.agent,workspace:r.workspace})}),async beforeAdapterResultContract(e){emitMemoryLifecycle(s.memory,e.emit,e.requestId,e.sessionId,e.agent.id,"read-before-finalize"),await submitMemoryCandidates({memory:s.memory,approvals:s.approvals,emit:e.emit,request:e.request,requestId:e.requestId,sessionId:e.sessionId,agent:e.agent,workspace:e.workspace})},async afterAdapterResponse(e){await r({providers:s.memoryProviders,emit:e.emit,request:e.request,requestId:e.requestId,sessionId:e.sessionId,agent:e.agent,workspace:e.workspace,result:e.result})}}}function resolveMemoryNamespace(e,r,s){return s.memory?.namespace??`${e.root}:${r.id}`}

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

@@ -0,0 +1,8 @@
+import type { RuntimeArtifactRecord, RuntimeArtifactStore } from "../types.js";
+type ArtifactState = {
+    records: RuntimeArtifactRecord[];
+    contents: Record<string, unknown>;
+};
+export declare function createInMemoryArtifactStore(initial?: ArtifactState): RuntimeArtifactStore;
+export declare function createJsonFileArtifactStore(filePath: string): RuntimeArtifactStore;
+export {};

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

@@ -0,0 +1 @@
+import{existsSync as t,mkdirSync as e,readFileSync as r,writeFileSync as n}from"node:fs";import i from"node:path";export function createInMemoryArtifactStore(t){const e=new Map((t?.records??[]).map(t=>[t.id,cloneRecord(t)])),r=new Map(Object.entries(t?.contents??{}).map(([t,e])=>[t,structuredClone(e)]));return{createArtifact(t){const n=function toRecord(t){return{id:t.id,kind:t.kind,uri:t.uri,metadata:t.metadata,requestId:t.requestId,sessionId:t.sessionId,agentId:t.agentId,contentType:t.contentType,createdAt:t.createdAt??(new Date).toISOString(),size:(e=t.content,Buffer.byteLength(JSON.stringify(e??null),"utf8"))};var e}(t);return e.set(n.id,n),r.set(n.id,structuredClone(t.content??null)),cloneRecord(n)},listArtifacts:t=>[...e.values()].filter(e=>function matchesFilter(t,e){return!e||!(e.requestId&&e.requestId!==t.requestId||e.sessionId&&e.sessionId!==t.sessionId||e.agentId&&e.agentId!==t.agentId)}(e,t)).map(cloneRecord),readArtifact(t){if(!r.has(t))throw new Error(`Artifact not found: ${t}`);return structuredClone(r.get(t))}}}export function createJsonFileArtifactStore(c){const o=i.resolve(c),s=createInMemoryArtifactStore(function readArtifactFile(e){if(!t(e))return{records:[],contents:{}};const n=JSON.parse(r(e,"utf8"));if(!function isState(t){return"object"==typeof t&&null!==t&&Array.isArray(t.records)&&"object"==typeof t.contents}(n))throw new Error(`Invalid artifact store file: ${e}`);return n}(o));return{createArtifact(t){const r=s.createArtifact(t);return function writeArtifactFile(t,r){e(i.dirname(t),{recursive:!0}),n(t,`${JSON.stringify({version:1,...r},null,2)}\n`)}(o,function snapshot(t){const e=t.listArtifacts(),r=Object.fromEntries(e.map(e=>[e.id,t.readArtifact(e.id)]));return{records:e,contents:r}}(s)),r},listArtifacts:t=>s.listArtifacts(t),readArtifact:t=>s.readArtifact(t)}}function cloneRecord(t){return structuredClone(t)}

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

@@ -0,0 +1,4 @@
+import type { CompiledWorkspace, RuntimeRequestInspection, RuntimeRequestSummary, RuntimeRunRecord, RuntimeSessionSummary } from "../../types.js";
+export declare function projectRequestSummary(run: RuntimeRunRecord): RuntimeRequestSummary;
+export declare function projectSessionSummaries(runs: RuntimeRunRecord[]): RuntimeSessionSummary[];
+export declare function projectRequestInspection(workspace: CompiledWorkspace, run: RuntimeRunRecord): RuntimeRequestInspection;

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

@@ -0,0 +1 @@
+import{applySpecDrivenPhaseTransition as t,createSpecDrivenWorkflowState as e}from"../../spec-driven/index.js";export function projectRequestSummary(t){return{requestId:t.requestId,sessionId:t.sessionId,agentId:t.agentId,parentRunId:t.parentRunId,state:t.state,startedAt:t.startedAt,completedAt:t.completedAt,eventCount:t.events.length,artifactCount:t.artifacts.length}}export function projectSessionSummaries(t){const e=new Map;for(const n of t)e.set(n.sessionId,[...e.get(n.sessionId)??[],n]);return[...e.entries()].map(([t,e])=>function projectSessionSummary(t,e){const n=[...e].sort((t,e)=>t.startedAt.localeCompare(e.startedAt));return{sessionId:t,requestCount:e.length,agentIds:[...new Set(e.map(t=>t.agentId))].sort(),states:countStates(e),startedAt:n[0]?.startedAt??"",updatedAt:latestTimestamp(e)}}(t,e)).sort((t,e)=>e.updatedAt.localeCompare(t.updatedAt))}export function projectRequestInspection(t,e){return{summary:projectRequestSummary(e),input:e.input,output:e.output,error:e.error,metadata:e.metadata,artifacts:e.artifacts,runtimeSnapshot:projectBindingSnapshot(t,e.agentId),...t.runtime.specDrivenWorkflow?{specDrivenWorkflow:projectSpecDrivenState(t.runtime.specDrivenWorkflow,e)}:{},timeline:projectTimeline(e)}}function projectSpecDrivenState(n,r){const s=new Set(n.phases.map(t=>t.id));return r.events.map(specDrivenTransition).filter(t=>void 0!==t&&s.has(t.phaseId)).reduce(t,e(n))}function specDrivenTransition(t){if(!function isSpecDrivenPhaseEvent(t){return t.type.startsWith("runtime.specDriven.phase.")}(t))return;const e=t.type.slice(25);return["started","blocked","completed","verified"].includes(e)?{phaseId:t.phaseId,status:e,..."artifact"in t&&t.artifact?{artifact:t.artifact}:{},..."reason"in t?{reason:t.reason}:{}}:void 0}function projectBindingSnapshot(t,e){const n=t.agents.get(e);return{workspaceRoot:t.root,agentId:e,backend:n?.backend??"unknown",modelRef:n?.modelRef,tools:[...n?.tools??[]],skills:[...n?.skills??[]],subagents:[...n?.subagents??[]]}}function projectTimeline(t){return t.events.map((t,e)=>({index:e,type:t.type,event:t}))}function countStates(t){return t.reduce((t,e)=>(t[e.state]=(t[e.state]??0)+1,t),{})}function latestTimestamp(t){return t.map(t=>t.completedAt??t.startedAt).sort((t,e)=>e.localeCompare(t))[0]??""}

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

@@ -0,0 +1,2 @@
+import type { RuntimeQueueStore } from "../types.js";
+export declare function createInMemoryRuntimeQueueStore(): RuntimeQueueStore;

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

@@ -0,0 +1 @@
+export function createInMemoryRuntimeQueueStore(){const e=new Map,t=new Map,r=new Map;return{enqueue(t){const r=t.enqueuedAt??(new Date).toISOString(),n=cloneQueueRecord({...t,enqueuedAt:r,attemptCount:t.attemptCount??0});return e.set(n.requestId,n),cloneQueueRecord(n)},listQueue:()=>sortQueue([...e.values()]).map(cloneQueueRecord),getQueuedRequest:t=>cloneOptional(e.get(t),cloneQueueRecord),claimNext(r){const n=function findClaimCandidate(e,t){const r=Date.parse(t.now??(new Date).toISOString());return sortQueue(e).find(e=>{const n=Date.parse(e.availableAt)<=r,o=!t.queueKey||e.queueKey===t.queueKey,u=!e.leaseExpiresAt||Date.parse(e.leaseExpiresAt)<=r;return n&&o&&u})}([...e.values()],r);if(!n)return;const o=r.now??(new Date).toISOString(),u=function claimRecord(e,t,r,n){return{...e,claimedBy:t,claimedAt:r,leaseExpiresAt:new Date(Date.parse(r)+n).toISOString(),attemptCount:e.attemptCount+1}}(n,r.workerId,o,r.leaseMs);return e.set(u.requestId,u),t.set(u.requestId,{requestId:u.requestId,cancelRequested:t.get(u.requestId)?.cancelRequested??!1,workerId:r.workerId,workerStartedAt:t.get(u.requestId)?.workerStartedAt??o,heartbeatAt:o}),cloneQueueRecord(u)},heartbeat(e){const r=t.get(e.requestId);if(!r||r.workerId!==e.workerId)return;const n={...r,heartbeatAt:e.now??(new Date).toISOString()};return t.set(e.requestId,n),cloneControl(n)},requestCancel(e){const r={...t.get(e.requestId),requestId:e.requestId,cancelRequested:!0,cancelReason:e.reason,cancelRequestedAt:e.now??(new Date).toISOString()};return t.set(e.requestId,r),cloneControl(r)},getControl:e=>cloneOptional(t.get(e),cloneControl),listStuck(r){const n=Date.parse(r.now??(new Date).toISOString());return[...e.values()].filter(e=>function isStuck(e,t,r,n){if(!e.claimedAt)return!1;const o=Date.parse(t?.heartbeatAt??e.claimedAt);return!!e.leaseExpiresAt&&Date.parse(e.leaseExpiresAt)<r||r-o>n}(e,t.get(e.requestId),n,r.staleAfterMs)).map(cloneQueueRecord)},saveRecoveryIntent:e=>(r.set(e.requestId,cloneRecovery(e)),cloneRecovery(e)),getRecoveryIntent:e=>cloneOptional(r.get(e),cloneRecovery),clearRecoveryIntent:e=>r.delete(e)}}function sortQueue(e){return[...e].sort((e,t)=>{const r=t.priority-e.priority;return 0===r?e.enqueuedAt.localeCompare(t.enqueuedAt):r})}function cloneOptional(e,t){return e?t(e):void 0}function cloneQueueRecord(e){return structuredClone(e)}function cloneControl(e){return structuredClone(e)}function cloneRecovery(e){return structuredClone(e)}

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

@@ -0,0 +1,3 @@
+import type { RuntimeRunRecord, RuntimeStore } from "../types.js";
+export declare function createInMemoryRuntimeStore(initialRuns?: RuntimeRunRecord[]): RuntimeStore;
+export declare function createJsonFileRuntimeStore(filePath: string): RuntimeStore;

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

@@ -0,0 +1 @@
+import{existsSync as e,mkdirSync as t,readFileSync as n,writeFileSync as r}from"node:fs";import u from"node:path";export function createInMemoryRuntimeStore(e=[]){const t=new Map(e.map(e=>[e.requestId,cloneRun(e)]));return{createRun(e){t.set(e.requestId,cloneRun(e))},updateRun(e,n){const r=t.get(e);if(r)return Object.assign(r,function clonePatch(e){return structuredClone(e)}(n)),cloneRun(r)},appendEvent(e){const n=t.get(e.requestId);if(!n)return;const r=function eventArtifact(e){return"artifact"in e&&e.artifact?e.artifact:void 0}(e);return r&&!n.artifacts.some(e=>e.id===r.id)&&n.artifacts.push(structuredClone(r)),n.events.push(function cloneEvent(e){return structuredClone(e)}(e)),cloneRun(n)},getRun:e=>function cloneOptionalRun(e){return e?cloneRun(e):void 0}(t.get(e)),listRuns:e=>[...t.values()].filter(t=>function matchesFilter(e,t){return!t||!(t.agentId&&t.agentId!==e.agentId||t.sessionId&&t.sessionId!==e.sessionId||t.state&&t.state!==e.state)}(t,e)).map(cloneRun)}}export function createJsonFileRuntimeStore(t){const r=u.resolve(t),i=createInMemoryRuntimeStore(function readStoreFile(t){if(!e(t))return[];const r=JSON.parse(n(t,"utf8"));if(!isRecord(r)||!Array.isArray(r.runs))throw new Error(`Invalid runtime store file: ${t}`);return r.runs.map(assertRunRecord)}(r));return{createRun(e){i.createRun(e),writeStoreFile(r,i.listRuns())},updateRun(e,t){const n=i.updateRun(e,t);return writeStoreFile(r,i.listRuns()),n},appendEvent(e){const t=i.appendEvent(e);return writeStoreFile(r,i.listRuns()),t},getRun:e=>i.getRun(e),listRuns:e=>i.listRuns(e)}}function writeStoreFile(e,n){t(u.dirname(e),{recursive:!0}),r(e,`${JSON.stringify({version:1,runs:n},null,2)}\n`)}function assertRunRecord(e){if(!isRecord(e)||"string"!=typeof e.requestId)throw new Error("Invalid runtime run record in store file");return cloneRun(e)}function cloneRun(e){return structuredClone(e)}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)}