stable-harness 0.0.1

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

@@ -0,0 +1,526 @@
+import type { MemoryCandidate, MemoryDecision, MemoryProvider, MemoryRecord, RuntimeMemoryStore } from "@stable-harness/memory";
+import type { ApprovalQueue, ApprovalRequest } from "@stable-harness/governance";
+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 WorkspaceModel = {
+    id: string;
+    provider: string;
+    model: string;
+    config?: Record<string, unknown>;
+};
+export type WorkspaceTool = {
+    id: string;
+    description?: string;
+    schema?: 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[];
+    config: Record<string, unknown>;
+};
+export type WorkspaceRuntimePolicy = {
+    defaultAgentId: string;
+    workspaceId?: string;
+    profile?: string;
+    approvals?: Record<string, unknown>;
+    recovery?: Record<string, unknown>;
+    retry?: WorkspaceRetryPolicy;
+    memory?: Record<string, unknown>;
+    protocols?: 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>;
+};
+export type RuntimeRequest = {
+    input: string;
+    agentId?: string;
+    sessionId?: string;
+    requestId?: string;
+    parentRunId?: string;
+    toolCall?: RuntimeToolCallRequest;
+    memory?: RuntimeRequestMemory;
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeToolCallRequest = {
+    toolId: string;
+    args?: 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;
+};
+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;
+export type RuntimeAdapterContext = {
+    workspace: CompiledWorkspace;
+    agent: WorkspaceAgent;
+    request: RuntimeRequest;
+    requestId: string;
+    sessionId: string;
+    memory?: RuntimeMemoryContext;
+    pluginMemories?: RuntimeMemoryContext[];
+    toolGateway?: RuntimeToolGateway;
+    emit: RuntimeEmit;
+};
+export type RuntimeMemoryContext = {
+    namespace: string;
+    records: MemoryRecord[];
+    context: string;
+};
+export type RuntimeAdapterResult = string | RuntimeOutput;
+export type RuntimeAdapter = {
+    name: string;
+    canRun(agent: WorkspaceAgent): boolean;
+    run(input: RuntimeAdapterContext): Promise<RuntimeAdapterResult>;
+};
+export type RuntimeMemoryServices = {
+    store: RuntimeMemoryStore;
+    providers?: MemoryProvider[];
+};
+export type RuntimeGovernanceServices = {
+    approvals?: ApprovalQueue;
+};
+export type RuntimeToolServices = {
+    gateway?: RuntimeToolGateway;
+};
+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;
+    }>;
+};
+export type RuntimeInspectionSnapshot = {
+    workspaceRoot: string;
+    agents: string[];
+    models: string[];
+    tools: string[];
+    runs: RuntimeRunRecord[];
+};
+export type RuntimeRequestSummary = {
+    requestId: string;
+    sessionId: string;
+    agentId: string;
+    parentRunId?: string;
+    state: RuntimeRecordState;
+    startedAt: string;
+    completedAt?: string;
+    eventCount: number;
+    artifactCount: number;
+};
+export type RuntimeSessionSummary = {
+    sessionId: string;
+    requestCount: number;
+    agentIds: string[];
+    states: Partial<Record<RuntimeRecordState, number>>;
+    startedAt: string;
+    updatedAt: string;
+};
+export type RuntimeBindingSnapshot = {
+    workspaceRoot: string;
+    agentId: string;
+    backend: string;
+    modelRef?: string;
+    tools: string[];
+    skills: string[];
+    subagents: string[];
+};
+export type RuntimeTimelineItem = {
+    index: number;
+    type: RuntimeEvent["type"];
+    event: RuntimeEvent;
+};
+export type RuntimeRequestInspection = {
+    summary: RuntimeRequestSummary;
+    input: string;
+    output?: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    artifacts: RuntimeArtifact[];
+    runtimeSnapshot: RuntimeBindingSnapshot;
+    timeline: RuntimeTimelineItem[];
+};
+export type RuntimeClient = {
+    request(request: RuntimeRequest): Promise<RuntimeResponse>;
+};
+export type RuntimeEventSource = {
+    subscribe(listener: RuntimeEventListener): () => void;
+};
+export type RuntimeInspector = {
+    inspect(): RuntimeInspectionSnapshot;
+    getRun(requestId: string): RuntimeRunRecord | undefined;
+    listRequests(filter?: RuntimeRunFilter): RuntimeRequestSummary[];
+    listSessions(): RuntimeSessionSummary[];
+    inspectRequest(requestId: string): RuntimeRequestInspection | undefined;
+};
+export type RuntimeLifecycle = {
+    cancel(requestId: string, reason?: string): void;
+    stop(): Promise<void>;
+};
+export type StableHarnessRuntime = RuntimeClient & RuntimeEventSource & RuntimeInspector & RuntimeLifecycle;

package/packages/core/dist/types.js

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

package/packages/core/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@stable-harness/core",
+  "version": "0.0.1",
+  "type": "module",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@stable-harness/governance": "0.0.1",
+    "@stable-harness/memory": "0.0.1"
+  }
+}

package/packages/evaluation/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export { createTraceRecorder, createReplayManifest, createEvaluationBundle } from "./trace.js";
+export type { EvaluationBundle, ReplayManifest } from "./types.js";

package/packages/evaluation/dist/src/index.js

@@ -0,0 +1 @@
+export{createTraceRecorder,createReplayManifest,createEvaluationBundle}from"./trace.js";

package/packages/evaluation/dist/src/trace.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeArtifactRecord, RuntimeEvent, RuntimeRunRecord } from "@stable-harness/core";
+import type { EvaluationBundle, ReplayManifest } from "./types.js";
+export declare function createTraceRecorder(): {
+    listener(event: RuntimeEvent): void;
+    events(): RuntimeEvent[];
+};
+export declare function createReplayManifest(input: {
+    runs: RuntimeRunRecord[];
+    events: RuntimeEvent[];
+}): ReplayManifest;
+export declare function createEvaluationBundle(input: {
+    runs: RuntimeRunRecord[];
+    events: RuntimeEvent[];
+    artifacts?: RuntimeArtifactRecord[];
+    metadata?: Record<string, unknown>;
+}): EvaluationBundle;

package/packages/evaluation/dist/src/trace.js

@@ -0,0 +1 @@
+export function createTraceRecorder(){const e=[];return{listener(t){e.push(t)},events:()=>[...e]}}export function createReplayManifest(e){return{schemaVersion:1,createdAt:(new Date).toISOString(),runs:e.runs,events:e.events}}export function createEvaluationBundle(e){return{...createReplayManifest({runs:e.runs,events:e.events}),artifacts:e.artifacts??[],metadata:e.metadata}}

package/packages/evaluation/dist/src/types.d.ts

@@ -0,0 +1,11 @@
+import type { RuntimeArtifactRecord, RuntimeEvent, RuntimeRunRecord } from "@stable-harness/core";
+export type ReplayManifest = {
+    schemaVersion: 1;
+    createdAt: string;
+    runs: RuntimeRunRecord[];
+    events: RuntimeEvent[];
+};
+export type EvaluationBundle = ReplayManifest & {
+    artifacts: RuntimeArtifactRecord[];
+    metadata?: Record<string, unknown>;
+};

package/packages/evaluation/dist/src/types.js

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

package/packages/evaluation/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@stable-harness/evaluation",
+  "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",
+  "dependencies": {
+    "@stable-harness/core": "0.0.1"
+  }
+}

package/packages/governance/dist/src/approval-queue.d.ts

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

package/packages/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},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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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 r}from"node:sqlite";export function createSqliteSkillCandidateStore(c){t(n.dirname(c),{recursive:!0});const o=new r(c);return function(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  ")}(o),{async upsert(t){const n=(new Date).toISOString(),r=function(e,t,n){const r=e.prepare("select * from skill_candidates where workspace_id = ? and name = ?").get(t,n);return r?d(r):void 0}(o,t.workspaceId,t.name),i=r?function(e,t,n,r){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,r,t),a(e,t)}(o,r.id,t,n):function(t,n,r){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,r,r),a(t,d)}(o,t,n);return function(t,n,r,a){t.prepare("delete from skill_candidate_evidence where candidate_id = ?").run(n);const d=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 r)d.run(String(e()),n,t.evidenceType,t.evidenceRef,t.summary??null,t.weight??null,a)}(o,i.id,t.evidence,n),i},list:async(e={})=>function(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=>d(e))}(o,e.workspaceId,e.status),get:async e=>a(o,e),listEvidence:async e=>function(e,t){return e.prepare("select * from skill_candidate_evidence where candidate_id = ? order by created_at asc").all(t).map(e=>function(e){return{id:String(e.id),candidateId:String(e.candidate_id),evidenceType:e.evidence_type,evidenceRef:String(e.evidence_ref),summary:i(e.summary),weight:"number"==typeof e.weight?e.weight:void 0,createdAt:String(e.created_at)}}(e))}(o,e),async updateStatus(e){const t=(new Date).toISOString();return o.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),a(o,e.id)}}}function a(e,t){const n=e.prepare("select * from skill_candidates where id = ?").get(t);return n?d(n):void 0}function d(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:i(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:i(e.reviewed_at),reviewedBy:i(e.reviewed_by),rejectionReason:i(e.rejection_reason)}}function i(e){return"string"==typeof e&&e?e:void 0}