stable-harness 0.0.1 → 0.0.3

package/packages/core/dist/memory-plugins/maintenance.d.ts

@@ -0,0 +1,42 @@
+import type { MemoryMaintenanceOperation, MemoryProvider } from "@stable-harness/memory";
+import type { ApprovalQueue, SkillCandidateStore } from "@stable-harness/governance";
+import type { CompiledWorkspace, RuntimeEmit, WorkspaceAgent } from "../types.js";
+export type MemoryMaintenanceTarget = {
+    name: string;
+    run(input: MemoryMaintenanceTargetInput): Promise<MemoryMaintenanceResult>;
+};
+export type MemoryMaintenanceTargetInput = {
+    emit: RuntimeEmit;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    workspace: CompiledWorkspace;
+    prompt: string;
+};
+export type MemoryMaintenanceResult = {
+    operations?: MemoryMaintenanceOperation[];
+    metadata?: Record<string, unknown>;
+};
+export type MemoryMaintenanceDaemon = {
+    runOnce(input?: Partial<Pick<MemoryMaintenanceTargetInput, "requestId" | "sessionId" | "agent">>): Promise<MemoryMaintenanceResult[]>;
+    start(): void;
+    stop(): void;
+};
+export declare function createMemoryMaintenanceDaemon(input: {
+    workspace: CompiledWorkspace;
+    emit?: RuntimeEmit;
+    targets: MemoryMaintenanceTarget[];
+    intervalMs?: number;
+    prompt?: string;
+    defaultAgentId?: string;
+}): MemoryMaintenanceDaemon;
+export declare function createLangMemMaintenanceTarget(input: {
+    providers: MemoryProvider[] | undefined;
+    limit?: number;
+}): MemoryMaintenanceTarget;
+export declare function createSkillCandidateMinerTarget(input: {
+    providers: MemoryProvider[] | undefined;
+    store: SkillCandidateStore;
+    approvals?: ApprovalQueue;
+    minEvidenceCount?: number;
+}): MemoryMaintenanceTarget;

package/packages/core/dist/memory-plugins/maintenance.js

@@ -0,0 +1 @@
+import{formatError as e,readRecord as t,readWorkspaceId as n,resolveEnabledMemories as a,resolveMemoryProvider as r,resolvePluginNamespace as s}from"./shared.js";export function createMemoryMaintenanceDaemon(e){let t;const n=e.emit??(()=>{});return{async runOnce(t={}){const a=t.agent??function(e,t){const n=e.agents.get(t??e.runtime.defaultAgentId);if(!n)throw new Error("Memory maintenance requires a configured default agent");return n}(e.workspace,e.defaultAgentId),r={emit:n,requestId:t.requestId??`memory-maintenance-${Date.now()}`,sessionId:t.sessionId??"memory-maintenance",agent:a,workspace:e.workspace,prompt:e.prompt??u(e.workspace)},s=[];for(const t of e.targets)s.push(await o(r,t));return s},start(){e.intervalMs&&!t&&(t=setInterval(()=>{this.runOnce()},e.intervalMs))},stop(){t&&(clearInterval(t),t=void 0)}}}export function createLangMemMaintenanceTarget(e){return{name:"LangMem",async run(t){const n=[];for(const o of a(t.workspace,"write")){const a=r(e.providers??[],o.provider);if(!a)continue;const c=s(t.workspace,t.agent,{input:"",sessionId:t.sessionId},o),d=i(await a.search({namespace:c,query:t.prompt,limit:e.limit??100}),await a.search({namespace:c,query:"",limit:e.limit??100}));n.push(...await a.consolidate({records:d}))}return{operations:n}}}}export function createSkillCandidateMinerTarget(e){return{name:"skillCandidateMiner",async run(t){const n=await async function(e,t){const n=[];for(const o of a(t.workspace,"all")){const a=r(e??[],o.provider);if(!a)continue;const c=s(t.workspace,t.agent,{input:"",sessionId:t.sessionId},o);n.push(...i(await a.search({namespace:c,query:t.prompt,limit:100}),await a.search({namespace:c,query:"",limit:100})))}return i(n,[])}(e.providers,t),o=function(e){const t=new Map;for(const n of e){const e=c(n);e&&t.set(e,[...t.get(e)??[],n])}return t}(n),m=[];for(const[n,a]of o){if(a.length<(e.minEvidenceCount??3))continue;const r=await e.store.upsert(d(t.workspace,n,a));m.push(r),t.emit({type:"skill.candidate.created",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,candidateId:r.id,name:r.name,confidence:r.confidence,evidenceCount:r.evidenceCount,status:r.status,proposedPath:r.proposedPath}),await(e.approvals?.create({kind:"skill_candidate",reason:`Review mined skill candidate ${r.name}`,requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,subject:{candidate:r}}))}return{operations:[],metadata:{candidateCount:m.length}}}}}async function o(t,n){t.emit({type:"memory.maintenance.started",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,target:n.name});try{const e=await n.run(t);return t.emit({type:"memory.maintenance.completed",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,target:n.name,operationCount:e.operations?.length??0}),e}catch(a){return t.emit({type:"memory.maintenance.failed",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,target:n.name,error:e(a)}),{operations:[],metadata:{error:e(a)}}}}function i(e,t){const n=new Map;for(const a of[...e,...t])n.set(a.id,a);return[...n.values()]}function c(e){const n=t(e.metadata?.skillCandidate),a=t(t(e.metadata?.requestMetadata)?.skillCandidate),r=n?.name??a?.name;return"string"==typeof r&&r.trim()?function(e){return e.toLowerCase().replace(/[^a-z0-9]+/gu,"-").replace(/^-+|-+$/gu,"")}(r):void 0}function d(e,t,a){const r=function(e){return e.split("-").filter(Boolean).map(e=>`${e[0]?.toUpperCase()??""}${e.slice(1)}`).join(" ")}(t);return{workspaceId:n(e),name:t,status:"review_required",confidence:Math.min(.95,.55+.1*a.length),proposedPath:`resources/skills/${t}/SKILL.md`,title:r,summary:`Repeated stable workflow mined from ${a.length} memory records.`,draftMarkdown:m(r,a),evidence:a.map(e=>({evidenceType:"memory_record",evidenceRef:e.id,summary:e.summary??e.content.slice(0,160),weight:e.confidence}))}}function m(e,t){return[`# ${e}`,"","## Purpose","","Apply this stable workflow when the task matches the evidence.","","## Evidence","",t.map(e=>`- ${e.summary??e.content}`).join("\n")].join("\n")}function u(e){const n=t(e.runtime.memory?.maintenance);return"string"==typeof n?.prompt?n.prompt:"durable preferences workspace facts reusable procedures prior corrections stale duplicated contradicted memories"}

package/packages/core/dist/memory-plugins/shared.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryProvider } from "@stable-harness/memory";
+import type { CompiledWorkspace, RuntimeRequest, WorkspaceAgent, WorkspaceMemory } from "../types.js";
+export declare function resolveEnabledMemories(workspace: CompiledWorkspace, phase?: "all" | "recall" | "write"): WorkspaceMemory[];
+export declare function resolvePluginNamespace(workspace: CompiledWorkspace, agent: WorkspaceAgent, request: RuntimeRequest, memory: WorkspaceMemory): string;
+export declare function resolveMemoryProvider(providers: MemoryProvider[], configuredProvider: string): MemoryProvider | undefined;
+export declare function readRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function readWorkspaceId(workspace: CompiledWorkspace): string;
+export declare function formatError(error: unknown): string;

package/packages/core/dist/memory-plugins/shared.js

@@ -0,0 +1 @@
+export function resolveEnabledMemories(r,o="all"){const n=r.runtime.memory??{};if(!function(r,o){return!1!==r.enabled&&("recall"!==o||!1!==r.recall&&!1!==r.read&&!1!==e(r,"LangMem","read"))&&("write"!==o||!1!==r.write&&!1!==e(r,"LangMem","write"))}(n,o))return[];const t=Array.isArray(n.refs)?n.refs.filter(e=>"string"==typeof e):[];return(t.length>0?t:[...r.memories.keys()]).map(e=>r.memories.get(e)).filter(e=>Boolean(e?.enabled))}export function resolvePluginNamespace(e,r,o,n){const t=readWorkspaceId(e),i=n.profile??n.id;return"agent"===i?`${t}:agent:${r.id}:${n.id}`:"user"===i?`${t}:user:${function(e){return e.metadata?.userId??"local"}(o)}:${n.id}`:"session"===i?`${t}:session:${o.sessionId??"default"}:${n.id}`:`${t}:${i}:${n.id}`}export function resolveMemoryProvider(e,r){return e.find(e=>e.name===r||e.name===`${r}-service`)}export function readRecord(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}export function readWorkspaceId(e){return e.runtime.workspaceId??e.runtime.profile??e.root}export function formatError(e){return e instanceof Error?e.message:String(e)}function e(e,r,o){const n=readRecord(e[r])??readRecord(e[r.toLowerCase()]);return"boolean"==typeof n?.[o]?n[o]:void 0}

package/packages/core/dist/memory-plugins.d.ts

@@ -1,27 +1,8 @@
-import type { MemoryMaintenanceOperation, MemoryProvider, MemoryRecord } from "@stable-harness/memory";
-import type { ApprovalQueue, SkillCandidateStore } from "@stable-harness/governance";
-import type { CompiledWorkspace, RuntimeEmit, RuntimeOutput, RuntimeRequest, WorkspaceAgent, WorkspaceMemory } from "./types.js";
-export type MemoryMaintenanceTarget = {
-    name: string;
-    run(input: MemoryMaintenanceTargetInput): Promise<MemoryMaintenanceResult>;
-};
-export type MemoryMaintenanceTargetInput = {
-    emit: RuntimeEmit;
-    requestId: string;
-    sessionId: string;
-    agent: WorkspaceAgent;
-    workspace: CompiledWorkspace;
-    prompt: string;
-};
-export type MemoryMaintenanceResult = {
-    operations?: MemoryMaintenanceOperation[];
-    metadata?: Record<string, unknown>;
-};
-export type MemoryMaintenanceDaemon = {
-    runOnce(input?: Partial<Pick<MemoryMaintenanceTargetInput, "requestId" | "sessionId" | "agent">>): Promise<MemoryMaintenanceResult[]>;
-    start(): void;
-    stop(): void;
-};
+import type { MemoryProvider, MemoryRecord } from "@stable-harness/memory";
+import type { CompiledWorkspace, RuntimeEmit, RuntimeOutput, RuntimeRequest, WorkspaceAgent } from "./types.js";
+export { resolveEnabledMemories, resolvePluginNamespace, } from "./memory-plugins/shared.js";
+export type { MemoryMaintenanceDaemon, MemoryMaintenanceResult, MemoryMaintenanceTarget, MemoryMaintenanceTargetInput, } from "./memory-plugins/maintenance.js";
+export { createLangMemMaintenanceTarget, createMemoryMaintenanceDaemon, createSkillCandidateMinerTarget, } from "./memory-plugins/maintenance.js";
 export declare function runMemoryPlugins(input: {
     providers: MemoryProvider[] | undefined;
     emit: RuntimeEmit;
@@ -42,27 +23,3 @@ export declare function recallMemoryPlugins(input: {
     records: MemoryRecord[];
     context: string;
 }>>;
-export declare function resolveEnabledMemories(workspace: CompiledWorkspace, phase?: "all" | "recall" | "write"): WorkspaceMemory[];
-export declare function resolveDeepAgentsNativeMemories(workspace: CompiledWorkspace): WorkspaceMemory[];
-export declare function createMemoryMaintenanceDaemon(input: {
-    workspace: CompiledWorkspace;
-    emit?: RuntimeEmit;
-    targets: MemoryMaintenanceTarget[];
-    intervalMs?: number;
-    prompt?: string;
-    defaultAgentId?: string;
-}): MemoryMaintenanceDaemon;
-export declare function createLangMemMaintenanceTarget(input: {
-    providers: MemoryProvider[] | undefined;
-    limit?: number;
-}): MemoryMaintenanceTarget;
-export declare function createDeepAgentsMemoryMaintenanceTarget(input?: {
-    run?: (context: MemoryMaintenanceTargetInput) => Promise<MemoryMaintenanceResult>;
-}): MemoryMaintenanceTarget;
-export declare function createSkillCandidateMinerTarget(input: {
-    providers: MemoryProvider[] | undefined;
-    store: SkillCandidateStore;
-    approvals?: ApprovalQueue;
-    minEvidenceCount?: number;
-}): MemoryMaintenanceTarget;
-export declare function resolvePluginNamespace(workspace: CompiledWorkspace, agent: WorkspaceAgent, request: RuntimeRequest, memory: WorkspaceMemory): string;

package/packages/core/dist/memory-plugins.js

@@ -1 +1 @@
-export async function runMemoryPlugins(n){const t=resolveEnabledMemories(n.workspace,"write");if(n.providers?.length&&0!==t.length&&!1!==n.request.metadata?.memoryWrite)for(const r of t)await e(n,r)}export async function recallMemoryPlugins(e){const t=resolveEnabledMemories(e.workspace,"recall");if(!e.providers?.length||0===t.length)return[];const o=await Promise.all(t.map(async t=>async function(e,t){const o=n(e.providers??[],t.provider);if(!o)return;const s=resolvePluginNamespace(e.workspace,e.agent,e.request,t),i=await o.search({namespace:s,query:r(e),limit:a(e.workspace)});return{namespace:s,records:i,context:i.map(e=>`- ${e.summary??e.content}\n  ${e.content}`).join("\n")}}(e,t)));return o.filter(e=>Boolean(e?.context))}export function resolveEnabledMemories(e,n="all"){const t=e.runtime.memory??{};if(!function(e,n){return!1!==e.enabled&&("recall"!==n||!1!==e.recall&&!1!==e.read&&!1!==m(e,"LangMem","read"))&&("write"!==n||!1!==e.write&&!1!==m(e,"LangMem","write"))}(t,n))return[];const r=Array.isArray(t.refs)?t.refs.filter(e=>"string"==typeof e):[];return(r.length>0?r:[...e.memories.keys()]).map(n=>e.memories.get(n)).filter(e=>Boolean(e?.enabled))}export function resolveDeepAgentsNativeMemories(e){return!1===m(e.runtime.memory??{},"deepagentsMem","read")?[]:resolveEnabledMemories(e,"all")}export function createMemoryMaintenanceDaemon(e){let n;const r=e.emit??(()=>{});return{async runOnce(n={}){const a=n.agent??function(e,n){const t=e.agents.get(n??e.runtime.defaultAgentId);if(!t)throw new Error("Memory maintenance requires a configured default agent");return t}(e.workspace,e.defaultAgentId),o={emit:r,requestId:n.requestId??`memory-maintenance-${Date.now()}`,sessionId:n.sessionId??"memory-maintenance",agent:a,workspace:e.workspace,prompt:e.prompt??d(e.workspace)},s=[];for(const n of e.targets)s.push(await t(o,n));return s},start(){e.intervalMs&&!n&&(n=setInterval(()=>{this.runOnce()},e.intervalMs))},stop(){n&&(clearInterval(n),n=void 0)}}}export function createLangMemMaintenanceTarget(e){return{name:"LangMem",async run(t){const r=[];for(const a of resolveEnabledMemories(t.workspace,"write")){const s=n(e.providers??[],a.provider);if(!s)continue;const i=resolvePluginNamespace(t.workspace,t.agent,{input:"",sessionId:t.sessionId},a),c=o(await s.search({namespace:i,query:t.prompt,limit:e.limit??100}),await s.search({namespace:i,query:"",limit:e.limit??100}));r.push(...await s.consolidate({records:c}))}return{operations:r}}}}export function createDeepAgentsMemoryMaintenanceTarget(e={}){return{name:"deepagentsMem",run:async n=>e.run?e.run(n):{operations:[],metadata:{skipped:!0,reason:"No DeepAgents memory maintainer configured"}}}}export function createSkillCandidateMinerTarget(e){return{name:"skillCandidateMiner",async run(t){const r=await async function(e,t){const r=[];for(const a of resolveEnabledMemories(t.workspace,"all")){const s=n(e??[],a.provider);if(!s)continue;const i=resolvePluginNamespace(t.workspace,t.agent,{input:"",sessionId:t.sessionId},a);r.push(...o(await s.search({namespace:i,query:t.prompt,limit:100}),await s.search({namespace:i,query:"",limit:100})))}return o(r,[])}(e.providers,t),a=function(e){const n=new Map;for(const t of e){const e=s(t);e&&n.set(e,[...n.get(e)??[],t])}return n}(r),c=[];for(const[n,r]of a){if(r.length<(e.minEvidenceCount??3))continue;const a=await e.store.upsert(i(t.workspace,n,r));c.push(a),t.emit({type:"skill.candidate.created",requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,candidateId:a.id,name:a.name,confidence:a.confidence,evidenceCount:a.evidenceCount,status:a.status,proposedPath:a.proposedPath}),await(e.approvals?.create({kind:"skill_candidate",reason:`Review mined skill candidate ${a.name}`,requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,subject:{candidate:a}}))}return{operations:[],metadata:{candidateCount:c.length}}}}}export function resolvePluginNamespace(e,n,t,r){const a=p(e),o=r.profile??r.id;return"agent"===o?`${a}:agent:${n.id}:${r.id}`:"user"===o?`${a}:user:${function(e){return e.metadata?.userId??"local"}(t)}:${r.id}`:"session"===o?`${a}:session:${t.sessionId??"default"}:${r.id}`:`${a}:${o}:${r.id}`}async function e(e,t){const r=n(e.providers??[],t.provider);if(!r)return;const a=resolvePluginNamespace(e.workspace,e.agent,e.request,t);e.emit({type:"memory.plugin.started",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,memoryId:t.id,provider:r.name,namespace:a});try{const n=await r.propose(function(e,n,t){return{namespace:t,content:[`User input:\n${e.request.input}`,`Agent output:\n${e.result.text}`].join("\n\n"),sourceType:"runtime-run",sourceRef:e.requestId,metadata:{memoryId:n.id,provider:n.provider,profile:n.profile,mode:n.mode,prompts:n.prompts,workspaceRoot:e.workspace.root,agentId:e.agent.id,sessionId:e.sessionId,requestMetadata:e.request.metadata}}}(e,t,a));e.emit({type:"memory.plugin.completed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,memoryId:t.id,provider:r.name,namespace:a,candidateCount:n.length})}catch(n){e.emit({type:"memory.plugin.failed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,memoryId:t.id,provider:r.name,namespace:a,error:l(n)})}}function n(e,n){return e.find(e=>e.name===n||e.name===`${n}-service`)}async function t(e,n){e.emit({type:"memory.maintenance.started",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,target:n.name});try{const t=await n.run(e);return e.emit({type:"memory.maintenance.completed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,target:n.name,operationCount:t.operations?.length??0}),t}catch(t){return e.emit({type:"memory.maintenance.failed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,target:n.name,error:l(t)}),{operations:[],metadata:{error:l(t)}}}}function r(e){const n=[`task: ${e.request.input}`,`workspace: ${p(e.workspace)}`,`agent: ${e.agent.id}`,"memory_needed: durable preferences, workspace facts, reusable procedures, prior corrections"],t=(r=e.request.metadata,"string"==typeof r?.recentContext?r.recentContext.slice(0,3e3):Array.isArray(r?.recentTurns)?r.recentTurns.filter(e=>"string"==typeof e).slice(-6).join("\n").slice(0,3e3):void 0);var r;return t?[...n,`recent_context: ${t}`].join("\n"):n.join("\n")}function a(e){const n=u(e.runtime.memory?.LangMem),t=u(n?.recall),r=t?.topK??t?.limit;return"number"==typeof r&&Number.isFinite(r)?r:10}function o(e,n){const t=new Map;for(const r of[...e,...n])t.set(r.id,r);return[...t.values()]}function s(e){const n=u(e.metadata?.skillCandidate),t=u(u(e.metadata?.requestMetadata)?.skillCandidate),r=n?.name??t?.name;return"string"==typeof r&&r.trim()?function(e){return e.toLowerCase().replace(/[^a-z0-9]+/gu,"-").replace(/^-+|-+$/gu,"")}(r):void 0}function i(e,n,t){const r=function(e){return e.split("-").filter(Boolean).map(e=>`${e[0]?.toUpperCase()??""}${e.slice(1)}`).join(" ")}(n);return{workspaceId:p(e),name:n,status:"review_required",confidence:Math.min(.95,.55+.1*t.length),proposedPath:`resources/skills/${n}/SKILL.md`,title:r,summary:`Repeated stable workflow mined from ${t.length} memory records.`,draftMarkdown:c(r,t),evidence:t.map(e=>({evidenceType:"memory_record",evidenceRef:e.id,summary:e.summary??e.content.slice(0,160),weight:e.confidence}))}}function c(e,n){return[`# ${e}`,"","## Purpose","","Apply this stable workflow when the task matches the evidence.","","## Evidence","",n.map(e=>`- ${e.summary??e.content}`).join("\n")].join("\n")}function d(e){const n=u(e.runtime.memory?.maintenance);return"string"==typeof n?.prompt?n.prompt:"durable preferences workspace facts reusable procedures prior corrections stale duplicated contradicted memories"}function u(e){return"object"!=typeof e||null===e||Array.isArray(e)?void 0:e}function m(e,n,t){const r=u(e[n])??u(e[n.toLowerCase()]);return"boolean"==typeof r?.[t]?r[t]:void 0}function p(e){return e.runtime.workspaceId??e.runtime.profile??e.root}function l(e){return e instanceof Error?e.message:String(e)}
+import{formatError as e,readRecord as r,readWorkspaceId as t,resolveEnabledMemories as n,resolveMemoryProvider as o,resolvePluginNamespace as s}from"./memory-plugins/shared.js";export{resolveEnabledMemories,resolvePluginNamespace}from"./memory-plugins/shared.js";export{createLangMemMaintenanceTarget,createMemoryMaintenanceDaemon,createSkillCandidateMinerTarget}from"./memory-plugins/maintenance.js";export async function runMemoryPlugins(e){const r=n(e.workspace,"write");if(e.providers?.length&&0!==r.length&&!1!==e.request.metadata?.memoryWrite)for(const t of r)await a(e,t)}export async function recallMemoryPlugins(e){const r=n(e.workspace,"recall");if(!e.providers?.length||0===r.length)return[];const t=await Promise.all(r.map(async r=>async function(e,r){const t=o(e.providers??[],r.provider);if(!t)return;const n=s(e.workspace,e.agent,e.request,r),a=await t.search({namespace:n,query:i(e),limit:c(e.workspace)});return{namespace:n,records:a,context:a.map(e=>`- ${e.summary??e.content}\n  ${e.content}`).join("\n")}}(e,r)));return t.filter(e=>Boolean(e?.context))}async function a(r,t){const n=o(r.providers??[],t.provider);if(!n)return;const a=s(r.workspace,r.agent,r.request,t);r.emit({type:"memory.plugin.started",requestId:r.requestId,sessionId:r.sessionId,agentId:r.agent.id,memoryId:t.id,provider:n.name,namespace:a});try{const e=await n.propose(function(e,r,t){return{namespace:t,content:[`User input:\n${e.request.input}`,`Agent output:\n${e.result.text}`].join("\n\n"),sourceType:"runtime-run",sourceRef:e.requestId,metadata:{memoryId:r.id,provider:r.provider,profile:r.profile,mode:r.mode,prompts:r.prompts,workspaceRoot:e.workspace.root,agentId:e.agent.id,sessionId:e.sessionId,requestMetadata:e.request.metadata}}}(r,t,a));r.emit({type:"memory.plugin.completed",requestId:r.requestId,sessionId:r.sessionId,agentId:r.agent.id,memoryId:t.id,provider:n.name,namespace:a,candidateCount:e.length})}catch(o){r.emit({type:"memory.plugin.failed",requestId:r.requestId,sessionId:r.sessionId,agentId:r.agent.id,memoryId:t.id,provider:n.name,namespace:a,error:e(o)})}}function i(e){const r=[`task: ${e.request.input}`,`workspace: ${t(e.workspace)}`,`agent: ${e.agent.id}`,"memory_needed: durable preferences, workspace facts, reusable procedures, prior corrections"],n=(o=e.request.metadata,"string"==typeof o?.recentContext?o.recentContext.slice(0,3e3):Array.isArray(o?.recentTurns)?o.recentTurns.filter(e=>"string"==typeof e).slice(-6).join("\n").slice(0,3e3):void 0);var o;return n?[...r,`recent_context: ${n}`].join("\n"):r.join("\n")}function c(e){const t=r(e.runtime.memory?.LangMem),n=r(t?.recall),o=n?.topK??n?.limit;return"number"==typeof o&&Number.isFinite(o)?o:10}

package/packages/core/dist/recovery/tool-call.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeEvent, RuntimeRequest } from "../types.js";
+export declare function toolCallRecoveryEnabled(policy: unknown): boolean;
+export declare function isRecoverableAdapterError(error: unknown, policy: unknown): boolean;
+export declare function buildAdapterErrorRecoveryPrompt(request: RuntimeRequest, error: unknown, policy: unknown): RuntimeRequest;
+export declare function buildResultRecoveryRequest(input: {
+    request: RuntimeRequest;
+    output: string;
+    events: RuntimeEvent[];
+    policy: unknown;
+}): RuntimeRequest | undefined;
+export declare function assertNoRawToolCallOutput(output: string, policy: unknown): void;
+export declare function containsRawToolCallOutput(output: string, policy: unknown): boolean;
+export declare function rawToolCallFailureMessage(): string;

package/packages/core/dist/recovery/tool-call.js

@@ -0,0 +1 @@
+export function toolCallRecoveryEnabled(t){return!0===o(t).enabled}export function isRecoverableAdapterError(t,e){const n=o(e);if(!0!==n.enabled)return!1;const a=t instanceof Error?t.message:String(t);return r(n.adapterErrorPatterns,[/XML syntax error|tool.?call.*syntax|malformed.*(?:XML|tool)|Non string tool message content/iu]).some(t=>t.test(a))}export function buildAdapterErrorRecoveryPrompt(e,r,n){const a=r instanceof Error?r.message:String(r),l=o(n).instruction;return t(e,["Stable runtime recovery: the backend failed while parsing a tool call.",`Parser error: ${a}`,"string"==typeof l?l:"Continue the same user request using the backend's normal tool-calling mechanism, then return a final human-readable answer.","Do not print raw tool-call markup, JSON tool-call envelopes, or pseudo tool-call text in the final answer."])}export function buildResultRecoveryRequest(r){const a=o(r.policy);if(!0!==a.enabled)return;if(e(r.output,a))return t(r.request,["Stable runtime recovery: your previous final answer printed raw tool-call markup instead of executing the tool.","Continue the same user request by calling the available upstream tool normally, then return a final human-readable answer. Do not print XML, JSON, or pseudo tool-call text in the final answer.","","Previous invalid final answer:",r.output]);const l=function(t,e){const o=(r=e.eventRecoveryHints,(Array.isArray(r)?r:[]).flatMap(t=>n(t)&&"string"==typeof t.instruction?[{..."string"==typeof t.toolId?{toolId:t.toolId}:{},..."string"==typeof t.phase?{phase:t.phase}:{},..."string"==typeof t.outputIncludes?{outputIncludes:t.outputIncludes}:{},instruction:t.instruction}]:[]));var r;if(0!==o.length)return t.flatMap(t=>function(t,e){const o="adapter.event"===t.type&&n(t.event)?t.event:void 0;return o?e.filter(t=>function(t,e){return(!e.toolId||t.toolId===e.toolId)&&(!e.phase||t.phase===e.phase)&&(!e.outputIncludes||"string"==typeof t.output&&t.output.includes(e.outputIncludes))}(o,t)).map(t=>({output:"string"==typeof o.output?o.output:"Adapter event matched configured recovery hint.",instruction:t.instruction})):[]}(t,o)).at(-1)}(r.events,a);return l?t(r.request,["Stable runtime recovery: a previous adapter event matched a configured recovery hint.",l.output,l.instruction]):void 0}export function assertNoRawToolCallOutput(t,e){if(containsRawToolCallOutput(t,e))throw new Error("Adapter returned raw tool-call text as the final answer after recovery. The backend must execute tools instead of printing tool-call markup.")}export function containsRawToolCallOutput(t,r){const n=o(r);return!0===n.enabled&&e(t,n)}export function rawToolCallFailureMessage(){return["The model attempted to call a tool but returned the tool call as text instead of executing it.","Please retry the request or use a model/backend configuration with reliable tool calling for this workspace."].join(" ")}function t(t,e){return{...t,input:[t.input,"",...e].join("\n"),metadata:{...t.metadata,stableHarnessRecovery:"tool_call"}}}function e(t,e){return r(e.rawOutputPatterns,[/<\s*(?:tool_call|task)\b[^>]*>/iu,/<\s*\/\s*(?:tool_call|task)\s*>/iu]).some(e=>e.test(t))}function o(t){if(!n(t))return{};const e=n(t.recovery)?t.recovery:{};return n(e.toolCall)?e.toolCall:{}}function r(t,e){const o=(Array.isArray(t)?t:[]).filter(t=>"string"==typeof t&&t.length>0).map(t=>new RegExp(t,"iu"));return o.length>0?o:e}function n(t){return"object"==typeof t&&null!==t&&!Array.isArray(t)}

package/packages/core/dist/runtime/completion.d.ts

@@ -0,0 +1,17 @@
+import type { 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;
+}): RuntimeResponse;
+export declare function failRun(input: {
+    store: RuntimeStore;
+    emit: (event: RuntimeEvent) => void;
+    requestId: string;
+    sessionId: string;
+    agent: WorkspaceAgent;
+    error: unknown;
+}): RuntimeResponse;

package/packages/core/dist/runtime/completion.js

@@ -0,0 +1 @@
+export function completeRun(e){const s=e.store.getRun(e.requestId);if("cancelled"===s?.state)return t(e,"cancelled");s&&e.store.updateRun(e.requestId,{state:"completed",output:e.result.text,metadata:{...s.metadata,...e.result.metadata},artifacts:[...s.artifacts,...e.result.artifacts??[]],completedAt:(new Date).toISOString()});for(const t of e.result.artifacts??[])e.emit({type:"artifact.created",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,artifact:t});return e.emit({type:"request.completed",requestId:e.requestId,sessionId:e.sessionId,agentId:e.agent.id,output:e.result.text}),t(e,"completed")}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:"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 t(t,e){return{requestId:t.requestId,sessionId:t.sessionId,agentId:t.agent.id,state:e,output:t.result.text,metadata:t.result.metadata,artifacts:t.result.artifacts}}

package/packages/core/dist/runtime/direct-tool-call.d.ts

@@ -0,0 +1,10 @@
+import type { CompiledWorkspace, RuntimeEvent, RuntimeOutput, RuntimeRequest, 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;
+}): Promise<RuntimeOutput>;

package/packages/core/dist/runtime/direct-tool-call.js

@@ -0,0 +1 @@
+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(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}}));if(t&&o.agent.tools.includes(t.toolId)&&o.gateway.get(t.toolId))return t;if(!o.agent.tools.includes(o.toolId))throw new Error(`Tool ${o.toolId} is not assigned to agent ${o.agent.id}`);throw new Error(`Tool is not registered: ${o.toolId}`)}({gateway:o.gateway,workspace:o.workspace,requestId:o.requestId,sessionId:o.sessionId,agent:o.agent,toolId:t.toolId,args:t.args});o.emit({type:"tool.started",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,toolId:e.toolId});const s=await o.gateway.invoke({toolId:e.toolId,args:e.args,context:{workspaceRoot:o.workspace.root,requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id}});return o.emit({type:"tool.completed",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agent.id,toolId:s.toolId,output:s.output}),{text:(a=s.output,"string"==typeof a?a:JSON.stringify(a)),metadata:{toolCall:{toolId:s.toolId}}};var a}

package/packages/core/dist/runtime/events.d.ts

@@ -0,0 +1,147 @@
+import type { MemoryCandidate, MemoryDecision, MemoryRecord } from "@stable-harness/memory";
+import type { ApprovalRequest } from "@stable-harness/governance";
+import type { RuntimeArtifact } from "../types.js";
+export type RuntimeEvent = {
+    type: "request.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+} | {
+    type: "request.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    output: string;
+} | {
+    type: "request.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    error: string;
+} | {
+    type: "request.cancelled";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    reason?: string;
+} | {
+    type: "artifact.created";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    artifact: RuntimeArtifact;
+} | {
+    type: "execution.contract.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    reason: string;
+    missingEvidenceTools?: string[];
+} | {
+    type: "tool.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+} | {
+    type: "tool.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    toolId: string;
+    output: unknown;
+} | {
+    type: "memory.lifecycle";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    hook: RuntimeMemoryHook;
+} | {
+    type: "memory.recall.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    namespace: string;
+    recordIds: string[];
+    context: string;
+} | {
+    type: "memory.candidate.submitted";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    candidate: MemoryCandidate;
+    decision: MemoryDecision;
+    record?: MemoryRecord;
+} | {
+    type: "memory.approval.requested";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    approval: ApprovalRequest;
+} | {
+    type: "memory.plugin.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+} | {
+    type: "memory.plugin.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+    candidateCount: number;
+} | {
+    type: "memory.plugin.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    memoryId: string;
+    provider: string;
+    namespace: string;
+    error: string;
+} | {
+    type: "memory.maintenance.started";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+} | {
+    type: "memory.maintenance.completed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+    operationCount: number;
+} | {
+    type: "memory.maintenance.failed";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    target: string;
+    error: string;
+} | {
+    type: "skill.candidate.created";
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    candidateId: string;
+    name: string;
+    confidence: number;
+    evidenceCount: number;
+    status: string;
+    proposedPath?: string;
+} | {
+    type: "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/packages/core/dist/runtime/events.js

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

package/packages/core/dist/runtime/memory.d.ts

@@ -0,0 +1,23 @@
+import type { ApprovalQueue } from "@stable-harness/governance";
+import type { RuntimeMemoryStore } from "@stable-harness/memory";
+import type { CompiledWorkspace, RuntimeEvent, RuntimeMemoryContext, RuntimeRequest, WorkspaceAgent } from "../types.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>;

package/packages/core/dist/runtime/memory.js

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

package/packages/core/dist/{artifacts.d.ts → runtime/persistence/artifacts.d.ts}

@@ -1,4 +1,4 @@
-import type { RuntimeArtifactRecord, RuntimeArtifactStore } from "./types.js";
+import type { RuntimeArtifactRecord, RuntimeArtifactStore } from "../types.js";
 type ArtifactState = {
     records: RuntimeArtifactRecord[];
     contents: Record<string, unknown>;

package/packages/core/dist/{inspection.d.ts → runtime/persistence/inspection.d.ts}

@@ -1,4 +1,4 @@
-import type { CompiledWorkspace, RuntimeRequestInspection, RuntimeRequestSummary, RuntimeRunRecord, RuntimeSessionSummary } from "./types.js";
+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/packages/core/dist/{queue.d.ts → runtime/persistence/queue.d.ts}

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

package/packages/core/dist/{stores.d.ts → runtime/persistence/stores.d.ts}

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

package/packages/core/dist/runtime/tool-gateway.d.ts

@@ -0,0 +1,35 @@
+export type RuntimeToolCallRequest = {
+    toolId: string;
+    args?: unknown;
+};
+export type RuntimeToolGatewayContext = {
+    workspaceRoot: string;
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+};
+export type RuntimeToolGatewayTool = {
+    id: string;
+    description?: string;
+    schema?: unknown;
+};
+export type RuntimeToolGateway = {
+    get(toolId: string): RuntimeToolGatewayTool | undefined;
+    repairToolCall?(request: {
+        toolId: string;
+        args?: unknown;
+        allowedToolIds?: string[];
+        context: RuntimeToolGatewayContext;
+    }): Promise<{
+        toolId: string;
+        args: unknown;
+    } | undefined>;
+    invoke(request: {
+        toolId: string;
+        args?: unknown;
+        context: RuntimeToolGatewayContext;
+    }): Promise<{
+        toolId: string;
+        output: unknown;
+    }>;
+};

package/packages/core/dist/runtime/tool-gateway.js

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

package/packages/core/dist/runtime/types.d.ts

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

package/packages/core/dist/runtime/types.js

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