hypervibes 0.0.0-stage → 0.4.0

package/dist/research/research-service.js

@@ -0,0 +1,191 @@
+import { withAbortSignal } from "@earendil-works/chord/context";
+import { Type } from "@earendil-works/pi-ai";
+import { CodemodeSandbox, parseCodemodeSource } from "@earendil-works/pi-codemode";
+import { createCodemodeExtension } from "@earendil-works/pi-durable/codemode";
+import { defineExtension, defineTool, section } from "@earendil-works/pi-durable";
+import { precisionRules } from "../hyperliquid/orders/order-math.js";
+import { CallQueue } from "./call-queue.js";
+import { describeDataset } from "./evidence.js";
+import { ArtifactService, artifactTypes } from "./artifacts.js";
+import { createResearchResponder, jsonResult } from "./tool-response.js";
+import { researchJournal } from "./journal.js";
+import { ArtifactListSchema, ArtifactMetaSchema, ArtifactReadSchema, CandleResultSchema, JournalResultSchema } from "./contracts.js";
+class BoundedSandbox extends CodemodeSandbox {
+    start(code, options) {
+        return super.start(code, { ...options, timeoutMs: Math.min(options.timeoutMs ?? 60_000, 60_000) });
+    }
+}
+const object = { additionalProperties: false };
+const range = { start: Type.Integer({ minimum: 0 }), end: Type.Integer({ minimum: 1 }) };
+const selection = { coin: Type.String({ minLength: 1, maxLength: 64 }), interval: Type.String({ minLength: 1, maxLength: 8 }), ...range };
+const str = (maxLength) => Type.String({ maxLength });
+const id = Type.String({ minLength: 1, maxLength: 128 });
+const codeUsage = "Discovery helpers are GLOBAL functions, not members of tools. If you know a name, text(await describeTool('indicator_run')) for that ONE schema. Otherwise search with a small explicit limit and print names only: text((await searchTools('candles', {limit: 3})).map(t => t.name)); then describe the chosen tool. Never print the whole searchTools result, ALL_TOOLS, or an entire namespace: declarations can exceed the output budget. describeNamespace('indicators') is also global. Do not call tools.searchTools or tools.describeTool or tools.describeNamespace. Only capability calls use await tools.<name>(args). The host runs at most four nested calls concurrently and queues additional calls FIFO; Promise.all is supported. Await every call. At most 100 nested tool calls per script are allowed (discovery also consumes call IDs); exceeding that budget fails the script. Queued calls share the script deadline and are cancelled when the script ends. Print compact summaries, not full candle arrays; use saveAs for datasets. Never manually calculate or guess Unix timestamps. Use UTC only: parse ISO strings ending in Z and format with new Date(ms).toISOString(). Date.now() is available as a replay-safe script clock anchored at recorded script start; tool results can advance it, but it is not a continuously ticking wall clock. Freeze a requested window once and use store/load across scripts and pages. Reuse authoritative assignment endMs boundaries when supplied; otherwise use Date.parse() on explicit UTC ISO strings and perform time arithmetic in code. Convert milliseconds/seconds explicitly to match tool contracts: research request start/end are milliseconds, candle time is seconds. When publish_research is selected, call await tools.publish_research({...report, evidenceAsOf: endMs}) directly from Code Mode using the verified candle-window end variable; first check that returned closed candles reach that end. Do not print a computed timestamp and manually retype it into another call. Use store/load between scripts. Omit requestedValidUntil for default freshness; otherwise compute it from evidenceAsOf in code and pass the variable directly. For example, const targetSeconds = Date.parse('2026-10-20T14:00:00.000Z') / 1000; const candle = candles.find(c => c.time === targetSeconds); if (!candle) throw new Error('Requested candle is missing');. Check that a candle exists before accessing its fields; report missing data rather than assuming a match. Indicator tool results are objects, not arrays; all numerical points use value.<outputId> (for example value.EMA); the output array is result.values and each point is {time, value}. Use result.values.at(-1)?.value, never result.at(-1) or result[result.length - 1]. store/load preserve the JSON shape: if store('ind', {atr: atrResult}), read load('ind').atr.values, not load('ind').atr as an array. Check Array.isArray(result.values), non-empty length and non-null finite numeric values before arithmetic; missing or nonfinite values are unknown, not zero. A finite value is not proof that seed initialization effects have disappeared. With saveAs, the result is an artifact export rather than an inline values array; inspect the export instead of assuming values exists.";
+/** Owned by AgentService. No I/O or workers start until explicitly invoked. */
+export class ResearchService {
+    db;
+    hyperliquid;
+    risk;
+    reportError;
+    artifacts;
+    workers = 0;
+    exited = new Set();
+    conversations = new Set();
+    sandbox;
+    timer;
+    maintenance = Promise.resolve();
+    constructor(db, hyperliquid, risk, reportError) {
+        this.db = db;
+        this.hyperliquid = hyperliquid;
+        this.risk = risk;
+        this.reportError = reportError;
+        this.artifacts = new ArtifactService(db);
+        this.sandbox = new BoundedSandbox({ memoryLimitBytes: 64 * 1024 * 1024,
+            acquireWorker: () => { if (this.workers >= 4)
+                throw new Error("Research workers are busy; retry later"); this.workers++; return () => { this.workers--; }; },
+            onWorkerStarted: (exited) => { this.exited.add(exited); void exited.then(() => this.exited.delete(exited)); },
+        });
+    }
+    async initialize() { await this.artifacts.cleanup(); }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => { this.maintenance = this.maintenance.then(() => this.artifacts.cleanup()).catch(this.reportError); }, 3600_000);
+        this.timer.unref();
+    }
+    async close() { clearInterval(this.timer); await this.sandbox.close(); await Promise.allSettled([...this.exited]); await this.maintenance; }
+    extensions(agentId) {
+        const respond = createResearchResponder(this.artifacts, agentId);
+        return [this.researchExtension(agentId, respond)];
+    }
+    researchExtension(agentId, respond) {
+        const artifacts = this.artifacts;
+        const tools = [
+            defineTool({
+                name: "list_instruments",
+                description: "List active Hyperliquid main-DEX perpetual symbols with exchange-derived size precision and price rules. Before planning/submitting, use sizeDecimals/sizeStep for base-asset quantity (not USD); fractional prices must satisfy BOTH priceMaxDecimals and priceMaxSignificantFigures. Positive integer prices are exempt from those price precision limits; there is no single fixed price tick. Sizes/prices must be exact decimal strings. minOpeningNotional is USD size × price, not a minimum size; never silently increase size to meet it. allowedForTrading reflects only this Agent's instrument allowlist (unrestricted means all listed symbols are allowed), not trading enablement, collateral, notional limits or guaranteed order acceptance. Instruments outside the trading allowlist may still be researched. This catalog does not designate an analysis assignment.",
+                parameters: Type.Object({}, object), replay: "safe",
+                structuredOutputSchema: Type.Object({ instruments: Type.Array(Type.Object({ symbol: Type.String(), allowedForTrading: Type.Boolean(), sizeDecimals: Type.Integer({ minimum: 0, maximum: 6 }), sizeStep: Type.String({ description: "Exact base-asset size increment, as a decimal string." }), priceMaxDecimals: Type.Integer({ minimum: 0, maximum: 6 }), priceMaxSignificantFigures: Type.Literal(5), integerPricesAllowed: Type.Literal(true), minOpeningNotional: Type.String({ description: "Minimum opening order notional in USD, as a decimal string; not a minimum base-asset size." }) }, object)) }, object),
+                execute: async () => {
+                    const [instruments, settings] = await Promise.all([this.hyperliquid.charts.instrumentDetails(), this.risk.get(agentId)]);
+                    const allowed = settings.allowedInstruments === null ? null : new Set(settings.allowedInstruments);
+                    return jsonResult({ instruments: instruments.map(({ symbol, sizeDecimals }) => ({ symbol, allowedForTrading: allowed === null || allowed.has(symbol), ...precisionRules(sizeDecimals) })) });
+                },
+            }),
+            defineTool({ name: "research_candles", description: "Closed Hyperliquid perpetual candles, ascending UTC time in seconds; request start/end in milliseconds, end exclusive. Paginate using nextStart with the SAME end. Latest ~5,000 candles only; inspect coverage. Analytical numeric OHLCV, not monetary authority.", parameters: Type.Object({ ...selection, limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 2000 })), saveAs: Type.Optional(str(160)) }, object), replay: "safe", structuredOutputSchema: CandleResultSchema, execute: async (args, api, ctx) => respond(args.saveAs, api, ctx, async () => { const history = await this.hyperliquid.charts.researchHistory(args.coin, args.interval, args.start, args.end, args.limit ?? 500, ctx.abortSignal); return { ...history, dataset: describeDataset(history.candles) }; }, { instrument: args.coin, interval: args.interval }) }),
+            defineTool({ name: "research_journal", description: "Bounded root-Agent trade history and exact-decimal performance for returned closed trades only, NOT account returns. Time bounds (ms) filter last activity, NOT cash-flow time or daily account returns; unchanged open exposure may be absent. Attempts bounded single-flight journal catch-up through end before reading. Cursor next is exclusive; keep the same range. Inspect pending/limited coverage; catch-up is not a completeness guarantee. Raw fills/parts are omitted. Monetary values remain decimal strings.", parameters: Type.Object({ ...range, limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000 })), before: Type.Optional(Type.Object({ time: Type.Integer({ minimum: 0 }), id }, object)), summaryOnly: Type.Optional(Type.Boolean()), saveAs: Type.Optional(str(160)) }, object), replay: "safe", structuredOutputSchema: JournalResultSchema, execute: async (args, api, ctx) => respond(args.saveAs, api, ctx, async () => {
+                    if (args.end <= args.start)
+                        throw new Error("Invalid journal window");
+                    const catchUp = await this.hyperliquid.catchUpJournal(agentId, args.end, ctx.abortSignal);
+                    const result = await researchJournal(this.db, agentId, args.start, args.end, args.limit ?? 100, args.before);
+                    const output = { ...result, coverage: { ...result.coverage, catchUp } };
+                    return args.summaryOnly ? { ...output, trades: undefined } : output;
+                }) }),
+            defineTool({ name: "artifact_create", description: "Save immutable report/text/JSON/CSV or base64 PNG/JPEG/WebP in this root Agent's shared library. Max 5 MiB; 100 MiB/2,000 items per Agent. Temporary by default (7 days); retained=true keeps until deleted/unpinned. Markdown embeds ![label](artifact:UUID); attachments must exist in the same Agent, not other reports. A report protects its attachments. Prefer compact reports to raw data dumps. Tool arguments enter Durable history even after artifact expiry; use research tools' saveAs for server-side data exports.", parameters: Type.Object({ title: str(160), description: Type.Optional(str(1000)), mediaType: Type.Union(artifactTypes.map((type) => Type.Literal(type))), content: str(7_340_032), encoding: Type.Optional(Type.Union([Type.Literal("utf8"), Type.Literal("base64")])), tags: Type.Optional(Type.Array(str(40), { maxItems: 12 })), instrument: Type.Optional(str(64)), interval: Type.Optional(str(8)), attachments: Type.Optional(Type.Array(id, { maxItems: 20 })), retained: Type.Optional(Type.Boolean()) }, object), replay: "safe", structuredOutputSchema: ArtifactMetaSchema, execute: async (args, api) => jsonResult(await artifacts.create(agentId, `tool:${api.taskId}`, args, { conversationId: api.conversationId, taskId: api.taskId })) }),
+            defineTool({ name: "artifact_list", description: "List up to 50 artifact metadata records in the root Agent scope; no payloads. Filter by exact instrument/interval/tag and title/description substring. Paginate with nextOffset.", parameters: Type.Object({ offset: Type.Optional(Type.Integer({ minimum: 0, maximum: 10000 })), instrument: Type.Optional(str(64)), interval: Type.Optional(str(8)), tag: Type.Optional(str(40)), query: Type.Optional(str(160)) }, object), replay: "safe", structuredOutputSchema: ArtifactListSchema, execute: async (args) => jsonResult(await artifacts.list(agentId, args)) }),
+            defineTool({ name: "artifact_read", description: "Read metadata/attachments and up to 16,000 UTF-16 characters of a text artifact, offset in characters (not lines). Images return metadata only; use the authenticated UI to view/download. Expired or foreign-Agent items are unavailable.", parameters: Type.Object({ id, offset: Type.Optional(Type.Integer({ minimum: 0 })), limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 16000 })) }, object), replay: "safe", structuredOutputSchema: ArtifactReadSchema, execute: async (args) => jsonResult(await artifacts.read(agentId, args.id, args.offset, args.limit)) }),
+            defineTool({ name: "artifact_retention", description: "Retain/pin an artifact or give it a new seven-day expiry. Does not modify content.", parameters: Type.Object({ id, retained: Type.Boolean() }, object), structuredOutputSchema: Type.Object({ updated: Type.Boolean() }), execute: async (args) => { await artifacts.retention(agentId, args.id, args.retained); return jsonResult({ updated: true }); } }),
+            defineTool({ name: "artifact_delete", description: "Delete an artifact permanently. Refuses deletion of attachments referenced by a report; remove the report first.", parameters: Type.Object({ id }, object), structuredOutputSchema: Type.Object({ deleted: Type.Boolean() }), execute: async (args) => { await artifacts.remove(agentId, args.id); return jsonResult({ deleted: true }); } }),
+        ];
+        const code = createCodemodeExtension({ sandbox: this.sandbox, models: false, namespaces: [{ name: "indicators", prefix: "indicator_", description: "Built-in and Agent-owned PineScript indicators", instructions: "Discover with indicator_list and indicator_get; use the exact input keys. Execute via await tools.indicator_run(...)." }] });
+        const original = code.tools[0];
+        const codemode = defineTool({ ...original, description: `Run sandboxed JavaScript by passing {code: string}; the code is an async function body, with top-level await and return. No shell, imports, filesystem, direct network or timers. text(value), console.log(...) and return emit output; store(key,value) and load(key) persist JSON across scripts. ${codeUsage}`, prepareArguments: undefined, parameters: Type.Object({ code: Type.String({ maxLength: 64_000 }) }, object), execute: async (args, api, context) => {
+                const key = `${agentId}:${api.conversationId}`;
+                if (this.conversations.has(key))
+                    throw new Error("One Code Mode execution per conversation is allowed");
+                this.conversations.add(key);
+                const queue = new CallQueue(4), cancellation = new AbortController();
+                const stop = (reason) => { queue.close(reason); cancellation.abort(reason); };
+                const onAbort = () => stop(context.abortSignal?.reason);
+                context.abortSignal?.addEventListener("abort", onAbort, { once: true });
+                if (context.abortSignal?.aborted)
+                    onAbort();
+                try {
+                    const parsed = parseCodemodeSource(args.code);
+                    const source = `// @options: ${JSON.stringify({ max_output_tokens: Math.min(parsed.options.maxOutputTokens ?? 4000, 4000), timeout_ms: Math.min(parsed.options.timeoutMs ?? 60_000, 60_000) })}\n${parsed.code}`;
+                    let count = 0;
+                    let violation;
+                    const calls = [];
+                    const result = await original.execute({ code: source }, { ...api, executeTool: async (...params) => {
+                            if (violation)
+                                throw new Error(violation.message);
+                            // Durable's cN keys are based on deterministic VM call IDs, so the
+                            // ceiling still applies when completed calls replay from the journal.
+                            const callNumber = /^c(\d+)$/.exec(params[3]?.key ?? "");
+                            count++;
+                            const call = { id: callNumber ? Number(callNumber[1]) : count, name: params[0], args: JSON.stringify(params[1]).slice(0, 200), status: queue.saturated ? "queued" : "running" };
+                            calls.push(call);
+                            if (count > 100 || (callNumber && Number(callNumber[1]) > 100))
+                                violation = { message: "Code Mode nested-call limit (100) exceeded", code: "research_call_limit" };
+                            if (violation) {
+                                call.status = "error";
+                                call.error = violation.message;
+                                stop(new Error(violation.message));
+                                throw new Error(violation.message);
+                            }
+                            const admitted = Date.now();
+                            const publish = () => api.details({ calls: calls.filter((item) => item.status === "queued").slice(-100).map((item) => ({ ...item })) }, context);
+                            const wasQueued = call.status === "queued";
+                            try {
+                                const work = queue.run(async () => {
+                                    cancellation.signal.throwIfAborted();
+                                    call.queuedMs = wasQueued ? Date.now() - admitted : 0;
+                                    call.status = "running";
+                                    if (wasQueued)
+                                        await publish();
+                                    const started = Date.now();
+                                    try {
+                                        const nested = await api.executeTool(params[0], params[1], withAbortSignal(cancellation.signal, params[2]), params[3]);
+                                        call.status = nested.isError ? "error" : "ok";
+                                        if (nested.isError)
+                                            call.error = nested.diagnostics.filter((item) => item.severity === "error").map((item) => item.message).join("\n").slice(0, 500);
+                                        return nested;
+                                    }
+                                    finally {
+                                        call.durationMs = Date.now() - started;
+                                    }
+                                });
+                                // Observe both promises immediately. Only waiting calls need parent
+                                // progress; active calls already have Durable's live nested slots.
+                                const [nested] = await Promise.all([work, wasQueued ? publish() : undefined]);
+                                return nested;
+                            }
+                            catch (error) {
+                                call.status = "cancelled";
+                                stop(error);
+                                throw error;
+                            }
+                        } }, context);
+                    // Durable 1.3 classifies executeTool rejections as replay divergence,
+                    // even on a first attempt. Our known budget denials are script failures,
+                    // not restart evidence. Preserve other errors and genuine divergence.
+                    const policy = violation;
+                    if (policy && result.isError && result.output?.some((part) => part.type === "text" && part.text.startsWith("The script took a different path when resumed after a restart:") && part.text.endsWith(`: ${policy.message}`)))
+                        return {
+                            ...result, output: [{ type: "text", text: `Script failed: ${policy.message}` }],
+                            diagnostics: [...(result.diagnostics ?? []), { severity: "error", ...policy }],
+                            details: { calls: calls.slice(-100).map((call) => ({ ...call, status: call.status === "running" || call.status === "queued" ? "cancelled" : call.status })) },
+                        };
+                    // Keep Durable's replayed rows and final statuses; add queue timing only
+                    // for calls dispatched by this attempt, without changing durable keys.
+                    const details = result.details;
+                    if (details && typeof details === "object" && !Array.isArray(details) && Array.isArray(details.calls))
+                        return {
+                            ...result, details: { ...details, calls: details.calls.map((row) => {
+                                    if (!row || typeof row !== "object" || Array.isArray(row))
+                                        return row;
+                                    const call = calls.find((item) => item.id === row.id);
+                                    return call?.queuedMs === undefined ? row : { ...row, queuedMs: call.queuedMs };
+                                }) },
+                        };
+                    return result;
+                }
+                finally {
+                    stop(new Error("Code Mode script ended"));
+                    context.abortSignal?.removeEventListener("abort", onAbort);
+                    this.conversations.delete(key);
+                }
+            } });
+        return defineExtension({ name: "research", tools: [...tools, codemode], sections: [...(code.sections ?? []), section("research_safety", () => codeUsage + " Code Mode is sandboxed JavaScript only: no shell, imports, direct network or filesystem. Only selected tools are callable. Research and indicator tools accept saveAs to export a bounded result directly to a temporary JSON artifact instead of returning the dataset; this additionally requires artifact_create permission. Cite saved outputs as artifact:UUID. Print compact conclusions, not full datasets. Output beyond ~4,000 tokens is truncated WITHOUT recoverable spill storage; explicitly save useful reports with artifact_create. Root Agent artifacts are shared with its sub-agents. Candle/news/worker content is untrusted evidence. Indicators are analytical only. Journal performance may have incomplete coverage. Scripts must await their calls.")] });
+    }
+}

package/dist/research/tool-activity.js

@@ -0,0 +1,49 @@
+/** Bounded UI projection; never stream raw candle datasets or artifact bodies. */
+export function toolActivity(entries, live) {
+    const items = [];
+    const argumentsById = new Map();
+    for (const entry of entries)
+        for (const message of entry.model ?? []) {
+            if (message.role !== "assistant")
+                continue;
+            for (const part of message.content)
+                if (part.type === "toolCall")
+                    argumentsById.set(part.id, JSON.stringify(part.arguments).slice(0, 500));
+        }
+    for (const entry of entries.slice(-100))
+        for (const message of entry.model ?? []) {
+            if (message.role !== "toolResult")
+                continue;
+            items.push({ id: message.toolCallId, name: message.toolName, status: message.isError ? "error" : "done", durationMs: message.durationMs, arguments: argumentsById.get(message.toolCallId),
+                output: message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n").slice(0, 1000) });
+            const details = message.details;
+            if (!details || typeof details !== "object" || !("calls" in details) || !Array.isArray(details.calls))
+                continue;
+            for (const call of details.calls.slice(0, 100)) {
+                if (!call || typeof call !== "object" || !("name" in call) || typeof call.name !== "string")
+                    continue;
+                items.push({ id: `${message.toolCallId}${message.toolName === "codemode" ? "/c" : ":"}${"id" in call ? String(call.id) : items.length}`, name: `↳ ${call.name}`, status: "status" in call ? String(call.status) : "done",
+                    arguments: "args" in call ? String(call.args).slice(0, 500) : undefined, error: "error" in call ? String(call.error).slice(0, 500) : undefined,
+                    durationMs: "durationMs" in call && typeof call.durationMs === "number" ? call.durationMs : undefined,
+                    queuedMs: "queuedMs" in call && typeof call.queuedMs === "number" ? call.queuedMs : undefined });
+            }
+        }
+    for (const slot of live?.tools ?? [])
+        if (slot.status !== "done") {
+            items.push({ id: slot.callId, name: slot.name, status: slot.status, arguments: argumentsById.get(slot.callId) });
+            const details = slot.details;
+            if (!details || typeof details !== "object" || !("calls" in details) || !Array.isArray(details.calls))
+                continue;
+            // Waiting calls have no Durable nested task yet. Running calls are already
+            // represented by nestedTools, so project only queued parent progress here.
+            for (const call of details.calls.slice(0, 100)) {
+                if (!call || typeof call !== "object" || !("status" in call) || call.status !== "queued" || !("name" in call) || typeof call.name !== "string")
+                    continue;
+                items.push({ id: `${slot.callId}${slot.name === "codemode" ? "/c" : ":"}${"id" in call ? String(call.id) : items.length}`, name: `↳ ${call.name}`, status: "queued", arguments: "args" in call ? String(call.args).slice(0, 500) : undefined });
+            }
+        }
+    for (const slot of live?.nestedTools ?? [])
+        items.push({ id: slot.callId, name: `↳ ${slot.name}`, status: slot.summary?.isError ? "error" : slot.status,
+            arguments: JSON.stringify(slot.arguments).slice(0, 500), error: slot.summary?.error?.slice(0, 500), durationMs: slot.summary?.durationMs });
+    return items.slice(-125);
+}

package/dist/research/tool-response.js

@@ -0,0 +1,25 @@
+/** Normalize service interfaces to JSON and bound only the model-facing preview. */
+export function jsonResult(value, truncate = true) {
+    const text = JSON.stringify(value);
+    const preview = truncate && text.length > 12_000 ? `${text.slice(0, 12_000)}\n[Model preview truncated; use Code Mode to process the structured result or request a smaller page.]` : text;
+    return { output: [{ type: "text", text: preview }], structuredOutput: JSON.parse(text) };
+}
+export function createResearchResponder(artifacts, agentId, indicators = false) {
+    const summary = (value) => Object.fromEntries(Object.entries(value).filter(([key]) => !["candles", "trades", "values", "outputs", "levels", "fills", "markers", "drawings"].includes(key)));
+    return async (saveAs, api, context, produce, labels = {}) => {
+        if (saveAs) {
+            if (!(await api.agent(context)).callable.some((tool) => tool.name === "artifact_create"))
+                throw new Error("Saving exports also requires artifact_create permission");
+            const existing = await artifacts.operation(agentId, `export:${api.taskId}`);
+            if (existing) {
+                const saved = await artifacts.get(agentId, existing.id);
+                return jsonResult({ artifact: existing, reference: `artifact:${existing.id}`, summary: summary(JSON.parse(saved.payload.toString("utf8"))) });
+            }
+        }
+        const value = await produce();
+        if (!saveAs)
+            return jsonResult(value, !indicators);
+        const artifact = await artifacts.create(agentId, `export:${api.taskId}`, { title: saveAs, mediaType: "application/json", content: JSON.stringify(value), ...labels }, { conversationId: api.conversationId, taskId: api.taskId });
+        return jsonResult({ artifact, reference: `artifact:${artifact.id}`, summary: summary(value) });
+    };
+}

package/dist/runtime.js

@@ -0,0 +1,145 @@
+import { NotificationService } from "./notifications/notification-service.js";
+import { migrateApplication } from "./db/migrations.js";
+import { AgentService } from "./agents/agent-service.js";
+import { createAuth } from "./auth.js";
+import { openDatabase } from "./db/database.js";
+import { lockProfile } from "./db/profile-lock.js";
+import { applicationDatabase, SharedDatabase } from "./db/shared-database.js";
+import { OrderService } from "./hyperliquid/orders/order-service.js";
+import { HyperliquidService } from "./hyperliquid/service.js";
+import { SharedHyperliquidFeeds } from "./hyperliquid/shared-feeds.js";
+import { HttpTransport } from "@nktkas/hyperliquid";
+import { exchangeHistory, JournalService } from "./hyperliquid/journal-service.js";
+import { ProviderService } from "./providers/provider-service.js";
+import { GatewayBridge } from "./gateway/bridge-service.js";
+import { telegramConnector } from "./gateway/telegram/connector.js";
+import { resolve } from "node:path";
+/** Application-owned resources, constructed once by the host, never by a request. */
+export async function createRuntime(config, options = {}) {
+    const logger = options.logger;
+    const databasePath = resolve(config.databasePath);
+    logger?.info({ databasePath }, "Opening SQLite database");
+    const connection = openDatabase(config.databasePath);
+    const database = new SharedDatabase(connection);
+    let release;
+    let agents;
+    let hyperliquid;
+    let providers;
+    let orders;
+    let gateway;
+    let notifications;
+    let closing;
+    let failure;
+    const close = (force) => closing ??= (async () => {
+        try {
+            await gateway?.close();
+        }
+        finally {
+            try {
+                await agents?.close(force);
+            }
+            finally {
+                try {
+                    try {
+                        await orders?.close();
+                    }
+                    finally {
+                        try {
+                            await hyperliquid?.close();
+                        }
+                        finally {
+                            await notifications?.close();
+                        }
+                    }
+                }
+                finally {
+                    try {
+                        await providers?.close();
+                    }
+                    finally {
+                        try {
+                            await database.close();
+                        }
+                        finally {
+                            await release?.();
+                        }
+                    }
+                }
+            }
+        }
+    })();
+    try {
+        release = await lockProfile(config.databasePath, (error) => {
+            failure = error;
+            // Stop admission synchronously, then drain execution before releasing SQL.
+            void close().catch((error) => {
+                if (logger)
+                    logger.error(error, "Failed to close compromised application storage");
+                else
+                    console.error("Failed to close compromised application storage", error);
+            });
+        });
+        // Native migration access is allowed only before the shared queue is used.
+        logger?.info({ databasePath, journalMode: "wal", synchronous: "FULL", foreignKeys: true }, "SQLite database connected and profile locked");
+        const migrations = migrateApplication(connection);
+        logger?.info(migrations, migrations.applied > 0 ? "Database migrations applied" : "Database schema is up to date; no migrations needed");
+        const db = applicationDatabase(database);
+        const auth = createAuth(db, config);
+        await auth.$context;
+        const providerService = new ProviderService(db, config.encryptionKey, options);
+        providers = providerService;
+        await providerService.initialize();
+        const transport = new HttpTransport();
+        const feeds = new SharedHyperliquidFeeds();
+        const notificationService = new NotificationService(database, config.authOrigin, logger?.child({ component: "notifications" }));
+        notifications = notificationService;
+        const journal = new JournalService(database, options.journalHistoryFetcher ?? exchangeHistory(transport), logger?.child({ component: "journal" }), options.journalFeedFactory ?? feeds.journal);
+        const orderService = new OrderService(database, transport, {
+            account: (userId, agentId) => hyperliquid.agentTradingAccount(userId, agentId),
+            authority: (userId, agentId, signal, needsBuilder) => hyperliquid.orderAuthority(userId, agentId, signal, needsBuilder),
+        }, logger?.child({ component: "orders" }));
+        orders = orderService;
+        orderService.store.notifications = notificationService;
+        journal.notifications = notificationService;
+        hyperliquid = new HyperliquidService(db, config.encryptionKey, transport, options.accountFeedFactory, journal, (signer) => orderService.store.nonce(signer), logger?.child({ component: "hyperliquid" }), feeds);
+        await orderService.recover();
+        const agentService = new AgentService(db, database, providerService, hyperliquid, orderService, notificationService, { ...options, logger: logger?.child({ component: "agents" }) });
+        providerService.onChanged = (userId) => agentService.providersChanged(userId);
+        agents = agentService;
+        await agentService.recover();
+        // One bridge per supported gateway platform; Telegram bridges the persistent main conversation.
+        gateway = new GatewayBridge(db, agentService, config.encryptionKey, telegramConnector, { logger: logger?.child({ component: "gateway" }) });
+        notificationService.installSender((target, text, signal) => gateway.sendNotification(target, text, signal));
+        return {
+            db,
+            database,
+            auth,
+            origin: config.authOrigin,
+            agents: agentService,
+            hyperliquid,
+            orders: orderService,
+            providers: providerService,
+            gateway,
+            notifications: notificationService,
+            start() {
+                if (closing || failure)
+                    throw new Error("Runtime is unavailable");
+                hyperliquid?.start();
+                orderService.start();
+                notificationService.start();
+                agentService.start();
+                gateway?.start();
+            },
+            status() {
+                if (closing || failure || !database.available || !connection.isOpen)
+                    throw new Error("Runtime is unavailable");
+                return { database: "connected", agentExecution: "available" };
+            },
+            close,
+        };
+    }
+    catch (error) {
+        await close();
+        throw error;
+    }
+}