stable-harness 0.0.37 → 0.0.39

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

@@ -0,0 +1,48 @@
+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[];
+    modules: Record<string, Record<string, unknown>>;
+};
+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={modules:{}};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]),t.modules&&(e.modules=function mergeModuleState(e,t){const o={...e};for(const[e,r]of Object.entries(t))o[e]={...o[e]??{},...r};return o}(e.modules,t.modules)))}

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/policy/projection.d.ts

@@ -0,0 +1,11 @@
+import type { CompiledWorkspace, RuntimeRequest, WorkspaceAgent } from "../../types.js";
+export type RuntimePolicyProjectionInput = {
+    workspace: CompiledWorkspace;
+    agent?: WorkspaceAgent;
+    request: RuntimeRequest;
+};
+export type RuntimePolicyProjection = {
+    systemPromptSections: string[];
+};
+export declare function projectRuntimePolicies(input: RuntimePolicyProjectionInput): RuntimePolicyProjection;
+export declare function buildRuntimeSystemPrompt(input: RuntimePolicyProjectionInput, basePrompt?: string): string | undefined;

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

@@ -0,0 +1 @@
+export function projectRuntimePolicies(e){return{systemPromptSections:[skillInventoryPolicy(e),responseLanguagePolicy(e),responsePresentationPolicy(e)].filter(e=>Boolean(e))}}export function buildRuntimeSystemPrompt(e,t){const n=[t,...projectRuntimePolicies(e).systemPromptSections].filter(e=>Boolean(e));return n.length>0?n.join("\n\n"):void 0}function skillInventoryPolicy(e){const t=(e.agent?.skills??[]).map(t=>e.workspace.skills.get(t)).filter(e=>Boolean(e));if(0!==t.length)return["## Stable Harness Skill Inventory","Use only the skills listed in this workspace inventory. Do not infer or invent skill names, skill directories, or SKILL.md paths from generic examples.","Skill files are already registered with the backend. Do not read local SKILL.md files or skill directories through filesystem tools.","If none of these skills match the task, continue with the configured tools and collected evidence instead of reading an unlisted skill path.",t.map(e=>{const t=e.allowedTools.length>0?`; allowed tools: ${e.allowedTools.join(", ")}`:"",n=e.description?`: ${e.description}${t}`:t;return`- ${e.id}${n}`}).join("\n")].join("\n")}function responseLanguagePolicy(e){const t=readRecord(e.workspace.runtime.responseLanguage);if("matchUser"!==(readString(t.mode)??readString(t.strategy)))return;const n=function detectRequestLanguage(e){return/\p{Script=Han}/u.test(e)?"Chinese":/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(e)?"Japanese":/\p{Script=Hangul}/u.test(e)?"Korean":/\p{Script=Arabic}/u.test(e)?"Arabic":/\p{Script=Hebrew}/u.test(e)?"Hebrew":/\p{Script=Thai}/u.test(e)?"Thai":/\p{Script=Cyrillic}/u.test(e)?"Cyrillic-script language":void 0}(e.request.input);return["Stable runtime response language policy:",...n?[`- Detected request language: ${n}.`]:[],"- Match the final answer language to the original user request unless the user explicitly asks for another language.","- If tool or subagent evidence is in a different language, translate the final user-facing answer into the detected request language.","- When delegating to subagents, include the same response-language requirement in delegated instructions.","- Do not call another tool or subagent only to translate, rewrite, format, or synthesize a completed answer.",`Original user request:\n${e.request.input}`].join("\n")}function responsePresentationPolicy(e){const t=readRecord(e.workspace.runtime.responsePresentation);if(!0===t.enabled&&!function hasStructuredResponseFormat(e){return void 0!==e?.config.responseFormat||isRecord(e?.config.deepagents)&&void 0!==e.config.deepagents.responseFormat}(e.agent))return"markdown"===(readString(t.style)??"markdown")?["Stable runtime final-answer presentation policy:","- For user-facing natural-language final answers, use GitHub-flavored Markdown.","- Prefer clear section headings, short paragraphs, and concise bullets over dense prose.","- Use tables only when they make comparison or planning details easier to scan.","- For detailed investigations, plans, or reports, include assumptions, findings, recommendations, and concrete next steps.","- Preserve exact plain text, JSON, code, or other structured output when the user or response format asks for it.","- Do not end with generic follow-up offers; deliver the requested answer directly."].join("\n"):void 0}function readRecord(e){return isRecord(e)?e:{}}function readString(e){return"string"==typeof e&&e.trim()?e:void 0}function isRecord(e){return"object"==typeof e&&null!==e&&!Array.isArray(e)}