stable-harness 0.0.36 → 0.0.38

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

@@ -0,0 +1,70 @@
+import type { CompiledWorkspace, RuntimeOutput, RuntimeToolGateway } from "../types.js";
+export type WorkspaceWorkflow = {
+    id: string;
+    description?: string;
+    sourcePath?: string;
+    adapter?: string;
+    entry?: string;
+    state?: WorkspaceWorkflowState;
+    nodes: WorkspaceWorkflowNode[];
+    edges: WorkspaceWorkflowEdge[];
+    policies?: Record<string, unknown>;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceWorkflowState = {
+    schema?: string;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceWorkflowNode = {
+    id: string;
+    use: string;
+    type?: string;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceWorkflowEdge = {
+    from: string;
+    to: string;
+    condition?: string;
+};
+export type WorkspaceWorkflowRoutingPolicy = {
+    defaultWorkflowId?: string;
+    routes?: WorkspaceWorkflowRoute[];
+};
+export type WorkspaceWorkflowRoute = {
+    id: string;
+    workflowId: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeWorkflowRequest = {
+    workflowId?: string;
+    routeId?: string;
+    input?: unknown;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeWorkflowAdapterInput = {
+    workspace: CompiledWorkspace;
+    workflow: WorkspaceWorkflow;
+    request: RuntimeWorkflowRequest;
+    requestId: string;
+    sessionId: string;
+    toolGateway?: RuntimeToolGateway;
+    emit: (event: unknown) => void;
+};
+export type RuntimeWorkflowAdapter = {
+    name: string;
+    run(input: RuntimeWorkflowAdapterInput): Promise<string | RuntimeOutput>;
+};
+export type WorkflowPlan = {
+    workflowId: string;
+    adapter?: string;
+    entry: string;
+    nodes: WorkspaceWorkflowNode[];
+    edges: WorkspaceWorkflowEdge[];
+    terminalNodes: string[];
+    unreachableNodes: string[];
+    cycles: string[][];
+};
+export declare function compileWorkflowPlan(workflow: WorkspaceWorkflow): WorkflowPlan;
+export declare function renderWorkflowMermaid(workflow: WorkspaceWorkflow): string;
+export declare function renderAgentMermaid(workspace: CompiledWorkspace, agentId: string): string;

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

@@ -0,0 +1 @@
+export function compileWorkflowPlan(e){const n=e.entry??e.nodes[0]?.id;if(!n)throw new Error(`Workflow ${e.id} has no entry node`);const t=function buildAdjacency(e){const n=new Map(e.nodes.map(e=>[e.id,[]]));for(const t of e.edges)n.get(t.from)?.push(t.to);return n}(e),o=function collectReachable(e,n){const t=new Set,o=[e];for(;o.length>0;){const e=o.pop();t.has(e)||(t.add(e),o.push(...n.get(e)??[]))}return t}(n,t),a=function findCycles(e,n){const t=[];for(const o of e)collectCycles(o,o,n,[],t);return function dedupeCycles(e){const n=new Set;return e.filter(e=>{const t=function canonicalCycleKey(e){const n=e.slice(0,-1);return n.map((e,t)=>[...n.slice(t),...n.slice(0,t)].join("|")).sort()[0]??""}(e);return!n.has(t)&&(n.add(t),!0)})}(t)}(e.nodes.map(e=>e.id),t);return{workflowId:e.id,...e.adapter?{adapter:e.adapter}:{},entry:n,nodes:e.nodes,edges:e.edges,terminalNodes:e.nodes.map(e=>e.id).filter(e=>0===(t.get(e)??[]).length),unreachableNodes:e.nodes.map(e=>e.id).filter(e=>!o.has(e)),cycles:a}}export function renderWorkflowMermaid(e){const n=["flowchart TD"];for(const t of e.nodes)n.push(`  ${escapeId(t.id)}["${escapeLabel(`${t.id}\\n${t.use}`)}"]`);for(const t of e.edges){const e=t.condition?`|${escapeLabel(t.condition)}|`:"";n.push(`  ${escapeId(t.from)} --\x3e${e} ${escapeId(t.to)}`)}return n.join("\n")}export function renderAgentMermaid(e,n){const t=e.agents.get(n);if(!t)throw new Error(`Agent is not defined: ${n}`);const o=function agentGraphNodes(e){return[...e.subagents.map(e=>agentGraphNode("agent",e)),...(e.skills??[]).map(e=>agentGraphNode("skill",e)),...e.tools.map(e=>agentGraphNode("tool",e))]}(t),a=["flowchart TD",`  START_${escapeId(t.id)}([START])`,`  END_${escapeId(t.id)}([END])`];for(const e of o)a.push(`  ${e.diagramId}["${escapeLabel(`${e.id}\\n${e.label}`)}"]`);return 0===o.length?(a.push(`  START_${escapeId(t.id)} --\x3e END_${escapeId(t.id)}`),a.join("\n")):[...a,...t.edges?.length?explicitAgentMermaidEdges(t,o):inventoryAgentMermaidEdges(t,o)].join("\n")}function agentGraphNode(e,n){return{id:n,diagramId:`${e}_${escapeId(n)}`,label:`${e}: ${n}`}}function explicitAgentMermaidEdges(e,n){const t=new Map(n.map(e=>[e.id,e.diagramId])),o=new Set((e.edges??[]).map(e=>e.to)),a=new Set((e.edges??[]).map(e=>e.from)),d=n.filter(e=>!o.has(e.id)).map(e=>e.diagramId),r=n.filter(e=>!a.has(e.id)).map(e=>e.diagramId);return[...d.map(n=>`  START_${escapeId(e.id)} --\x3e ${escapeId(n)}`),...(e.edges??[]).flatMap(e=>function renderAgentEdge(e,n){const t=n.get(e.from),o=n.get(e.to);return t&&o?[`  ${t} --\x3e${e.condition?`|${escapeLabel(e.condition)}|`:""} ${o}`]:[]}(e,t)),...r.map(n=>`  ${escapeId(n)} --\x3e END_${escapeId(e.id)}`)]}function inventoryAgentMermaidEdges(e,n){return n.flatMap(n=>[`  START_${escapeId(e.id)} -. available .-> ${n.diagramId}`,`  ${n.diagramId} -.-> END_${escapeId(e.id)}`])}function collectCycles(e,n,t,o,a){const d=[...o,n];for(const r of t.get(n)??[])r===e?a.push([...d,e]):o.includes(r)||collectCycles(e,r,t,d,a)}function escapeId(e){return e.replace(/[^A-Za-z0-9_]/gu,"_")}function escapeLabel(e){return e.replace(/"/gu,'\\"')}

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

@@ -0,0 +1,12 @@
+import type { CompiledWorkspace, RuntimeEvent, RuntimeOutput } from "../types.js";
+import type { RuntimeWorkflowAdapter, RuntimeWorkflowAdapterInput, RuntimeWorkflowRequest } from "./index.js";
+export declare function runWorkflowRequest(input: {
+    workspace: CompiledWorkspace;
+    adapters: RuntimeWorkflowAdapter[];
+    toolGateway?: RuntimeWorkflowAdapterInput["toolGateway"];
+    request: RuntimeWorkflowRequest;
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    emit: (event: RuntimeEvent) => void;
+}): Promise<RuntimeOutput>;

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

@@ -0,0 +1 @@
+import{repairRuntimeSelection as e}from"../runtime/selection-repair.js";export async function runWorkflowRequest(o){const r=await async function resolveWorkflow(o,r,t){const n=r.routeId?await async function resolveWorkflowRouteId(o,r,t){const n=o.runtime.workflowRouting?.routes??[];if(n.some(e=>e.id===r))return r;const i=await e({id:r,candidates:n.map(e=>({id:e.id,description:e.description,metadata:e.metadata})),trace:{...t,layer:"workflow_route",owner:"stable_runtime_policy"}});return i.ok?i.id:r}(o,r.routeId,t):void 0,i=n?o.runtime.workflowRouting?.routes?.find(e=>e.id===n):void 0;if(r.routeId&&!i)throw new Error(`Workflow route is not defined: ${r.routeId}`);const s=(r.workflowId?await async function resolveWorkflowId(o,r,t){if(o.workflows.has(r))return r;const n=await e({id:r,candidates:[...o.workflows.values()].map(e=>({id:e.id,description:e.description})),trace:{...t,layer:"workflow",owner:"stable_runtime_policy"}});return n.ok?n.id:r}(o,r.workflowId,t):void 0)??i?.workflowId??o.runtime.workflowRouting?.defaultWorkflowId;if(!s)throw new Error("Workflow request requires workflowId, routeId, or runtime.workflowRouting.defaultWorkflowId");const d=o.workflows.get(s);if(!d)throw new Error(`Workflow is not defined: ${s}`);return d}(o.workspace,o.request,o),t=function resolveWorkflowAdapter(e,o){const r=o?e.find(e=>e.name===o):e[0];if(!r)throw new Error("No workflow adapter is configured"+(o?` for ${o}`:""));return r}(o.adapters,r.adapter);o.emit({type:"runtime.workflow.started",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agentId,adapter:t.name,workflowId:r.id});const n=await t.run({workspace:o.workspace,workflow:r,request:o.request,requestId:o.requestId,sessionId:o.sessionId,toolGateway:o.toolGateway,emit:e=>o.emit({type:"runtime.adapter.event",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agentId,event:e})});return o.emit({type:"runtime.workflow.completed",requestId:o.requestId,sessionId:o.sessionId,agentId:o.agentId,adapter:t.name,workflowId:r.id}),"string"==typeof n?{text:n}:n}

package/node_modules/@stable-harness/core/dist/workspace/tool-quality.d.ts

@@ -0,0 +1,22 @@
+import type { CompiledWorkspace } from "./types.js";
+export type WorkspaceToolQualityDiagnosticCode = "missing-description" | "weak-description" | "missing-schema" | "missing-output-contract" | "missing-permission-metadata" | "overlapping-description";
+export type WorkspaceToolQualitySeverity = "error" | "warning";
+export type WorkspaceToolQualityDiagnostic = {
+    code: WorkspaceToolQualityDiagnosticCode;
+    layer: "tool";
+    owner: "stable_runtime_policy" | "workspace_config";
+    resources: string[];
+    severity: WorkspaceToolQualitySeverity;
+    message: string;
+    locations: string[];
+    details?: Record<string, unknown>;
+};
+export type WorkspaceToolQualityPolicy = {
+    enabled?: boolean;
+    requireSchema?: boolean;
+    requireOutputContract?: boolean;
+    requirePermissionMetadata?: boolean;
+    failOn?: Partial<Record<WorkspaceToolQualityDiagnosticCode, boolean>>;
+};
+export declare function scanWorkspaceToolQuality(workspace: CompiledWorkspace, policy?: WorkspaceToolQualityPolicy): WorkspaceToolQualityDiagnostic[];
+export declare function assertWorkspaceToolQualityDiagnostics(diagnostics: WorkspaceToolQualityDiagnostic[]): void;

package/node_modules/@stable-harness/core/dist/workspace/tool-quality.js

@@ -0,0 +1 @@
+export function scanWorkspaceToolQuality(t,e={}){if(!1===e.enabled)return[];const o=[...t.tools.values()].flatMap(t=>function scanTool(t,e){const o=[],i=t.description?.trim()??"";return i?function isWeakDescription(t,e){const o=t.replace(/[_-]+/gu," ").toLowerCase(),i=e.replace(/[_-]+/gu," ").toLowerCase();return i.length<24||i===o}(t.id,i)&&o.push(diagnostic(t,"weak-description","Tool description is too short or repeats only the tool id.",e)):o.push(diagnostic(t,"missing-description","Tool is missing a description.",e)),!0===e.requireSchema&&void 0===t.schema&&o.push(diagnostic(t,"missing-schema","Tool is missing an input schema.",e)),!0!==e.requireOutputContract||void 0!==t.outputSchema||hasMetadata(t,"outputContract")||o.push(diagnostic(t,"missing-output-contract","Tool is missing output contract metadata.",e)),!0!==e.requirePermissionMetadata||hasMetadata(t,"permissions")||o.push(diagnostic(t,"missing-permission-metadata","Tool is missing permission metadata.",e)),o}(t,e));return[...o,...scanOverlaps([...t.tools.values()])]}export function assertWorkspaceToolQualityDiagnostics(t){const e=t.filter(t=>"error"===t.severity);if(0!==e.length)throw new Error(`Workspace tool quality gate failed:\n${e.map(formatDiagnostic).join("\n")}`)}function scanOverlaps(t){const e=[];for(let o=0;o<t.length;o+=1)for(let i=o+1;i<t.length;i+=1){const s=t[o],n=t[i],a=descriptionOverlap(s.description,n.description);a<.8||e.push({code:"overlapping-description",layer:"tool",owner:"workspace_config",resources:[s.id,n.id],severity:"warning",message:`Tools ${s.id} and ${n.id} have highly overlapping descriptions; add explicit selection boundaries.`,locations:[s.sourcePath,n.sourcePath].filter(isString),details:{score:a}})}return e}function diagnostic(t,e,o,i){return{code:e,layer:"tool",owner:"workspace_config",resources:[t.id],severity:!0===i.failOn?.[e]?"error":"warning",message:o,locations:t.sourcePath?[t.sourcePath]:[]}}function descriptionOverlap(t,e){const o=tokenSet(t),i=tokenSet(e);return o.size<4||i.size<4?0:[...o].filter(t=>i.has(t)).length/Math.min(o.size,i.size)}function tokenSet(t){return new Set((t??"").toLowerCase().split(/[^a-z0-9]+/u).filter(t=>t.length>2))}function hasMetadata(t,e){return"object"==typeof t.metadata&&null!==t.metadata&&!Array.isArray(t.metadata)&&void 0!==t.metadata[e]}function formatDiagnostic(t){return`- ${t.code}: ${t.message} (${t.resources.join(", ")})`}function isString(t){return"string"==typeof t&&t.length>0}

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

@@ -0,0 +1,134 @@
+import type { WorkspaceEvaluation } from "../evaluations/index.js";
+import type { WorkspaceSpecDrivenWorkflowPolicy } from "../spec-driven/index.js";
+import type { WorkspaceWorkflow, WorkspaceWorkflowEdge, WorkspaceWorkflowRoutingPolicy } from "../workflows/index.js";
+import type { WorkspaceToolQualityDiagnostic, WorkspaceToolQualityPolicy } from "./tool-quality.js";
+export type WorkspaceModel = {
+    id: string;
+    provider: string;
+    model: string;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceTool = {
+    id: string;
+    description?: string;
+    schema?: unknown;
+    outputSchema?: unknown;
+    metadata?: Record<string, unknown>;
+    implementation?: string;
+    sourcePath?: string;
+};
+export type WorkspaceSkill = {
+    id: string;
+    path: string;
+    description?: string;
+    allowedTools: string[];
+};
+export type WorkspaceMemory = {
+    id: string;
+    provider: string;
+    profile?: string;
+    mode?: string;
+    enabled: boolean;
+    prompts?: {
+        semantic?: string;
+        episodic?: string;
+        procedural?: string;
+    };
+    config?: Record<string, unknown>;
+};
+export type WorkspaceAgent = {
+    id: string;
+    description?: string;
+    sourcePath?: string;
+    backend: string;
+    modelRef?: string;
+    systemPrompt?: string;
+    tools: string[];
+    skills?: string[];
+    memory?: unknown[];
+    subagents: string[];
+    edges?: WorkspaceWorkflowEdge[];
+    config: Record<string, unknown>;
+};
+export type WorkspaceRuntimePolicy = {
+    defaultAgentId: string;
+    routes?: WorkspaceAgentRoute[];
+    workspaceId?: string;
+    profile?: string;
+    workspaceValidation?: WorkspaceValidationPolicy;
+    adapters?: WorkspaceAdapterPolicy[];
+    workflowRouting?: WorkspaceWorkflowRoutingPolicy;
+    specDrivenWorkflow?: WorkspaceSpecDrivenWorkflowPolicy;
+    approvals?: Record<string, unknown>;
+    recovery?: Record<string, unknown>;
+    retry?: WorkspaceRetryPolicy;
+    toolGateway?: Record<string, unknown>;
+    sandbox?: Record<string, unknown>;
+    memory?: Record<string, unknown>;
+    protocols?: Record<string, unknown>;
+    progress?: Record<string, unknown>;
+    cli?: Record<string, unknown>;
+    quality?: string | Record<string, unknown>;
+    responseLanguage?: Record<string, unknown>;
+    responsePresentation?: Record<string, unknown>;
+};
+export type WorkspaceAgentRoute = {
+    id: string;
+    agentId: string;
+    keywords?: string[];
+    pattern?: string;
+    description?: string;
+};
+export type WorkspaceValidationPolicy = {
+    boundaryScan?: WorkspaceBoundaryScanPolicy;
+    toolQuality?: WorkspaceToolQualityPolicy;
+};
+export type WorkspaceBoundaryScanPolicy = {
+    enabled?: boolean;
+    failOn?: Partial<Record<WorkspaceBoundaryDiagnosticCode, boolean>>;
+};
+export type WorkspaceBoundaryDiagnosticCode = "duplicate-scope" | "hardcoded-sibling-routing" | "broad-fallback-scope" | "weak-positive-boundary" | "possible-sibling-overlap";
+export type WorkspaceBoundaryDiagnostic = {
+    code: WorkspaceBoundaryDiagnosticCode;
+    layer: "subagent" | "skill" | "tool";
+    resources: string[];
+    severity: "error" | "warning";
+    message: string;
+    locations: string[];
+    details?: Record<string, unknown>;
+};
+export type WorkspaceAdapterPolicy = {
+    name: string;
+    enabled?: boolean;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceRetryPolicy = {
+    model?: WorkspaceRetryTargetPolicy;
+    tools?: WorkspaceToolRetryPolicy;
+};
+export type WorkspaceRetryTargetPolicy = {
+    enabled?: boolean;
+    maxRetries?: number;
+    retryOn?: WorkspaceRetryReason[];
+    backoffFactor?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    jitter?: boolean;
+    onFailure?: "continue" | "error";
+};
+export type WorkspaceToolRetryPolicy = WorkspaceRetryTargetPolicy & {
+    tools?: string[];
+};
+export type WorkspaceRetryReason = "timeout" | "network" | "rateLimit" | "serverError";
+export type CompiledWorkspace = {
+    root: string;
+    runtime: WorkspaceRuntimePolicy;
+    agents: Map<string, WorkspaceAgent>;
+    models: Map<string, WorkspaceModel>;
+    tools: Map<string, WorkspaceTool>;
+    skills: Map<string, WorkspaceSkill>;
+    memories: Map<string, WorkspaceMemory>;
+    workflows: Map<string, WorkspaceWorkflow>;
+    evaluations?: Map<string, WorkspaceEvaluation>;
+    diagnostics?: Array<WorkspaceBoundaryDiagnostic | WorkspaceToolQualityDiagnostic>;
+};

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

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

package/node_modules/@stable-harness/core/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@stable-harness/core",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "peerDependencies": {
+    "@botbotgo/better-call": "^0.1.58",
+    "@stable-harness/governance": "0.0.1",
+    "@stable-harness/memory": "0.0.1"
+  }
+}

package/node_modules/@stable-harness/governance/dist/src/approval-queue.d.ts

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

package/node_modules/@stable-harness/governance/dist/src/approval-queue.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";export function createInMemoryApprovalQueue(){const t=[];return{async create(n){const s={id:e(),kind:n.kind,reason:n.reason,status:"pending",requestId:n.requestId,sessionId:n.sessionId,agentId:n.agentId,subject:n.subject,createdAt:(new Date).toISOString()};return t.push(s),s},get:async e=>t.find(t=>t.id===e),list:async e=>e?t.filter(t=>t.status===e):[...t],async resolve(e,n){const s=t.find(t=>t.id===e);if(s)return s.status=n,s.resolvedAt=(new Date).toISOString(),s}}}

package/node_modules/@stable-harness/governance/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createInMemoryApprovalQueue } from "./approval-queue.js";
+export { createPolicyEngine } from "./policy-engine.js";
+export { createSqliteSkillCandidateStore } from "./skill-candidates.js";
+export type { ApprovalQueue, ApprovalRequest, ApprovalRequestKind, ApprovalRequestStatus, PolicyDecision, RuntimePolicyEngine, SkillCandidate, SkillCandidateEvidence, SkillCandidateInput, SkillCandidateStatus, SkillCandidateStore, ToolPolicy, } from "./types.js";

package/node_modules/@stable-harness/governance/dist/src/index.js

@@ -0,0 +1 @@
+export{createInMemoryApprovalQueue}from"./approval-queue.js";export{createPolicyEngine}from"./policy-engine.js";export{createSqliteSkillCandidateStore}from"./skill-candidates.js";

package/node_modules/@stable-harness/governance/dist/src/policy-engine.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimePolicyEngine, ToolPolicy } from "./types.js";
+export declare function createPolicyEngine(policy?: ToolPolicy): RuntimePolicyEngine;

package/node_modules/@stable-harness/governance/dist/src/policy-engine.js

@@ -0,0 +1 @@
+export function createPolicyEngine(o={}){const e=new Set(o.approvalRequiredToolIds??[]),l=o.sandboxByToolId??{};return{evaluateTool:o=>e.has(o.toolId)?{action:"require_approval",reason:`Tool '${o.toolId}' requires explicit approval.`}:{action:"allow",reason:`Tool '${o.toolId}' is allowed by configured policy.`},resolveSandbox:o=>l[o.toolId]??o.defaultSandbox??"default"}}

package/node_modules/@stable-harness/governance/dist/src/skill-candidates.d.ts

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

package/node_modules/@stable-harness/governance/dist/src/skill-candidates.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{mkdirSync as t}from"node:fs";import n from"node:path";import{DatabaseSync as a}from"node:sqlite";export function createSqliteSkillCandidateStore(d){t(n.dirname(d),{recursive:!0});const r=new a(d);return function init(e){e.exec("\n    create table if not exists skill_candidates (\n      id text primary key, workspace_id text not null, name text not null,\n      status text not null, confidence real not null, evidence_count integer not null,\n      proposed_path text, title text not null, summary text not null,\n      draft_markdown text not null, created_at text not null, updated_at text not null,\n      reviewed_at text, reviewed_by text, rejection_reason text,\n      unique(workspace_id, name)\n    );\n    create table if not exists skill_candidate_evidence (\n      id text primary key, candidate_id text not null, evidence_type text not null,\n      evidence_ref text not null, summary text, weight real, created_at text not null,\n      foreign key(candidate_id) references skill_candidates(id)\n    );\n  ")}(r),{async upsert(t){const n=(new Date).toISOString(),a=function findByName(e,t,n){const a=e.prepare("select * from skill_candidates where workspace_id = ? and name = ?").get(t,n);return a?rowToCandidate(a):void 0}(r,t.workspaceId,t.name),d=a?function updateCandidate(e,t,n,a){return e.prepare("\n    update skill_candidates\n    set status = ?, confidence = ?, evidence_count = ?, proposed_path = ?,\n        title = ?, summary = ?, draft_markdown = ?, updated_at = ?\n    where id = ?\n  ").run(n.status??"review_required",n.confidence,n.evidence.length,n.proposedPath??null,n.title,n.summary,n.draftMarkdown,a,t),readCandidate(e,t)}(r,a.id,t,n):function insertCandidate(t,n,a){const d=String(e());return t.prepare("\n    insert into skill_candidates\n    (id, workspace_id, name, status, confidence, evidence_count, proposed_path,\n     title, summary, draft_markdown, created_at, updated_at)\n    values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n  ").run(d,n.workspaceId,n.name,n.status??"review_required",n.confidence,n.evidence.length,n.proposedPath??null,n.title,n.summary,n.draftMarkdown,a,a),readCandidate(t,d)}(r,t,n);return function replaceEvidence(t,n,a,d){t.prepare("delete from skill_candidate_evidence where candidate_id = ?").run(n);const r=t.prepare("\n    insert into skill_candidate_evidence\n    (id, candidate_id, evidence_type, evidence_ref, summary, weight, created_at)\n    values (?, ?, ?, ?, ?, ?, ?)\n  ");for(const t of a)r.run(String(e()),n,t.evidenceType,t.evidenceRef,t.summary??null,t.weight??null,d)}(r,d.id,t.evidence,n),d},list:async(e={})=>function listCandidates(e,t,n){return(t&&n?e.prepare("select * from skill_candidates where workspace_id = ? and status = ? order by updated_at desc").all(t,n):t?e.prepare("select * from skill_candidates where workspace_id = ? order by updated_at desc").all(t):e.prepare("select * from skill_candidates order by updated_at desc").all()).map(e=>rowToCandidate(e))}(r,e.workspaceId,e.status),get:async e=>readCandidate(r,e),listEvidence:async e=>function listEvidence(e,t){return e.prepare("select * from skill_candidate_evidence where candidate_id = ? order by created_at asc").all(t).map(e=>function rowToEvidence(e){return{id:String(e.id),candidateId:String(e.candidate_id),evidenceType:e.evidence_type,evidenceRef:String(e.evidence_ref),summary:readOptionalString(e.summary),weight:"number"==typeof e.weight?e.weight:void 0,createdAt:String(e.created_at)}}(e))}(r,e),async updateStatus(e){const t=(new Date).toISOString();return r.prepare("\n        update skill_candidates\n        set status = ?, reviewed_at = ?, reviewed_by = ?, rejection_reason = ?, updated_at = ?\n        where id = ?\n      ").run(e.status,t,e.reviewedBy??null,e.rejectionReason??null,t,e.id),readCandidate(r,e.id)}}}function readCandidate(e,t){const n=e.prepare("select * from skill_candidates where id = ?").get(t);return n?rowToCandidate(n):void 0}function rowToCandidate(e){return{id:String(e.id),workspaceId:String(e.workspace_id),name:String(e.name),status:e.status,confidence:Number(e.confidence),evidenceCount:Number(e.evidence_count),proposedPath:readOptionalString(e.proposed_path),title:String(e.title),summary:String(e.summary),draftMarkdown:String(e.draft_markdown),createdAt:String(e.created_at),updatedAt:String(e.updated_at),reviewedAt:readOptionalString(e.reviewed_at),reviewedBy:readOptionalString(e.reviewed_by),rejectionReason:readOptionalString(e.rejection_reason)}}function readOptionalString(e){return"string"==typeof e&&e?e:void 0}

package/node_modules/@stable-harness/governance/dist/src/types.d.ts

@@ -0,0 +1,101 @@
+export type PolicyDecision = {
+    action: "allow";
+    reason: string;
+} | {
+    action: "require_approval";
+    reason: string;
+};
+export type ToolPolicy = {
+    approvalRequiredToolIds?: string[];
+    sandboxByToolId?: Record<string, string>;
+};
+export type RuntimePolicyEngine = {
+    evaluateTool(input: {
+        toolId: string;
+        metadata?: Record<string, unknown>;
+    }): PolicyDecision;
+    resolveSandbox(input: {
+        toolId: string;
+        defaultSandbox?: string;
+    }): string;
+};
+export type ApprovalRequestKind = "tool_invocation" | "memory_write" | "skill_candidate";
+export type ApprovalRequestStatus = "pending" | "approved" | "rejected";
+export type ApprovalRequest = {
+    id: string;
+    kind: ApprovalRequestKind;
+    reason: string;
+    status: ApprovalRequestStatus;
+    requestId?: string;
+    sessionId?: string;
+    agentId?: string;
+    subject: Record<string, unknown>;
+    createdAt: string;
+    resolvedAt?: string;
+};
+export type ApprovalQueue = {
+    create(input: {
+        kind: ApprovalRequestKind;
+        reason: string;
+        requestId?: string;
+        sessionId?: string;
+        agentId?: string;
+        subject: Record<string, unknown>;
+    }): Promise<ApprovalRequest>;
+    get(id: string): Promise<ApprovalRequest | undefined>;
+    list(status?: ApprovalRequestStatus): Promise<ApprovalRequest[]>;
+    resolve(id: string, status: Exclude<ApprovalRequestStatus, "pending">): Promise<ApprovalRequest | undefined>;
+};
+export type SkillCandidateStatus = "observed" | "candidate" | "review_required" | "approved" | "rejected" | "drafted" | "enabled" | "deprecated";
+export type SkillCandidate = {
+    id: string;
+    workspaceId: string;
+    name: string;
+    status: SkillCandidateStatus;
+    confidence: number;
+    evidenceCount: number;
+    proposedPath?: string;
+    title: string;
+    summary: string;
+    draftMarkdown: string;
+    createdAt: string;
+    updatedAt: string;
+    reviewedAt?: string;
+    reviewedBy?: string;
+    rejectionReason?: string;
+};
+export type SkillCandidateEvidence = {
+    id: string;
+    candidateId: string;
+    evidenceType: "memory_record" | "memory_file" | "run" | "tool_event" | "validation" | "user_correction";
+    evidenceRef: string;
+    summary?: string;
+    weight?: number;
+    createdAt: string;
+};
+export type SkillCandidateInput = {
+    workspaceId: string;
+    name: string;
+    status?: SkillCandidateStatus;
+    confidence: number;
+    proposedPath?: string;
+    title: string;
+    summary: string;
+    draftMarkdown: string;
+    evidence: Array<Omit<SkillCandidateEvidence, "id" | "candidateId" | "createdAt">>;
+};
+export type SkillCandidateStore = {
+    upsert(input: SkillCandidateInput): Promise<SkillCandidate>;
+    list(filter?: {
+        workspaceId?: string;
+        status?: SkillCandidateStatus;
+    }): Promise<SkillCandidate[]>;
+    get(id: string): Promise<SkillCandidate | undefined>;
+    listEvidence(candidateId: string): Promise<SkillCandidateEvidence[]>;
+    updateStatus(input: {
+        id: string;
+        status: SkillCandidateStatus;
+        reviewedBy?: string;
+        rejectionReason?: string;
+    }): Promise<SkillCandidate | undefined>;
+};

package/node_modules/@stable-harness/governance/dist/src/types.js

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

package/node_modules/@stable-harness/governance/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@stable-harness/governance",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json"
+  ],
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts"
+}

package/node_modules/@stable-harness/memory/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export { applyMemoryMaintenance } from "./maintenance.js";
+export { createEmbeddedMemoryProvider, } from "./provider.js";
+export { createLangMemServiceProvider, } from "./langmem-service.js";
+export type { LangMemServiceProviderOptions, } from "./langmem-service.js";
+export type { MemoryProvider, MemoryProviderApprovalConfig, MemoryProviderConfig, MemoryProviderConsolidateInput, MemoryProviderDefaults, MemoryProviderMode, MemoryProviderProposeInput, MemoryProviderSearchInput, MemoryProviderTypeConfig, } from "./provider.js";
+export { cloneRecords, createInMemoryMemoryPersistenceAdapter, createMemorySnapshot, } from "./persistence.js";
+export { createDefaultMemoryPolicy } from "./policy.js";
+export { createInMemoryRuntimeMemoryStore } from "./store.js";
+export type { ListMemoriesInput, MemorizeInput, MemoryCandidate, MemoryDecision, MemoryDecisionAction, MemoryKind, MemoryMaintenanceAction, MemoryMaintenanceOperation, MemoryMaintenanceResult, MemoryPolicy, MemoryPersistenceAdapter, MemoryRecallResult, MemoryRecord, MemoryRecordStatus, MemoryScope, MemorySensitivity, MemoryStoreSnapshot, MemorySubmitResult, RecallInput, RuntimeMemoryStore, UpdateMemoryInput, } from "./types.js";

package/node_modules/@stable-harness/memory/dist/src/index.js

@@ -0,0 +1 @@
+export{applyMemoryMaintenance}from"./maintenance.js";export{createEmbeddedMemoryProvider}from"./provider.js";export{createLangMemServiceProvider}from"./langmem-service.js";export{cloneRecords,createInMemoryMemoryPersistenceAdapter,createMemorySnapshot}from"./persistence.js";export{createDefaultMemoryPolicy}from"./policy.js";export{createInMemoryRuntimeMemoryStore}from"./store.js";

package/node_modules/@stable-harness/memory/dist/src/langmem-service.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryProvider, MemoryProviderConfig } from "./provider.js";
+export type LangMemServiceProviderOptions = {
+    baseUrl: string;
+    config?: MemoryProviderConfig;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+};
+export declare function createLangMemServiceProvider(options: LangMemServiceProviderOptions): MemoryProvider;

package/node_modules/@stable-harness/memory/dist/src/langmem-service.js

@@ -0,0 +1 @@
+export function createLangMemServiceProvider(e){const n=function normalizeBaseUrl(e){return e.replace(/\/+$/u,"")}(e.baseUrl),t={...e.config,provider:"langmem-service"};return{name:"langmem-service",config:t,propose:async o=>(await postJson(n,"/memory/propose",{...o,config:t},e)).candidates??[],async search(o){const r=await(o.store?.list({namespace:o.namespace,kinds:o.kinds}))??[];return(await postJson(n,"/memory/search",{...withoutStore(o),records:r,config:t},e)).records??[]},consolidate:async o=>(await postJson(n,"/memory/consolidate",{...o,config:t},e)).operations??[]}}async function postJson(e,n,t,o){const r=new AbortController,a=setTimeout(()=>r.abort(),o.timeoutMs??3e4);try{const a=await fetch(`${e}${n}`,{method:"POST",headers:{"content-type":"application/json",...o.headers},body:JSON.stringify(t),signal:r.signal});return await async function readResponse(e,n){const t=await e.text();if(!e.ok)throw new Error(`LangMem service ${n} failed with ${e.status}: ${t}`);return t?JSON.parse(t):{}}(a,n)}finally{clearTimeout(a)}}function withoutStore(e){return{namespace:e.namespace,query:e.query,limit:e.limit,kinds:e.kinds,records:[]}}

package/node_modules/@stable-harness/memory/dist/src/maintenance.d.ts

@@ -0,0 +1,2 @@
+import type { MemoryMaintenanceOperation, MemoryMaintenanceResult, RuntimeMemoryStore } from "./types.js";
+export declare function applyMemoryMaintenance(store: RuntimeMemoryStore, operations: MemoryMaintenanceOperation[]): Promise<MemoryMaintenanceResult[]>;

package/node_modules/@stable-harness/memory/dist/src/maintenance.js

@@ -0,0 +1 @@
+export async function applyMemoryMaintenance(a,e){const t=[];for(const n of e)t.push(await applyOperation(a,n));return t}async function applyOperation(a,e){return"archive"===e.action?result(e,await a.archive(e.recordId,e.reason)):"mark_stale"===e.action?result(e,await a.update({id:e.recordId,status:"stale",metadata:{maintenanceReason:e.reason}})):"refresh"===e.action?result(e,await a.update({id:e.recordId,status:"active",metadata:{maintenanceReason:e.reason}})):result(e,await a.update({id:e.recordId,status:"archived",metadata:{maintenanceReason:e.reason,supersededBy:e.replacementRecordId}}))}function result(a,e){return{operation:a,record:e,applied:Boolean(e),reason:e?a.reason:"record not found"}}

package/node_modules/@stable-harness/memory/dist/src/persistence.d.ts

@@ -0,0 +1,4 @@
+import type { ListMemoriesInput, MemoryPersistenceAdapter, MemoryRecord, MemoryStoreSnapshot, RuntimeMemoryStore } from "./types.js";
+export declare function createMemorySnapshot(store: RuntimeMemoryStore, input: ListMemoriesInput): Promise<MemoryStoreSnapshot>;
+export declare function createInMemoryMemoryPersistenceAdapter(): MemoryPersistenceAdapter;
+export declare function cloneRecords(records: MemoryRecord[]): MemoryRecord[];

package/node_modules/@stable-harness/memory/dist/src/persistence.js

@@ -0,0 +1 @@
+export async function createMemorySnapshot(e,t){return{namespace:t.namespace,records:await e.list(t),exportedAt:(new Date).toISOString()}}export function createInMemoryMemoryPersistenceAdapter(){const e=new Map;return{load:async t=>cloneRecords(e.get(t)??[]),async save(t){e.set(t.namespace,cloneRecords(t.records))}}}export function cloneRecords(e){return e.map(e=>({...e,sourceRefs:[...e.sourceRefs],tags:[...e.tags],metadata:{...e.metadata},provenance:{...e.provenance},supersedes:[...e.supersedes],conflictsWith:[...e.conflictsWith]}))}

package/node_modules/@stable-harness/memory/dist/src/policy.d.ts

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

package/node_modules/@stable-harness/memory/dist/src/policy.js

@@ -0,0 +1 @@
+export function createDefaultMemoryPolicy(){return{decide:e=>e.noStore?{action:"reject",reason:"candidate marked noStore",reviewRequired:!1}:e.content.trim()?"sensitive"===e.sensitivity||"restricted"===e.sensitivity?{action:"review",reason:"sensitive memory requires operator approval",kind:e.kindHint??"semantic",scope:e.scopeHint??"workspace",confidence:normalizeConfidence(e.confidenceHint),reviewRequired:!0}:{action:"store",reason:"candidate accepted by default runtime policy",kind:e.kindHint??"semantic",scope:e.scopeHint??"workspace",confidence:normalizeConfidence(e.confidenceHint),retrievalPriority:0,reviewRequired:!1}:{action:"reject",reason:"candidate content is empty",reviewRequired:!1}}}function normalizeConfidence(e){return void 0===e||Number.isNaN(e)?.6:Math.min(1,Math.max(0,e))}

package/node_modules/@stable-harness/memory/dist/src/provider.d.ts

@@ -0,0 +1,50 @@
+import type { MemoryCandidate, MemoryKind, MemoryMaintenanceOperation, MemoryRecord, MemoryScope, MemorySensitivity, RuntimeMemoryStore } from "./types.js";
+export type MemoryProviderMode = {
+    hotPathTools?: boolean;
+    backgroundManager?: boolean;
+};
+export type MemoryProviderTypeConfig = Partial<Record<MemoryKind, boolean>>;
+export type MemoryProviderApprovalConfig = {
+    procedural?: boolean;
+    sensitive?: boolean;
+    restricted?: boolean;
+};
+export type MemoryProviderDefaults = {
+    scope?: MemoryScope;
+    sensitivity?: MemorySensitivity;
+};
+export type MemoryProviderConfig = {
+    provider?: "embedded" | "langmem-service" | "custom";
+    mode?: MemoryProviderMode;
+    types?: MemoryProviderTypeConfig;
+    approval?: MemoryProviderApprovalConfig;
+    defaults?: MemoryProviderDefaults;
+};
+export type MemoryProviderProposeInput = {
+    namespace: string;
+    content: string;
+    sourceType?: string;
+    sourceRef?: string;
+    kindHint?: MemoryKind;
+    scopeHint?: MemoryScope;
+    sensitivity?: MemorySensitivity;
+    metadata?: Record<string, unknown>;
+};
+export type MemoryProviderSearchInput = {
+    store?: RuntimeMemoryStore;
+    namespace: string;
+    query: string;
+    limit?: number;
+    kinds?: MemoryKind[];
+};
+export type MemoryProviderConsolidateInput = {
+    records: MemoryRecord[];
+};
+export type MemoryProvider = {
+    name: string;
+    config: MemoryProviderConfig;
+    propose(input: MemoryProviderProposeInput): Promise<MemoryCandidate[]>;
+    search(input: MemoryProviderSearchInput): Promise<MemoryRecord[]>;
+    consolidate(input: MemoryProviderConsolidateInput): Promise<MemoryMaintenanceOperation[]>;
+};
+export declare function createEmbeddedMemoryProvider(config?: MemoryProviderConfig): MemoryProvider;

package/node_modules/@stable-harness/memory/dist/src/provider.js

@@ -0,0 +1 @@
+export function createEmbeddedMemoryProvider(e={}){return{name:"embedded",config:e,async propose(n){const s=n.kindHint??function inferKind(e){const n=e.toLowerCase();return n.includes("must ")||n.includes("should ")?"procedural":n.includes("run ")||n.includes("failed ")?"episodic":"semantic"}(n.content);return function isKindEnabled(e,n){return!1!==e.types?.[n]}(e,s)?[{namespace:n.namespace,content:n.content,sourceType:n.sourceType,sourceRef:n.sourceRef,kindHint:s,scopeHint:n.scopeHint??e.defaults?.scope??"workspace",sensitivity:n.sensitivity??e.defaults?.sensitivity??"internal",confidenceHint:.6,metadata:n.metadata}]:[]},search:async e=>e.store?(await e.store.recall({namespace:e.namespace,query:e.query,limit:e.limit,kinds:e.kinds})).records:[],consolidate:async e=>e.records.filter(e=>"stale"===e.status).map(e=>({action:"archive",recordId:e.id,reason:"embedded provider archives stale records during consolidation"}))}}

package/node_modules/@stable-harness/memory/dist/src/store.d.ts

@@ -0,0 +1,5 @@
+import type { MemoryPolicy, MemoryRecord, RuntimeMemoryStore } from "./types.js";
+export declare function createInMemoryRuntimeMemoryStore(options?: {
+    policy?: MemoryPolicy;
+    records?: MemoryRecord[];
+}): RuntimeMemoryStore;

package/node_modules/@stable-harness/memory/dist/src/store.js

@@ -0,0 +1 @@
+import{randomUUID as e}from"node:crypto";import{createDefaultMemoryPolicy as t}from"./policy.js";import{cloneRecords as n}from"./persistence.js";export function createInMemoryRuntimeMemoryStore(e={}){const r=e.policy??t(),o=n(e.records??[]);return{async submitCandidate(e){const t=r.decide(e);if("store"!==t.action)return{candidate:e,decision:t};const n=createRecord({namespace:e.namespace,content:e.content,kind:t.kind,scope:t.scope,summary:e.summary,confidence:t.confidence,tags:e.tags,sensitivity:e.sensitivity,sourceType:e.sourceType,sourceRef:e.sourceRef,metadata:e.metadata,provenance:e.provenance,observedAt:e.observedAt,retrievalPriority:t.retrievalPriority});return o.push(n),{candidate:e,decision:{...t,recordId:n.id},record:cloneRecord(n)}},async memorize(e){const t=createRecord(e);return o.push(t),cloneRecord(t)},async recall(e){const t=e.query.toLowerCase(),n=filterRecords(o,e).filter(e=>function matchesQuery(e,t){return[e.canonicalKey,e.content,e.summary??"",...e.tags].join("\n").toLowerCase().includes(t)}(e,t)).sort(compareRecallPriority).slice(0,e.limit??10);return{records:n,context:buildMemoryContext(n)}},list:async e=>n(filterRecords(o,e)),async update(e){const t=o.find(t=>t.id===e.id);if(t)return function applyUpdate(e,t){e.content=t.content??e.content,e.summary=t.summary??e.summary,e.status=t.status??e.status,e.confidence=normalizeConfidence(t.confidence??e.confidence),e.tags=t.tags??e.tags,e.metadata=t.metadata?{...e.metadata,...t.metadata}:e.metadata,e.lastConfirmedAt=(new Date).toISOString(),e.revision+=1}(t,e),cloneRecord(t)},async archive(e,t){const n=o.find(t=>t.id===e);if(n)return n.status="archived",n.metadata={...n.metadata,archiveReason:t},n.revision+=1,cloneRecord(n)}}}function cloneRecord(e){return n([e])[0]}function createRecord(t){const n=(new Date).toISOString();return{id:e(),namespace:t.namespace,canonicalKey:(r=t.namespace,o=t.content,`${r}:${o.trim().toLowerCase().replace(/\s+/gu," ").slice(0,120)}`),kind:t.kind??"semantic",scope:t.scope??"workspace",status:"active",content:t.content,summary:t.summary,confidence:normalizeConfidence(t.confidence),sourceType:t.sourceType,sourceRefs:t.sourceRef?[t.sourceRef]:[],tags:t.tags??[],sensitivity:t.sensitivity??"internal",metadata:t.metadata??{},createdAt:n,observedAt:t.observedAt??n,lastConfirmedAt:n,provenance:t.provenance??{},revision:1,supersedes:[],conflictsWith:[],retrievalPriority:t.retrievalPriority??0};var r,o}function filterRecords(e,t){return e.filter(e=>e.namespace===t.namespace).filter(e=>!t.kinds||t.kinds.includes(e.kind)).filter(e=>!t.scopes||t.scopes.includes(e.scope)).filter(e=>(t.statuses??["active"]).includes(e.status))}function compareRecallPriority(e,t){return t.retrievalPriority-e.retrievalPriority||t.confidence-e.confidence||t.lastConfirmedAt.localeCompare(e.lastConfirmedAt)}function buildMemoryContext(e){return e.map(e=>`- [${e.kind}/${e.scope}] ${e.summary??e.content}`).join("\n")}function normalizeConfidence(e){return void 0===e||Number.isNaN(e)?.6:Math.min(1,Math.max(0,e))}