@hold-rein/cli 0.0.0

package/dist/runtime/api/db/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/db/schema.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB3B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBhC,CAAC;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBhC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBrC,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYtB,CAAC;AAEF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0CjB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBrB,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBjC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC9E,MAAM,MAAM,yBAAyB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AACjF,MAAM,MAAM,iBAAiB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACvE,MAAM,MAAM,sBAAsB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC9E,MAAM,MAAM,yBAAyB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AACjF,MAAM,MAAM,aAAa,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,gBAAgB,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAChE,MAAM,MAAM,sBAAsB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AAC9E,MAAM,MAAM,yBAAyB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAC;AACjF,MAAM,MAAM,2BAA2B,GACrC,OAAO,yBAAyB,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,8BAA8B,GACxC,OAAO,yBAAyB,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,YAAY,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG,OAAO,UAAU,CAAC,YAAY,CAAC;AAC7D,MAAM,MAAM,OAAO,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,UAAU,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AACnD,MAAM,MAAM,WAAW,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AAC3D,MAAM,MAAM,wBAAwB,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAC;AACjF,MAAM,MAAM,2BAA2B,GAAG,OAAO,qBAAqB,CAAC,YAAY,CAAC"}

package/dist/runtime/api/db/schema.js

@@ -0,0 +1,148 @@
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+export const customModelProviders = sqliteTable("custom_model_providers", {
+    baseUrl: text("base_url").notNull(),
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    providerUniqueIndex: uniqueIndex("custom_model_providers_provider_idx").on(table.provider)
+}));
+export const providerApiKeys = sqliteTable("provider_api_keys", {
+    apiKeyCiphertext: text("api_key_ciphertext").notNull(),
+    apiKeyIv: text("api_key_iv").notNull(),
+    apiKeyTag: text("api_key_tag").notNull(),
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    providerUniqueIndex: uniqueIndex("provider_api_keys_provider_idx").on(table.provider)
+}));
+export const customProviderModels = sqliteTable("custom_provider_models", {
+    api: text("api").notNull(),
+    contextWindow: integer("context_window").notNull(),
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    input: text("input").notNull(),
+    maxTokens: integer("max_tokens").notNull(),
+    modelId: text("model_id").notNull(),
+    name: text("name").notNull(),
+    providerId: text("provider_id")
+        .notNull()
+        .references(() => customModelProviders.id),
+    reasoning: integer("reasoning", { mode: "boolean" }).notNull(),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    providerModelUniqueIndex: uniqueIndex("custom_provider_models_provider_model_idx").on(table.providerId, table.modelId)
+}));
+export const modelProxies = sqliteTable("model_proxies", {
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    modelId: text("model_id").notNull(),
+    name: text("name").notNull(),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    modelIdUniqueIndex: uniqueIndex("model_proxies_model_id_idx").on(table.modelId)
+}));
+export const modelProxyCandidates = sqliteTable("model_proxy_candidates", {
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    modelId: text("model_id").notNull(),
+    priority: integer("priority").notNull(),
+    provider: text("provider").notNull(),
+    proxyId: text("proxy_id")
+        .notNull()
+        .references(() => modelProxies.id, { onDelete: "cascade" }),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    proxyPriorityIndex: index("model_proxy_candidates_proxy_priority_idx").on(table.proxyId, table.priority)
+}));
+export const modelProxyCandidateLimits = sqliteTable("model_proxy_candidate_limits", {
+    candidateId: text("candidate_id")
+        .notNull()
+        .references(() => modelProxyCandidates.id, { onDelete: "cascade" }),
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    maxTokens: integer("max_tokens").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    windowHours: integer("window_hours"),
+    windowType: text("window_type", { enum: ["hours", "day", "week"] }).notNull()
+}, (table) => ({
+    candidateIndex: index("model_proxy_candidate_limits_candidate_idx").on(table.candidateId)
+}));
+export const workspaces = sqliteTable("workspaces", {
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    name: text("name").notNull(),
+    path: text("path").notNull(),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    pathUniqueIndex: uniqueIndex("workspaces_path_idx").on(table.path)
+}));
+export const tasks = sqliteTable("tasks", {
+    createdAt: text("created_at").notNull(),
+    id: text("id").primaryKey(),
+    initialUserMessage: text("initial_user_message").notNull(),
+    inputToken: integer("input_token").notNull().default(0),
+    approvalPolicy: text("approval_policy", {
+        enum: ["approval", "run_all"]
+    })
+        .notNull()
+        .default("approval"),
+    lastContinuedAt: text("last_continued_at"),
+    lastModelId: text("last_model_id"),
+    lastModelName: text("last_model_name").notNull(),
+    lastModelProvider: text("last_model_provider").notNull(),
+    lastModelProviderSource: text("last_model_provider_source", {
+        enum: ["built_in", "custom"]
+    }).notNull(),
+    outputToken: integer("output_token").notNull().default(0),
+    sessionCreatedAt: text("session_created_at"),
+    sessionId: text("session_id"),
+    sessionPath: text("session_path"),
+    status: text("status", {
+        enum: ["running", "completed", "error"]
+    })
+        .notNull()
+        .default("completed"),
+    thinkingLevel: text("thinking_level", {
+        enum: ["off", "minimal", "low", "medium", "high", "xhigh"]
+    })
+        .notNull()
+        .default("medium"),
+    title: text("title").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    workspaceId: text("workspace_id")
+        .notNull()
+        .references(() => workspaces.id)
+}, (table) => ({
+    workspaceIdIndex: index("tasks_workspace_id_idx").on(table.workspaceId)
+}));
+export const subagents = sqliteTable("subagents", {
+    agentId: text("agent_id").primaryKey(),
+    agentName: text("agent_name").notNull().default("subagent"),
+    createdAt: text("created_at").notNull(),
+    parentAgentId: text("parent_agent_id").notNull(),
+    sessionCreatedAt: text("session_created_at"),
+    sessionId: text("session_id"),
+    sessionPath: text("session_path"),
+    status: text("status", {
+        enum: ["running", "completed", "interrupted"]
+    }).notNull(),
+    taskId: text("task_id")
+        .notNull()
+        .references(() => tasks.id, { onDelete: "cascade" }),
+    updatedAt: text("updated_at").notNull()
+}, (table) => ({
+    taskIdIndex: index("subagents_task_id_idx").on(table.taskId)
+}));
+export const modelTokenUsageHourly = sqliteTable("model_token_usage_hourly", {
+    hour: text("hour").notNull(),
+    inputToken: integer("input_token").notNull().default(0),
+    modelName: text("model_name").notNull(),
+    outputToken: integer("output_token").notNull().default(0),
+    provider: text("provider").notNull()
+}, (table) => ({
+    modelHourUniqueIndex: uniqueIndex("model_token_usage_hourly_model_hour_idx").on(table.provider, table.modelName, table.hour)
+}));

package/dist/runtime/api/middleware/error-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { NextFunction, Request, Response } from "express";
+export declare function errorMiddleware(error: Error, _request: Request, response: Response, _next: NextFunction): void;
+//# sourceMappingURL=error-middleware.d.ts.map

package/dist/runtime/api/middleware/error-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/error-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAI/D,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,OAAO,EACjB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,YAAY,GAClB,IAAI,CAQN"}

package/dist/runtime/api/middleware/error-middleware.js

@@ -0,0 +1,5 @@
+import { RESPONSE_CODE_DEFINITIONS, sendError } from "../response/index.js";
+export function errorMiddleware(error, _request, response, _next) {
+    void _next;
+    sendError(response, RESPONSE_CODE_DEFINITIONS.internalError, error.message || RESPONSE_CODE_DEFINITIONS.internalError.defaultMessage);
+}

package/dist/runtime/api/middleware/not-found-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { Request, Response } from "express";
+export declare function notFoundMiddleware(_request: Request, response: Response): void;
+//# sourceMappingURL=not-found-middleware.d.ts.map

package/dist/runtime/api/middleware/not-found-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"not-found-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/not-found-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIjD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAE9E"}

package/dist/runtime/api/middleware/not-found-middleware.js

@@ -0,0 +1,4 @@
+import { RESPONSE_CODE_DEFINITIONS, sendError } from "../response/index.js";
+export function notFoundMiddleware(_request, response) {
+    sendError(response, RESPONSE_CODE_DEFINITIONS.notFound);
+}

package/dist/runtime/api/modules/agents/active-task-run-registry.d.ts

@@ -0,0 +1,10 @@
+export interface ActiveTaskRunRegistry {
+    getAgentId: (taskId: string) => string | undefined;
+    hasTask: (taskId: string) => boolean;
+    markStarting: (taskId: string) => void;
+    register: (taskId: string, agentId: string) => void;
+    remove: (taskId: string) => void;
+}
+export declare function createActiveTaskRunRegistry(): ActiveTaskRunRegistry;
+export declare function getDefaultActiveTaskRunRegistry(): ActiveTaskRunRegistry;
+//# sourceMappingURL=active-task-run-registry.d.ts.map

package/dist/runtime/api/modules/agents/active-task-run-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-task-run-registry.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/active-task-run-registry.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACnD,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IACrC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED,wBAAgB,2BAA2B,IAAI,qBAAqB,CAgBnE;AAID,wBAAgB,+BAA+B,IAAI,qBAAqB,CAEvE"}

package/dist/runtime/api/modules/agents/active-task-run-registry.js

@@ -0,0 +1,20 @@
+export function createActiveTaskRunRegistry() {
+    const agentIdsByTaskId = new Map();
+    return {
+        getAgentId: (taskId) => agentIdsByTaskId.get(taskId),
+        hasTask: (taskId) => agentIdsByTaskId.has(taskId),
+        markStarting: (taskId) => {
+            agentIdsByTaskId.set(taskId, undefined);
+        },
+        register: (taskId, agentId) => {
+            agentIdsByTaskId.set(taskId, agentId);
+        },
+        remove: (taskId) => {
+            agentIdsByTaskId.delete(taskId);
+        }
+    };
+}
+const defaultActiveTaskRunRegistry = createActiveTaskRunRegistry();
+export function getDefaultActiveTaskRunRegistry() {
+    return defaultActiveTaskRunRegistry;
+}

package/dist/runtime/api/modules/agents/agent-approval-store.d.ts

@@ -0,0 +1,7 @@
+import type { ApprovalDecision, ApprovalDecisionInput, ToolApprovalRequest } from "./agent-types";
+export interface AgentApprovalStore {
+    decide: (input: ApprovalDecisionInput) => boolean;
+    request: (request: ToolApprovalRequest) => Promise<ApprovalDecision>;
+}
+export declare function createAgentApprovalStore(): AgentApprovalStore;
+//# sourceMappingURL=agent-approval-store.d.ts.map

package/dist/runtime/api/modules/agents/agent-approval-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-approval-store.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-approval-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,OAAO,CAAC;IAClD,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACtE;AAOD,wBAAgB,wBAAwB,IAAI,kBAAkB,CA2B7D"}

package/dist/runtime/api/modules/agents/agent-approval-store.js

@@ -0,0 +1,23 @@
+export function createAgentApprovalStore() {
+    const pendingApprovals = new Map();
+    return {
+        decide: (input) => {
+            const pending = pendingApprovals.get(input.approvalId);
+            if (!pending || pending.agentId !== input.agentId) {
+                return false;
+            }
+            pendingApprovals.delete(input.approvalId);
+            pending.resolve({
+                approved: input.approved,
+                ...(input.reason === undefined ? {} : { reason: input.reason })
+            });
+            return true;
+        },
+        request: (request) => new Promise((resolve) => {
+            pendingApprovals.set(request.approvalId, {
+                agentId: request.agentId,
+                resolve
+            });
+        })
+    };
+}

package/dist/runtime/api/modules/agents/agent-event-bus.d.ts

@@ -0,0 +1,8 @@
+import type { AgentEventEnvelope, AgentEventSubscription, SubscribeAgentEventsInput } from "./agent-types";
+export type AgentEventListener = (event: AgentEventEnvelope) => void;
+export interface AgentEventBus {
+    emit: (event: Omit<AgentEventEnvelope, "sequence" | "timestamp">) => void;
+    subscribe: (input: SubscribeAgentEventsInput, listener: AgentEventListener) => AgentEventSubscription;
+}
+export declare function createAgentEventBus(): AgentEventBus;
+//# sourceMappingURL=agent-event-bus.d.ts.map

package/dist/runtime/api/modules/agents/agent-event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-event-bus.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-event-bus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,yBAAyB,EAC1B,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,GAAG,WAAW,CAAC,KAAK,IAAI,CAAC;IAC1E,SAAS,EAAE,CACT,KAAK,EAAE,yBAAyB,EAChC,QAAQ,EAAE,kBAAkB,KACzB,sBAAsB,CAAC;CAC7B;AAED,wBAAgB,mBAAmB,IAAI,aAAa,CA6CnD"}

package/dist/runtime/api/modules/agents/agent-event-bus.js

@@ -0,0 +1,40 @@
+export function createAgentEventBus() {
+    const listeners = new Map();
+    const events = new Map();
+    const sequences = new Map();
+    return {
+        emit: (event) => {
+            const sequence = (sequences.get(event.agentId) ?? 0) + 1;
+            sequences.set(event.agentId, sequence);
+            const envelope = {
+                ...event,
+                sequence,
+                timestamp: new Date().toISOString()
+            };
+            const agentEvents = events.get(event.agentId) ?? [];
+            agentEvents.push(envelope);
+            events.set(event.agentId, agentEvents);
+            for (const listener of listeners.get(event.agentId) ?? []) {
+                listener(envelope);
+            }
+        },
+        subscribe: (input, listener) => {
+            for (const event of events.get(input.agentId) ?? []) {
+                if (event.sequence > (input.afterSequence ?? 0)) {
+                    listener(event);
+                }
+            }
+            const agentListeners = listeners.get(input.agentId) ?? new Set();
+            agentListeners.add(listener);
+            listeners.set(input.agentId, agentListeners);
+            return {
+                unsubscribe: () => {
+                    agentListeners.delete(listener);
+                    if (agentListeners.size === 0) {
+                        listeners.delete(input.agentId);
+                    }
+                }
+            };
+        }
+    };
+}

package/dist/runtime/api/modules/agents/agent-message-repository.d.ts

@@ -0,0 +1,22 @@
+import type { AppDatabase } from "../../db";
+import type { StoredAgentMessage } from "./agent-types";
+export interface AppendTaskMessageInput {
+    agentId: string;
+    createdAt: string;
+    message: StoredAgentMessage;
+    taskId: string;
+}
+export interface StoredTaskMessage {
+    agentId: string;
+    createdAt: string;
+    message: StoredAgentMessage;
+    sequence: number;
+    taskId: string;
+}
+export interface AgentMessageRepository {
+    append: (input: AppendTaskMessageInput) => StoredTaskMessage;
+    listByTaskId: (taskId: string) => StoredTaskMessage[];
+}
+export declare function createInMemoryAgentMessageRepository(): AgentMessageRepository;
+export declare function createSqliteAgentMessageRepository(database: AppDatabase): AgentMessageRepository;
+//# sourceMappingURL=agent-message-repository.d.ts.map

package/dist/runtime/api/modules/agents/agent-message-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-message-repository.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-message-repository.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,iBAAiB,CAAC;IAC7D,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,iBAAiB,EAAE,CAAC;CACvD;AAED,wBAAgB,oCAAoC,IAAI,sBAAsB,CAuB7E;AAED,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,WAAW,GACpB,sBAAsB,CAyCxB"}

package/dist/runtime/api/modules/agents/agent-message-repository.js

@@ -0,0 +1,60 @@
+import { asc, desc, eq } from "drizzle-orm";
+import { taskMessages } from "../../db/index.js";
+export function createInMemoryAgentMessageRepository() {
+    const rows = [];
+    return {
+        append: (input) => {
+            const row = {
+                ...input,
+                sequence: Math.max(0, ...rows
+                    .filter((candidate) => candidate.taskId === input.taskId)
+                    .map((candidate) => candidate.sequence)) + 1
+            };
+            rows.push(row);
+            return row;
+        },
+        listByTaskId: (taskId) => rows
+            .filter((row) => row.taskId === taskId)
+            .sort((left, right) => left.sequence - right.sequence)
+    };
+}
+export function createSqliteAgentMessageRepository(database) {
+    return {
+        append: (input) => {
+            const latest = database.db
+                .select({ sequence: taskMessages.sequence })
+                .from(taskMessages)
+                .where(eq(taskMessages.taskId, input.taskId))
+                .orderBy(desc(taskMessages.sequence))
+                .get();
+            const sequence = (latest?.sequence ?? 0) + 1;
+            database.db
+                .insert(taskMessages)
+                .values({
+                agentId: input.agentId,
+                createdAt: input.createdAt,
+                id: input.message.id,
+                payload: JSON.stringify(input.message),
+                role: input.message.role,
+                sequence,
+                taskId: input.taskId,
+                updatedAt: input.createdAt
+            })
+                .run();
+            return { ...input, sequence };
+        },
+        listByTaskId: (taskId) => database.db
+            .select()
+            .from(taskMessages)
+            .where(eq(taskMessages.taskId, taskId))
+            .orderBy(asc(taskMessages.sequence))
+            .all()
+            .map((row) => ({
+            agentId: row.agentId,
+            createdAt: row.createdAt,
+            message: JSON.parse(row.payload),
+            sequence: row.sequence,
+            taskId: row.taskId
+        }))
+    };
+}

package/dist/runtime/api/modules/agents/agent-message-storage.d.ts

@@ -0,0 +1,4 @@
+import type { StoredAgentMessage } from "./agent-types";
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+export declare function toStoredAgentMessage(id: string, message: AgentMessage): StoredAgentMessage;
+//# sourceMappingURL=agent-message-storage.d.ts.map

package/dist/runtime/api/modules/agents/agent-message-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-message-storage.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-message-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAElE,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,YAAY,GACpB,kBAAkB,CAYpB"}

package/dist/runtime/api/modules/agents/agent-message-storage.js

@@ -0,0 +1,11 @@
+export function toStoredAgentMessage(id, message) {
+    const stored = { ...message, id };
+    if (stored.role !== "custom") {
+        delete stored.details;
+    }
+    delete stored.diagnostics;
+    delete stored.responseId;
+    delete stored.responseModel;
+    delete stored.usage;
+    return stored;
+}

package/dist/runtime/api/modules/agents/agent-model-resolver.d.ts

@@ -0,0 +1,4 @@
+import { type Api, type Model } from "@earendil-works/pi-ai";
+export type AgentModelLookup = (provider: string, modelId: string) => Model<Api> | null | Promise<Model<Api> | null>;
+export declare function resolveAgentModel(provider: string, modelId: string, getCustomModel?: AgentModelLookup): Promise<Model<Api> | null>;
+//# sourceMappingURL=agent-model-resolver.d.ts.map

package/dist/runtime/api/modules/agents/agent-model-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-model-resolver.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-model-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,GAAG,EAER,KAAK,KAAK,EACX,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,gBAAgB,GAAG,CAC7B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,KACZ,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;AAEpD,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,cAAc,CAAC,EAAE,gBAAgB,GAChC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAQ5B"}

package/dist/runtime/api/modules/agents/agent-model-resolver.js

@@ -0,0 +1,17 @@
+import { getModels } from "@earendil-works/pi-ai";
+export async function resolveAgentModel(provider, modelId, getCustomModel) {
+    const builtInModel = findBuiltInModel(provider, modelId);
+    if (builtInModel) {
+        return builtInModel;
+    }
+    return (await getCustomModel?.(provider, modelId)) ?? null;
+}
+function findBuiltInModel(provider, modelId) {
+    try {
+        return (getModels(provider).find((model) => model.id === modelId) ??
+            null);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime/api/modules/agents/agent-runtime-messages.d.ts

@@ -0,0 +1,12 @@
+import type { AgentEventBus } from "./agent-event-bus";
+export declare function appendVisibleCustomMessage(input: {
+    agentId: string;
+    content: string;
+    customType: string;
+    details?: unknown;
+    eventBus: AgentEventBus;
+    session: {
+        appendCustomMessageEntry: (customType: string, content: string, display: boolean, details?: unknown) => Promise<unknown>;
+    };
+}): Promise<void>;
+//# sourceMappingURL=agent-runtime-messages.d.ts.map

package/dist/runtime/api/modules/agents/agent-runtime-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime-messages.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-runtime-messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,wBAAsB,0BAA0B,CAAC,KAAK,EAAE;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE;QACP,wBAAwB,EAAE,CACxB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,OAAO,KACd,OAAO,CAAC,OAAO,CAAC,CAAC;KACvB,CAAC;CACH,iBAsBA"}

package/dist/runtime/api/modules/agents/agent-runtime-messages.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+export async function appendVisibleCustomMessage(input) {
+    await input.session.appendCustomMessageEntry(input.customType, input.content, true, input.details);
+    input.eventBus.emit({
+        agentId: input.agentId,
+        payload: {
+            message: {
+                content: input.content,
+                customType: input.customType,
+                ...(input.details === undefined ? {} : { details: input.details }),
+                display: true,
+                id: `message_${randomUUID()}`,
+                role: "custom",
+                timestamp: Date.now()
+            }
+        },
+        type: "message_start"
+    });
+}

package/dist/runtime/api/modules/agents/agent-runtime-support.d.ts

@@ -0,0 +1,12 @@
+import { type AgentHarness, type JsonlSessionRepoApi } from "@earendil-works/pi-agent-core/node";
+import type { AgentSessionMetadata } from "./agent-types";
+export declare function interruptHarness(harness: AgentHarness): Promise<void>;
+export declare function createSessionRepo(): JsonlSessionRepoApi;
+export declare function getSkillDirs(workspacePath: string, configuredSkillDirs?: string[]): string[];
+export declare function getEnvApiKey(provider: string): string | undefined;
+export declare function toAgentSessionMetadata(metadata: {
+    createdAt: string;
+    id: string;
+    path: string;
+}): AgentSessionMetadata;
+//# sourceMappingURL=agent-runtime-support.d.ts.map

package/dist/runtime/api/modules/agents/agent-runtime-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime-support.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-runtime-support.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAO1D,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAc3E;AAED,wBAAgB,iBAAiB,IAAI,mBAAmB,CAKvD;AAED,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAC7B,MAAM,EAAE,CAKV;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE;IAC/C,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,oBAAoB,CAMvB"}

package/dist/runtime/api/modules/agents/agent-runtime-support.js

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { JsonlSessionRepo, NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
+import { SESSIONS_DIR } from "../../config/const.js";
+export async function interruptHarness(harness) {
+    const interruptibleHarness = harness;
+    if (interruptibleHarness.interrupt) {
+        await interruptibleHarness.interrupt();
+        return;
+    }
+    if (interruptibleHarness.abort) {
+        await interruptibleHarness.abort();
+        return;
+    }
+    throw new Error("Agent runtime does not support interruption");
+}
+export function createSessionRepo() {
+    return new JsonlSessionRepo({
+        fs: new NodeExecutionEnv({ cwd: SESSIONS_DIR }),
+        sessionsRoot: SESSIONS_DIR
+    });
+}
+export function getSkillDirs(workspacePath, configuredSkillDirs) {
+    return configuredSkillDirs ?? [
+        join(workspacePath, ".hold-rein", "skills"),
+        join(homedir(), ".hold-rein", "skills")
+    ];
+}
+export function getEnvApiKey(provider) {
+    return process.env[`${provider.toUpperCase()}_API_KEY`];
+}
+export function toAgentSessionMetadata(metadata) {
+    return {
+        createdAt: metadata.createdAt,
+        id: metadata.id,
+        path: metadata.path
+    };
+}

package/dist/runtime/api/modules/agents/agent-runtime.d.ts

@@ -0,0 +1,25 @@
+import { type JsonlSessionRepoApi } from "@earendil-works/pi-agent-core/node";
+import type { AgentApprovalStore } from "./agent-approval-store";
+import type { AgentEventBus } from "./agent-event-bus";
+import { type AgentModelLookup } from "./agent-model-resolver";
+import { type AgentRunResult, type AgentSessionMetadata, type StoredAgentMessage, type RunAgentInput } from "./agent-types";
+import { type SubagentRepository } from "./subagent-repository";
+export interface AgentRuntime {
+    interrupt: (agentId: string) => Promise<boolean>;
+    listMessages: (input: {
+        session: AgentSessionMetadata;
+        workspacePath: string;
+    }) => Promise<StoredAgentMessage[]>;
+    start: (input: RunAgentInput) => Promise<AgentRunResult>;
+}
+export interface CreateAgentRuntimeOptions {
+    approvalStore: AgentApprovalStore;
+    eventBus: AgentEventBus;
+    getApiKey?: (provider: string, modelId: string) => Promise<string | undefined>;
+    getCustomModel?: AgentModelLookup;
+    sessionRepo?: JsonlSessionRepoApi;
+    skillDirs?: string[];
+    subagentRepository?: SubagentRepository;
+}
+export declare function createAgentRuntime(options: CreateAgentRuntimeOptions): AgentRuntime;
+//# sourceMappingURL=agent-runtime.d.ts.map

package/dist/runtime/api/modules/agents/agent-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime.d.ts","sourceRoot":"","sources":["../../../src/modules/agents/agent-runtime.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2E,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAEvJ,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,oBAAoB,EAAE,KAAK,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAK5H,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,uBAAuB,CAAC;AAQ/B,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjD,YAAY,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,oBAAoB,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAAC;IACjH,KAAK,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CAC1D;AAED,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,kBAAkB,CAAC;IAClC,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/E,cAAc,CAAC,EAAE,gBAAgB,CAAC;IAClC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;CACzC;AAqBD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAkbd"}