@smithers-orchestrator/db 0.16.0

package/src/index.js

@@ -0,0 +1,20 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./SchemaRegistryEntry.ts").SchemaRegistryEntry} SchemaRegistryEntry */
+// @smithers-type-exports-end
+
+export * from "./adapter.js";
+export * from "./ensure.js";
+export * from "./input-bounds.js";
+export * from "./frame-codec.js";
+export * from "./input.js";
+export * from "./internal-schema.js";
+export * from "./output.js";
+export * from "./schema-signature.js";
+export * from "./snapshot.js";
+export * from "./sql-message-storage.js";
+export * from "./cache/nodeDiffCache.js";
+export * from "./unwrapZodType.js";
+export * from "./write-retry.js";
+export * from "./zodToCreateTableSQL.js";
+export * from "./zodToTable.js";
+export * from "./utils/camelToSnake.js";

package/src/input-bounds.js

@@ -0,0 +1,12 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./JsonBounds.ts").JsonBounds} JsonBounds */
+// @smithers-type-exports-end
+
+export { assertMaxStringLength } from "./assertMaxStringLength.js";
+export { assertOptionalStringMaxLength } from "./assertOptionalStringMaxLength.js";
+export { assertOptionalArrayMaxLength } from "./assertOptionalArrayMaxLength.js";
+export { assertPositiveFiniteNumber } from "./assertPositiveFiniteNumber.js";
+export { assertPositiveFiniteInteger } from "./assertPositiveFiniteInteger.js";
+export { assertMaxBytes } from "./assertMaxBytes.js";
+export { assertMaxJsonDepth } from "./assertMaxJsonDepth.js";
+export { assertJsonPayloadWithinBounds } from "./assertJsonPayloadWithinBounds.js";

package/src/input.js

@@ -0,0 +1,17 @@
+import { createInsertSchema } from "drizzle-zod";
+import { z } from "zod";
+/** @typedef {import("drizzle-orm").Table} _Table */
+
+/**
+ * @param {_Table} table
+ * @param {unknown} payload
+ * @returns {{ ok: boolean; data?: any; error?: z.ZodError; }}
+ */
+export function validateInput(table, payload) {
+    const schema = createInsertSchema(table);
+    const result = schema.safeParse(payload);
+    if (result.success) {
+        return { ok: true, data: result.data };
+    }
+    return { ok: false, error: result.error };
+}

package/src/internal-schema/index.js

@@ -0,0 +1,19 @@
+export { smithersRuns } from "./smithersRuns.js";
+export { smithersNodes } from "./smithersNodes.js";
+export { smithersAttempts } from "./smithersAttempts.js";
+export { smithersFrames } from "./smithersFrames.js";
+export { smithersApprovals } from "./smithersApprovals.js";
+export { smithersHumanRequests } from "./smithersHumanRequests.js";
+export { smithersAlerts } from "./smithersAlerts.js";
+export { smithersSignals } from "./smithersSignals.js";
+export { smithersCache } from "./smithersCache.js";
+export { smithersNodeDiffs } from "./smithersNodeDiffs.js";
+export { smithersTimeTravelAudit } from "./smithersTimeTravelAudit.js";
+export { smithersSandboxes } from "./smithersSandboxes.js";
+export { smithersToolCalls } from "./smithersToolCalls.js";
+export { smithersEvents } from "./smithersEvents.js";
+export { smithersRalph } from "./smithersRalph.js";
+export { smithersScorers } from "@smithers-orchestrator/scorers/schema";
+export { smithersMemoryFacts, smithersMemoryThreads, smithersMemoryMessages, } from "@smithers-orchestrator/memory/schema";
+export { smithersVectors } from "./smithersVectors.js";
+export { smithersCron } from "./smithersCron.js";

package/src/internal-schema/smithersAlerts.js

@@ -0,0 +1,27 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersAlerts = sqliteTable("_smithers_alerts", {
+    alertId: text("alert_id").primaryKey(),
+    runId: text("run_id"),
+    policyName: text("policy_name").notNull(),
+    severity: text("severity").notNull(),
+    status: text("status").notNull(),
+    firedAtMs: integer("fired_at_ms").notNull(),
+    resolvedAtMs: integer("resolved_at_ms"),
+    acknowledgedAtMs: integer("acknowledged_at_ms"),
+    message: text("message").notNull(),
+    detailsJson: text("details_json"),
+    fingerprint: text("fingerprint"),
+    nodeId: text("node_id"),
+    iteration: integer("iteration"),
+    owner: text("owner"),
+    runbook: text("runbook"),
+    labelsJson: text("labels_json"),
+    reactionJson: text("reaction_json"),
+    sourceEventType: text("source_event_type"),
+    firstFiredAtMs: integer("first_fired_at_ms"),
+    lastFiredAtMs: integer("last_fired_at_ms"),
+    occurrenceCount: integer("occurrence_count").default(1),
+    silencedUntilMs: integer("silenced_until_ms"),
+    acknowledgedBy: text("acknowledged_by"),
+    resolvedBy: text("resolved_by"),
+});

package/src/internal-schema/smithersApprovals.js

@@ -0,0 +1,18 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersApprovals = sqliteTable("_smithers_approvals", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    status: text("status").notNull(),
+    requestedAtMs: integer("requested_at_ms"),
+    decidedAtMs: integer("decided_at_ms"),
+    note: text("note"),
+    decidedBy: text("decided_by"),
+    requestJson: text("request_json"),
+    decisionJson: text("decision_json"),
+    autoApproved: integer("auto_approved", { mode: "boolean" })
+        .notNull()
+        .default(false),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration] }),
+}));

package/src/internal-schema/smithersAttempts.js

@@ -0,0 +1,20 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersAttempts = sqliteTable("_smithers_attempts", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull(),
+    state: text("state").notNull(),
+    startedAtMs: integer("started_at_ms").notNull(),
+    finishedAtMs: integer("finished_at_ms"),
+    heartbeatAtMs: integer("heartbeat_at_ms"),
+    heartbeatDataJson: text("heartbeat_data_json"),
+    errorJson: text("error_json"),
+    jjPointer: text("jj_pointer"),
+    cached: integer("cached", { mode: "boolean" }).default(false),
+    metaJson: text("meta_json"),
+    responseText: text("response_text"),
+    jjCwd: text("jj_cwd"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration, t.attempt] }),
+}));

package/src/internal-schema/smithersCache.js

@@ -0,0 +1,13 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersCache = sqliteTable("_smithers_cache", {
+    cacheKey: text("cache_key").primaryKey(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    workflowName: text("workflow_name").notNull(),
+    nodeId: text("node_id").notNull(),
+    outputTable: text("output_table").notNull(),
+    schemaSig: text("schema_sig").notNull(),
+    agentSig: text("agent_sig"),
+    toolsSig: text("tools_sig"),
+    jjPointer: text("jj_pointer"),
+    payloadJson: text("payload_json").notNull(),
+});

package/src/internal-schema/smithersCron.js

@@ -0,0 +1,11 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersCron = sqliteTable("_smithers_cron", {
+    cronId: text("cron_id").primaryKey(),
+    pattern: text("pattern").notNull(),
+    workflowPath: text("workflow_path").notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).default(true),
+    createdAtMs: integer("created_at_ms").notNull(),
+    lastRunAtMs: integer("last_run_at_ms"),
+    nextRunAtMs: integer("next_run_at_ms"),
+    errorJson: text("error_json"),
+});

package/src/internal-schema/smithersEvents.js

@@ -0,0 +1,10 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersEvents = sqliteTable("_smithers_events", {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    timestampMs: integer("timestamp_ms").notNull(),
+    type: text("type").notNull(),
+    payloadJson: text("payload_json").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.seq] }),
+}));

package/src/internal-schema/smithersFrames.js

@@ -0,0 +1,14 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersFrames = sqliteTable("_smithers_frames", {
+    runId: text("run_id").notNull(),
+    frameNo: integer("frame_no").notNull(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    xmlJson: text("xml_json").notNull(),
+    xmlHash: text("xml_hash").notNull(),
+    encoding: text("encoding").notNull().default("full"),
+    mountedTaskIdsJson: text("mounted_task_ids_json"),
+    taskIndexJson: text("task_index_json"),
+    note: text("note"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.frameNo] }),
+}));

package/src/internal-schema/smithersHumanRequests.js

@@ -0,0 +1,17 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersHumanRequests = sqliteTable("_smithers_human_requests", {
+    requestId: text("request_id").primaryKey(),
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    kind: text("kind").notNull(),
+    status: text("status").notNull(),
+    prompt: text("prompt").notNull(),
+    schemaJson: text("schema_json"),
+    optionsJson: text("options_json"),
+    responseJson: text("response_json"),
+    requestedAtMs: integer("requested_at_ms").notNull(),
+    answeredAtMs: integer("answered_at_ms"),
+    answeredBy: text("answered_by"),
+    timeoutAtMs: integer("timeout_at_ms"),
+});

package/src/internal-schema/smithersNodeDiffs.js

@@ -0,0 +1,12 @@
+import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersNodeDiffs = sqliteTable("_smithers_node_diffs", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull(),
+    baseRef: text("base_ref").notNull(),
+    diffJson: text("diff_json").notNull(),
+    computedAtMs: integer("computed_at_ms").notNull(),
+    sizeBytes: integer("size_bytes").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration, t.baseRef] }),
+}));

package/src/internal-schema/smithersNodes.js

@@ -0,0 +1,13 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersNodes = sqliteTable("_smithers_nodes", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    state: text("state").notNull(),
+    lastAttempt: integer("last_attempt"),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+    outputTable: text("output_table").notNull(),
+    label: text("label"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration] }),
+}));

package/src/internal-schema/smithersRalph.js

@@ -0,0 +1,10 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersRalph = sqliteTable("_smithers_ralph", {
+    runId: text("run_id").notNull(),
+    ralphId: text("ralph_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    done: integer("done", { mode: "boolean" }).notNull().default(false),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.ralphId] }),
+}));

package/src/internal-schema/smithersRuns.js

@@ -0,0 +1,22 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const smithersRuns = sqliteTable("_smithers_runs", {
+    runId: text("run_id").primaryKey(),
+    parentRunId: text("parent_run_id"),
+    workflowName: text("workflow_name").notNull(),
+    workflowPath: text("workflow_path"),
+    workflowHash: text("workflow_hash"),
+    status: text("status").notNull(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    startedAtMs: integer("started_at_ms"),
+    finishedAtMs: integer("finished_at_ms"),
+    heartbeatAtMs: integer("heartbeat_at_ms"),
+    runtimeOwnerId: text("runtime_owner_id"),
+    cancelRequestedAtMs: integer("cancel_requested_at_ms"),
+    hijackRequestedAtMs: integer("hijack_requested_at_ms"),
+    hijackTarget: text("hijack_target"),
+    vcsType: text("vcs_type"),
+    vcsRoot: text("vcs_root"),
+    vcsRevision: text("vcs_revision"),
+    errorJson: text("error_json"),
+    configJson: text("config_json"),
+});

package/src/internal-schema/smithersSandboxes.js

@@ -0,0 +1,16 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersSandboxes = sqliteTable("_smithers_sandboxes", {
+    runId: text("run_id").notNull(),
+    sandboxId: text("sandbox_id").notNull(),
+    runtime: text("runtime").notNull().default("bubblewrap"),
+    remoteRunId: text("remote_run_id"),
+    workspaceId: text("workspace_id"),
+    containerId: text("container_id"),
+    configJson: text("config_json").notNull(),
+    status: text("status").notNull().default("pending"),
+    shippedAtMs: integer("shipped_at_ms"),
+    completedAtMs: integer("completed_at_ms"),
+    bundlePath: text("bundle_path"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.sandboxId] }),
+}));

package/src/internal-schema/smithersSignals.js

@@ -0,0 +1,12 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersSignals = sqliteTable("_smithers_signals", {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    signalName: text("signal_name").notNull(),
+    correlationId: text("correlation_id"),
+    payloadJson: text("payload_json").notNull(),
+    receivedAtMs: integer("received_at_ms").notNull(),
+    receivedBy: text("received_by"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.seq] }),
+}));

package/src/internal-schema/smithersTimeTravelAudit.js

@@ -0,0 +1,12 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const smithersTimeTravelAudit = sqliteTable("_smithers_time_travel_audit", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  runId: text("run_id").notNull(),
+  fromFrameNo: integer("from_frame_no").notNull(),
+  toFrameNo: integer("to_frame_no").notNull(),
+  caller: text("caller").notNull(),
+  timestampMs: integer("timestamp_ms").notNull(),
+  result: text("result").notNull(),
+  durationMs: integer("duration_ms"),
+});

package/src/internal-schema/smithersToolCalls.js

@@ -0,0 +1,19 @@
+import { integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersToolCalls = sqliteTable("_smithers_tool_calls", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull(),
+    seq: integer("seq").notNull(),
+    toolName: text("tool_name").notNull(),
+    inputJson: text("input_json"),
+    outputJson: text("output_json"),
+    startedAtMs: integer("started_at_ms").notNull(),
+    finishedAtMs: integer("finished_at_ms"),
+    status: text("status").notNull(),
+    errorJson: text("error_json"),
+}, (t) => ({
+    pk: primaryKey({
+        columns: [t.runId, t.nodeId, t.iteration, t.attempt, t.seq],
+    }),
+}));

package/src/internal-schema/smithersVectors.js

@@ -0,0 +1,12 @@
+import { blob, integer, sqliteTable, text, } from "drizzle-orm/sqlite-core";
+export const smithersVectors = sqliteTable("_smithers_vectors", {
+    id: text("id").primaryKey(),
+    namespace: text("namespace").notNull(),
+    content: text("content").notNull(),
+    embedding: blob("embedding").notNull(),
+    dimensions: integer("dimensions").notNull(),
+    metadataJson: text("metadata_json"),
+    documentId: text("document_id"),
+    chunkIndex: integer("chunk_index"),
+    createdAtMs: integer("created_at_ms").notNull(),
+});

package/src/internal-schema.js

@@ -0,0 +1,245 @@
+import { blob, integer, sqliteTable, text, primaryKey, } from "drizzle-orm/sqlite-core";
+export const smithersRuns = sqliteTable("_smithers_runs", {
+    runId: text("run_id").primaryKey(),
+    parentRunId: text("parent_run_id"),
+    workflowName: text("workflow_name").notNull(),
+    workflowPath: text("workflow_path"),
+    workflowHash: text("workflow_hash"),
+    status: text("status").notNull(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    startedAtMs: integer("started_at_ms"),
+    finishedAtMs: integer("finished_at_ms"),
+    heartbeatAtMs: integer("heartbeat_at_ms"),
+    runtimeOwnerId: text("runtime_owner_id"),
+    cancelRequestedAtMs: integer("cancel_requested_at_ms"),
+    hijackRequestedAtMs: integer("hijack_requested_at_ms"),
+    hijackTarget: text("hijack_target"),
+    vcsType: text("vcs_type"),
+    vcsRoot: text("vcs_root"),
+    vcsRevision: text("vcs_revision"),
+    errorJson: text("error_json"),
+    configJson: text("config_json"),
+});
+export const smithersNodes = sqliteTable("_smithers_nodes", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    state: text("state").notNull(),
+    lastAttempt: integer("last_attempt"),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+    outputTable: text("output_table").notNull(),
+    label: text("label"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration] }),
+}));
+export const smithersAttempts = sqliteTable("_smithers_attempts", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull(),
+    state: text("state").notNull(),
+    startedAtMs: integer("started_at_ms").notNull(),
+    finishedAtMs: integer("finished_at_ms"),
+    heartbeatAtMs: integer("heartbeat_at_ms"),
+    heartbeatDataJson: text("heartbeat_data_json"),
+    errorJson: text("error_json"),
+    jjPointer: text("jj_pointer"),
+    cached: integer("cached", { mode: "boolean" }).default(false),
+    metaJson: text("meta_json"),
+    responseText: text("response_text"),
+    jjCwd: text("jj_cwd"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration, t.attempt] }),
+}));
+export const smithersFrames = sqliteTable("_smithers_frames", {
+    runId: text("run_id").notNull(),
+    frameNo: integer("frame_no").notNull(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    xmlJson: text("xml_json").notNull(),
+    xmlHash: text("xml_hash").notNull(),
+    encoding: text("encoding").notNull().default("full"),
+    mountedTaskIdsJson: text("mounted_task_ids_json"),
+    taskIndexJson: text("task_index_json"),
+    note: text("note"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.frameNo] }),
+}));
+export const smithersApprovals = sqliteTable("_smithers_approvals", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    status: text("status").notNull(),
+    requestedAtMs: integer("requested_at_ms"),
+    decidedAtMs: integer("decided_at_ms"),
+    note: text("note"),
+    decidedBy: text("decided_by"),
+    requestJson: text("request_json"),
+    decisionJson: text("decision_json"),
+    autoApproved: integer("auto_approved", { mode: "boolean" })
+        .notNull()
+        .default(false),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.nodeId, t.iteration] }),
+}));
+export const smithersHumanRequests = sqliteTable("_smithers_human_requests", {
+    requestId: text("request_id").primaryKey(),
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    kind: text("kind").notNull(),
+    status: text("status").notNull(),
+    prompt: text("prompt").notNull(),
+    schemaJson: text("schema_json"),
+    optionsJson: text("options_json"),
+    responseJson: text("response_json"),
+    requestedAtMs: integer("requested_at_ms").notNull(),
+    answeredAtMs: integer("answered_at_ms"),
+    answeredBy: text("answered_by"),
+    timeoutAtMs: integer("timeout_at_ms"),
+});
+export const smithersAlerts = sqliteTable("_smithers_alerts", {
+    alertId: text("alert_id").primaryKey(),
+    runId: text("run_id"),
+    policyName: text("policy_name").notNull(),
+    severity: text("severity").notNull(),
+    status: text("status").notNull(),
+    firedAtMs: integer("fired_at_ms").notNull(),
+    resolvedAtMs: integer("resolved_at_ms"),
+    acknowledgedAtMs: integer("acknowledged_at_ms"),
+    message: text("message").notNull(),
+    detailsJson: text("details_json"),
+    fingerprint: text("fingerprint"),
+    nodeId: text("node_id"),
+    iteration: integer("iteration"),
+    owner: text("owner"),
+    runbook: text("runbook"),
+    labelsJson: text("labels_json"),
+    reactionJson: text("reaction_json"),
+    sourceEventType: text("source_event_type"),
+    firstFiredAtMs: integer("first_fired_at_ms"),
+    lastFiredAtMs: integer("last_fired_at_ms"),
+    occurrenceCount: integer("occurrence_count").default(1),
+    silencedUntilMs: integer("silenced_until_ms"),
+    acknowledgedBy: text("acknowledged_by"),
+    resolvedBy: text("resolved_by"),
+});
+export const smithersSignals = sqliteTable("_smithers_signals", {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    signalName: text("signal_name").notNull(),
+    correlationId: text("correlation_id"),
+    payloadJson: text("payload_json").notNull(),
+    receivedAtMs: integer("received_at_ms").notNull(),
+    receivedBy: text("received_by"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.seq] }),
+}));
+export const smithersCache = sqliteTable("_smithers_cache", {
+    cacheKey: text("cache_key").primaryKey(),
+    createdAtMs: integer("created_at_ms").notNull(),
+    workflowName: text("workflow_name").notNull(),
+    nodeId: text("node_id").notNull(),
+    outputTable: text("output_table").notNull(),
+    schemaSig: text("schema_sig").notNull(),
+    agentSig: text("agent_sig"),
+    toolsSig: text("tools_sig"),
+    jjPointer: text("jj_pointer"),
+    payloadJson: text("payload_json").notNull(),
+});
+export const smithersNodeDiffs = sqliteTable("_smithers_node_diffs", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull(),
+    baseRef: text("base_ref").notNull(),
+    diffJson: text("diff_json").notNull(),
+    computedAtMs: integer("computed_at_ms").notNull(),
+    sizeBytes: integer("size_bytes").notNull(),
+}, (t) => ({
+    pk: primaryKey({
+        columns: [t.runId, t.nodeId, t.iteration, t.baseRef],
+    }),
+}));
+export const smithersTimeTravelAudit = sqliteTable("_smithers_time_travel_audit", {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    runId: text("run_id").notNull(),
+    fromFrameNo: integer("from_frame_no").notNull(),
+    toFrameNo: integer("to_frame_no").notNull(),
+    caller: text("caller").notNull(),
+    timestampMs: integer("timestamp_ms").notNull(),
+    result: text("result").notNull(),
+    durationMs: integer("duration_ms"),
+});
+export const smithersSandboxes = sqliteTable("_smithers_sandboxes", {
+    runId: text("run_id").notNull(),
+    sandboxId: text("sandbox_id").notNull(),
+    runtime: text("runtime").notNull().default("bubblewrap"),
+    remoteRunId: text("remote_run_id"),
+    workspaceId: text("workspace_id"),
+    containerId: text("container_id"),
+    configJson: text("config_json").notNull(),
+    status: text("status").notNull().default("pending"),
+    shippedAtMs: integer("shipped_at_ms"),
+    completedAtMs: integer("completed_at_ms"),
+    bundlePath: text("bundle_path"),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.sandboxId] }),
+}));
+export const smithersToolCalls = sqliteTable("_smithers_tool_calls", {
+    runId: text("run_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    attempt: integer("attempt").notNull(),
+    seq: integer("seq").notNull(),
+    toolName: text("tool_name").notNull(),
+    inputJson: text("input_json"),
+    outputJson: text("output_json"),
+    startedAtMs: integer("started_at_ms").notNull(),
+    finishedAtMs: integer("finished_at_ms"),
+    status: text("status").notNull(),
+    errorJson: text("error_json"),
+}, (t) => ({
+    pk: primaryKey({
+        columns: [t.runId, t.nodeId, t.iteration, t.attempt, t.seq],
+    }),
+}));
+export const smithersEvents = sqliteTable("_smithers_events", {
+    runId: text("run_id").notNull(),
+    seq: integer("seq").notNull(),
+    timestampMs: integer("timestamp_ms").notNull(),
+    type: text("type").notNull(),
+    payloadJson: text("payload_json").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.seq] }),
+}));
+export const smithersRalph = sqliteTable("_smithers_ralph", {
+    runId: text("run_id").notNull(),
+    ralphId: text("ralph_id").notNull(),
+    iteration: integer("iteration").notNull().default(0),
+    done: integer("done", { mode: "boolean" }).notNull().default(false),
+    updatedAtMs: integer("updated_at_ms").notNull(),
+}, (t) => ({
+    pk: primaryKey({ columns: [t.runId, t.ralphId] }),
+}));
+export { smithersScorers } from "@smithers-orchestrator/scorers/schema";
+export { smithersMemoryFacts, smithersMemoryThreads, smithersMemoryMessages, } from "@smithers-orchestrator/memory/schema";
+export const smithersVectors = sqliteTable("_smithers_vectors", {
+    id: text("id").primaryKey(),
+    namespace: text("namespace").notNull(),
+    content: text("content").notNull(),
+    embedding: blob("embedding").notNull(),
+    dimensions: integer("dimensions").notNull(),
+    metadataJson: text("metadata_json"),
+    documentId: text("document_id"),
+    chunkIndex: integer("chunk_index"),
+    createdAtMs: integer("created_at_ms").notNull(),
+});
+export const smithersCron = sqliteTable("_smithers_cron", {
+    cronId: text("cron_id").primaryKey(),
+    pattern: text("pattern").notNull(),
+    workflowPath: text("workflow_path").notNull(),
+    enabled: integer("enabled", { mode: "boolean" }).default(true),
+    createdAtMs: integer("created_at_ms").notNull(),
+    lastRunAtMs: integer("last_run_at_ms"),
+    nextRunAtMs: integer("next_run_at_ms"),
+    errorJson: text("error_json"),
+});

package/src/isRetryableSqliteWriteError.js

@@ -0,0 +1,53 @@
+/**
+ * @param {unknown} error
+ * @returns {SqliteErrorMetadata | null}
+ */
+function readSqliteErrorMetadata(error) {
+    if (!error || (typeof error !== "object" && !(error instanceof Error))) {
+        return null;
+    }
+    const code = typeof error?.code === "string" ? error.code : "";
+    const message = String(error?.message ?? "");
+    return { code, message };
+}
+/**
+ * @param {unknown} error
+ * @returns {SqliteErrorMetadata | null}
+ */
+function findSqliteErrorMetadata(error) {
+    const seen = new Set();
+    let current = error;
+    while (current && !seen.has(current)) {
+        seen.add(current);
+        const metadata = readSqliteErrorMetadata(current);
+        if (metadata) {
+            const message = metadata.message.toLowerCase();
+            if (metadata.code.startsWith("SQLITE_BUSY") ||
+                metadata.code.startsWith("SQLITE_IOERR") ||
+                message.includes("database is locked") ||
+                message.includes("database is busy") ||
+                message.includes("disk i/o error")) {
+                return metadata;
+            }
+        }
+        current = current?.cause;
+    }
+    return readSqliteErrorMetadata(error);
+}
+/**
+ * @param {unknown} error
+ * @returns {boolean}
+ */
+export function isRetryableSqliteWriteError(error) {
+    const metadata = findSqliteErrorMetadata(error);
+    if (!metadata)
+        return false;
+    const { code } = metadata;
+    if (code.startsWith("SQLITE_BUSY") || code.startsWith("SQLITE_IOERR")) {
+        return true;
+    }
+    const message = metadata.message.toLowerCase();
+    return (message.includes("database is locked") ||
+        message.includes("database is busy") ||
+        message.includes("disk i/o error"));
+}