@akira-tl/forgerelay 0.6.1 → 0.7.1

package/dist/subagents/sessions/delivery-mailbox.js

@@ -0,0 +1,115 @@
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+const MAX_DELIVERY_TEXT_BYTES = 64 * 1024;
+const MAX_DELIVERIES_PER_RESPONSE = 4;
+export class SubagentDeliveryMailbox {
+    directory;
+    constructor(stateDir) {
+        this.directory = join(stateDir, "subagent-delivery");
+    }
+    write(input) {
+        const response = boundText(input.finalResponse);
+        const error = boundText(input.error);
+        const delivery = {
+            sessionId: input.sessionId,
+            runId: input.runId,
+            workspaceId: input.workspaceId,
+            ...(input.activityId ? { activityId: input.activityId } : {}),
+            provider: input.provider,
+            outcome: input.outcome,
+            ...(response.text !== undefined ? { finalResponse: response.text } : {}),
+            ...(error.text !== undefined ? { error: error.text } : {}),
+            truncated: response.truncated || error.truncated,
+            createdAt: new Date().toISOString(),
+        };
+        mkdirSync(this.directory, { recursive: true, mode: 0o700 });
+        const path = this.pathFor(delivery.sessionId);
+        const temporary = `${path}.${process.pid}.tmp`;
+        writeFileSync(temporary, `${JSON.stringify(delivery)}\n`, { mode: 0o600 });
+        rmSync(path, { force: true });
+        renameSync(temporary, path);
+        return delivery;
+    }
+    claimWorkspace(workspaceId, excludeRunId) {
+        return this.claim((delivery) => delivery.workspaceId === workspaceId && delivery.runId !== excludeRunId);
+    }
+    claimSession(workspaceId, sessionId) {
+        return this.claim((delivery) => delivery.workspaceId === workspaceId && delivery.sessionId === sessionId);
+    }
+    hasSession(sessionId) {
+        return this.files().includes(`${sessionId}.json`);
+    }
+    claim(predicate) {
+        const deliveries = [];
+        for (const file of this.files()) {
+            if (deliveries.length >= MAX_DELIVERIES_PER_RESPONSE)
+                break;
+            const path = join(this.directory, file);
+            const delivery = readDelivery(path);
+            if (!delivery || !predicate(delivery))
+                continue;
+            rmSync(path, { force: true });
+            deliveries.push(delivery);
+        }
+        return deliveries.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+    files() {
+        try {
+            return readdirSync(this.directory)
+                .filter((file) => /^agt_[a-z0-9]+\.json$/i.test(file))
+                .sort();
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        }
+    }
+    pathFor(sessionId) {
+        if (!/^agt_[a-z0-9]+$/i.test(sessionId))
+            throw new Error(`Invalid Subagent Session id: ${sessionId}`);
+        return join(this.directory, `${sessionId}.json`);
+    }
+}
+function readDelivery(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof value.sessionId !== "string" ||
+            typeof value.runId !== "string" ||
+            typeof value.workspaceId !== "string" ||
+            typeof value.provider !== "string" ||
+            !isOutcome(value.outcome) ||
+            typeof value.createdAt !== "string") {
+            return undefined;
+        }
+        return {
+            sessionId: value.sessionId,
+            runId: value.runId,
+            workspaceId: value.workspaceId,
+            ...(typeof value.activityId === "string" ? { activityId: value.activityId } : {}),
+            provider: value.provider,
+            outcome: value.outcome,
+            ...(typeof value.finalResponse === "string" ? { finalResponse: value.finalResponse } : {}),
+            ...(typeof value.error === "string" ? { error: value.error } : {}),
+            truncated: value.truncated === true,
+            createdAt: value.createdAt,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function boundText(value) {
+    if (value === undefined)
+        return { truncated: false };
+    const bytes = Buffer.from(value, "utf8");
+    if (bytes.length <= MAX_DELIVERY_TEXT_BYTES)
+        return { text: value, truncated: false };
+    return {
+        text: bytes.subarray(0, MAX_DELIVERY_TEXT_BYTES).toString("utf8"),
+        truncated: true,
+    };
+}
+function isOutcome(value) {
+    return value === "succeeded" || value === "failed" || value === "cancelled" || value === "interrupted";
+}

package/dist/subagents/sessions/execution.js

@@ -0,0 +1,171 @@
+import { HookRunner } from "../../hooks.js";
+import { isSubagentProvider, loadSubagentProfiles, } from "../profiles.js";
+import { runSubagentProvider } from "../providers/registry.js";
+import { SubagentDeliveryMailbox } from "./delivery-mailbox.js";
+import { createSubagentSessionStore, } from "./store.js";
+export async function executeSubagentRun(config, input, providerRunner = runSubagentProvider) {
+    const store = createSubagentSessionStore(config);
+    const mailbox = new SubagentDeliveryMailbox(config.stateDir);
+    try {
+        const record = store.get(input.sessionId);
+        if (!record)
+            throw new Error(`Unknown subagent id: ${input.sessionId}`);
+        if (record.activeRun?.id !== input.runId) {
+            throw new Error(`Subagent Run ${input.runId} is not active for Session ${record.id}.`);
+        }
+        const hooks = new HookRunner(config.hooks, config.logging);
+        const hookInvocation = {
+            workspaceId: record.workspaceId,
+            workspaceRoot: record.workspaceRoot,
+            payload: {
+                agentId: record.id,
+                sessionId: record.id,
+                runId: input.runId,
+                profile: record.profileName,
+                provider: record.provider,
+                model: record.model,
+                thinking: record.thinking,
+            },
+        };
+        await hooks.run("SubagentStart", hookInvocation);
+        try {
+            const result = await runSessionProvider(config, record, input.prompt, providerRunner);
+            await hooks.run("SubagentStop", {
+                ...hookInvocation,
+                payload: {
+                    ...hookInvocation.payload,
+                    status: "succeeded",
+                    providerSessionId: result.providerSessionId,
+                },
+            });
+            const finishedAt = new Date().toISOString();
+            store.update(record.id, {
+                providerSessionId: result.providerSessionId ?? undefined,
+                status: "idle",
+                activeRun: undefined,
+                latestRun: {
+                    id: input.runId,
+                    status: "succeeded",
+                    finishedAt,
+                },
+            });
+            if (record.workspaceId) {
+                mailbox.write({
+                    sessionId: record.id,
+                    runId: input.runId,
+                    workspaceId: record.workspaceId,
+                    ...(input.activityId ? { activityId: input.activityId } : {}),
+                    provider: record.provider,
+                    outcome: "succeeded",
+                    finalResponse: result.finalResponse,
+                });
+            }
+            return completion(record, input, "succeeded");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await hooks.run("SubagentStop", {
+                ...hookInvocation,
+                payload: {
+                    ...hookInvocation.payload,
+                    status: "failed",
+                },
+            });
+            const finishedAt = new Date().toISOString();
+            store.update(record.id, {
+                status: "idle",
+                activeRun: undefined,
+                latestRun: {
+                    id: input.runId,
+                    status: "failed",
+                    finishedAt,
+                },
+            });
+            if (record.workspaceId) {
+                mailbox.write({
+                    sessionId: record.id,
+                    runId: input.runId,
+                    workspaceId: record.workspaceId,
+                    ...(input.activityId ? { activityId: input.activityId } : {}),
+                    provider: record.provider,
+                    outcome: "failed",
+                    error: message,
+                });
+            }
+            return completion(record, input, "failed", message);
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+export async function executeSubagentSession(config, sessionId, prompt) {
+    const store = createSubagentSessionStore(config);
+    try {
+        const record = store.get(sessionId);
+        if (!record)
+            throw new Error(`Unknown subagent id: ${sessionId}`);
+        if (!record.activeRun)
+            throw new Error(`Subagent Session ${sessionId} has no active Run.`);
+        return executeSubagentRun(config, {
+            sessionId,
+            runId: record.activeRun.id,
+            ...(record.activeRun.activityId ? { activityId: record.activeRun.activityId } : {}),
+            prompt,
+        });
+    }
+    finally {
+        store.close();
+    }
+}
+async function runSessionProvider(config, session, prompt, providerRunner) {
+    if (!isSubagentProvider(session.provider)) {
+        throw new Error(`Unknown subagent provider for Session ${session.id}: ${session.provider}`);
+    }
+    if (session.providerSessionId) {
+        return providerRunner(session.provider, {
+            prompt,
+            workspace: session.workspaceRoot,
+            providerSessionId: session.providerSessionId,
+            writeMode: "allowed",
+            model: session.model,
+            thinking: session.thinking,
+        });
+    }
+    if (session.profileName === session.provider) {
+        return providerRunner(session.provider, {
+            prompt,
+            workspace: session.workspaceRoot,
+            writeMode: "allowed",
+            model: session.model,
+            thinking: session.thinking,
+        });
+    }
+    const profiles = await loadSubagentProfiles(config, session.workspaceRoot);
+    const profile = profiles.find((candidate) => candidate.name === session.profileName);
+    if (!profile)
+        throw new Error(`Subagent profile not found: ${session.profileName}`);
+    return runSubagentProfile(profile, session, prompt, providerRunner);
+}
+async function runSubagentProfile(profile, session, prompt, providerRunner) {
+    const body = profile.body.trim();
+    const firstPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
+    return providerRunner(session.provider, {
+        prompt: firstPrompt,
+        workspace: session.workspaceRoot,
+        writeMode: "allowed",
+        model: session.model,
+        thinking: session.thinking,
+    });
+}
+function completion(session, input, outcome, error) {
+    return {
+        sessionId: session.id,
+        runId: input.runId,
+        workspaceId: session.workspaceId,
+        activityId: input.activityId,
+        provider: session.provider,
+        outcome,
+        ...(error ? { error } : {}),
+    };
+}

package/dist/subagents/sessions/manager.js

@@ -0,0 +1,107 @@
+import { randomUUID } from "node:crypto";
+import { formatAvailableSubagentTargets, resolveSubagentTarget, } from "../cli-target.js";
+import { isSubagentProvider, loadSubagentProfiles, } from "../profiles.js";
+import { assertSubagentProviderAvailable } from "../providers/availability.js";
+import { subagentProviderContinuationSupported } from "../providers/continuation.js";
+import { createSubagentSessionStore, } from "./store.js";
+export class SubagentSessionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SubagentSessionError";
+    }
+}
+export class SubagentSessionManager {
+    config;
+    launcher;
+    store;
+    constructor(config, launcher) {
+        this.config = config;
+        this.launcher = launcher;
+        this.store = createSubagentSessionStore(config);
+    }
+    list(scope = {}) {
+        return this.store.list(scope);
+    }
+    get(idOrPrefix, scope) {
+        return scope ? this.store.getInScope(idOrPrefix, scope) : this.store.get(idOrPrefix);
+    }
+    async start(input) {
+        const profiles = await loadSubagentProfiles(this.config, input.workspaceRoot);
+        const target = resolveSubagentTarget(input.target, profiles, input.model, input.thinking);
+        if (!target) {
+            throw new Error(`Unknown subagent profile or provider: ${input.target}. Available ${formatAvailableSubagentTargets(profiles)}`);
+        }
+        assertSubagentProviderAvailable(target.provider);
+        const runId = newRunId();
+        const startedAt = new Date().toISOString();
+        const session = this.store.create({
+            workspaceId: input.workspaceId,
+            workspaceRoot: input.workspaceRoot,
+            profileName: target.name,
+            provider: target.provider,
+            model: target.model,
+            thinking: target.thinking,
+            activeRun: {
+                id: runId,
+                ...(input.activityId ? { activityId: input.activityId } : {}),
+                startedAt,
+            },
+        });
+        const run = session.activeRun;
+        if (!run)
+            throw new Error(`Subagent Session ${session.id} did not create an active Run.`);
+        this.launcher.launch({
+            sessionId: session.id,
+            runId,
+            ...(input.activityId ? { activityId: input.activityId } : {}),
+            prompt: input.prompt,
+        });
+        return { session, run };
+    }
+    resume(input, scope = {}) {
+        const existing = this.store.getInScope(input.sessionId, scope);
+        if (!existing) {
+            throw new SubagentSessionError("subagent.session_not_found", `Unknown Subagent Session in this Workspace: ${input.sessionId}`);
+        }
+        if (existing.activeRun) {
+            throw new SubagentSessionError("subagent.busy", `Subagent Session ${existing.id} already has active Run ${existing.activeRun.id}.`);
+        }
+        if (!isSubagentProvider(existing.provider)) {
+            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
+        }
+        if (!subagentProviderContinuationSupported(existing.provider)) {
+            throw new SubagentSessionError("subagent.continuation_unsupported", `${existing.provider} does not support true Subagent Session continuation.`);
+        }
+        if (!existing.providerSessionId) {
+            throw new SubagentSessionError("subagent.continuation_unavailable", `Subagent Session ${existing.id} has no provider continuation identity.`);
+        }
+        assertSubagentProviderAvailable(existing.provider);
+        const runId = newRunId();
+        const startedAt = new Date().toISOString();
+        const run = {
+            id: runId,
+            status: "running",
+            ...(input.activityId ? { activityId: input.activityId } : {}),
+            startedAt,
+        };
+        const session = this.store.update(existing.id, {
+            status: "running",
+            activeRun: run,
+        });
+        this.launcher.launch({
+            sessionId: session.id,
+            runId,
+            ...(input.activityId ? { activityId: input.activityId } : {}),
+            prompt: input.prompt,
+        });
+        return { session, run };
+    }
+    close() {
+        this.store.close();
+    }
+}
+function newRunId() {
+    return `run_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+}

package/dist/subagents/sessions/mcp/audit.js

@@ -0,0 +1,85 @@
+export function capabilityActivityAuditRequest(input) {
+    if (input.name !== "subagent.session") {
+        return {
+            workspaceId: input.workspaceId,
+            name: input.name,
+            action: "run",
+            arguments: input.arguments,
+            file: input.file,
+        };
+    }
+    const argumentsValue = isAuditRecord(input.arguments) ? input.arguments : {};
+    return {
+        workspaceId: input.workspaceId,
+        name: input.name,
+        action: "run",
+        arguments: {
+            operation: argumentsValue.operation,
+            ...(typeof argumentsValue.target === "string" ? { target: argumentsValue.target } : {}),
+            ...(typeof argumentsValue.sessionId === "string" ? { sessionId: argumentsValue.sessionId } : {}),
+            ...(typeof argumentsValue.model === "string" ? { model: argumentsValue.model } : {}),
+            ...(typeof argumentsValue.thinking === "string" ? { thinking: argumentsValue.thinking } : {}),
+            ...(typeof argumentsValue.prompt === "string" ? { promptLength: argumentsValue.prompt.length } : {}),
+        },
+    };
+}
+export function capabilityActivityAuditResult(name, result) {
+    if (name !== "subagent.session" || !isAuditRecord(result))
+        return result;
+    const structuredContent = isAuditRecord(result.structuredContent) ? result.structuredContent : undefined;
+    const capabilityResult = structuredContent && isAuditRecord(structuredContent.result)
+        ? structuredContent.result
+        : undefined;
+    const error = structuredContent && isAuditRecord(structuredContent.error)
+        ? structuredContent.error
+        : undefined;
+    return {
+        name,
+        action: "run",
+        ...(capabilityResult ? { result: summarizeSubagentCapabilityResult(capabilityResult) } : {}),
+        ...(error
+            ? {
+                error: {
+                    code: error.code,
+                    message: error.message,
+                },
+            }
+            : {}),
+    };
+}
+function isAuditRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function summarizeSubagentCapabilityResult(result) {
+    const summary = { operation: result.operation };
+    const session = isAuditRecord(result.session) ? result.session : undefined;
+    if (session) {
+        summary.session = {
+            id: session.id,
+            status: session.status,
+            profileName: session.profileName,
+            provider: session.provider,
+            model: session.model,
+            thinking: session.thinking,
+        };
+    }
+    for (const key of ["run", "activeRun", "latestRun"]) {
+        const run = isAuditRecord(result[key]) ? result[key] : undefined;
+        if (run)
+            summary[key] = { id: run.id, status: run.status };
+    }
+    if (Array.isArray(result.sessions)) {
+        summary.sessions = result.sessions.flatMap((entry) => {
+            if (!isAuditRecord(entry))
+                return [];
+            return [{
+                    id: entry.id,
+                    status: entry.status,
+                    profileName: entry.profileName,
+                    provider: entry.provider,
+                    activeRunId: entry.activeRunId,
+                }];
+        });
+    }
+    return summary;
+}

package/dist/subagents/sessions/mcp/runtime.js

@@ -0,0 +1,19 @@
+import { SubagentSessionCapability } from "../capability.js";
+export function createSubagentMcpRuntime(config, activityLifecycle, options = {}) {
+    const capability = config.subagents
+        ? new SubagentSessionCapability(config, activityLifecycle, {
+            providerRunner: options.subagentProviderRunner,
+        })
+        : undefined;
+    return {
+        registryDependencies: capability
+            ? {
+                subagentSession: {
+                    available: true,
+                    run: (input, context, runOptions) => capability.run(input, context, runOptions),
+                },
+            }
+            : {},
+        decorateResult: (workspaceId, result) => capability?.decorateResult(workspaceId, result) ?? result,
+    };
+}

package/dist/{local-agent-store.js → subagents/sessions/store.js}

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { openDatabase } from "./db/client.js";
-export class LocalAgentStore {
+import { openDatabase } from "../../db/client.js";
+export class SubagentSessionStore {
     database;
     constructor(stateDir) {
         this.database = openDatabase(stateDir);
@@ -27,7 +27,7 @@ export class LocalAgentStore {
                 .prepare("select * from local_agent_sessions order by updated_at desc")
                 .all();
         }
-        return rows.map(rowToLocalAgentRecord);
+        return rows.map(rowToSubagentSession);
     }
     create(input) {
         const now = new Date().toISOString();
@@ -39,7 +39,17 @@ export class LocalAgentStore {
             provider: input.provider,
             model: input.model,
             thinking: input.thinking,
-            status: "starting",
+            status: input.activeRun ? "running" : "idle",
+            ...(input.activeRun
+                ? {
+                    activeRun: {
+                        id: input.activeRun.id,
+                        status: "running",
+                        ...(input.activeRun.activityId ? { activityId: input.activeRun.activityId } : {}),
+                        startedAt: input.activeRun.startedAt,
+                    },
+                }
+                : {}),
             createdAt: now,
             updatedAt: now,
         };
@@ -52,11 +62,21 @@ export class LocalAgentStore {
           provider,
           model,
           thinking,
+          provider_session_id,
           status,
+          active_run_id,
+          active_activity_id,
+          active_run_started_at,
+          latest_run_id,
+          latest_run_outcome,
+          latest_run_finished_at,
+          latest_response,
+          error,
+          hook_reports_json,
           created_at,
           updated_at
-        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(record.id, record.workspaceId ?? null, record.workspaceRoot, record.profileName, record.provider, record.model ?? null, record.thinking ?? null, record.status, record.createdAt, record.updatedAt);
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, null, null, null, ?, ?)`)
+            .run(record.id, record.workspaceId ?? null, record.workspaceRoot, record.profileName, record.provider, record.model ?? null, record.thinking ?? null, null, record.status, record.activeRun?.id ?? null, record.activeRun?.activityId ?? null, record.activeRun?.startedAt ?? null, null, null, null, record.createdAt, record.updatedAt);
         return record;
     }
     get(idOrPrefix) {
@@ -66,13 +86,23 @@ export class LocalAgentStore {
          limit 1`)
             .get(idOrPrefix, idOrPrefix);
         if (exact)
-            return rowToLocalAgentRecord(exact);
+            return rowToSubagentSession(exact);
         const matches = this.database.sqlite
             .prepare(`select * from local_agent_sessions
          where id like ? escape '\\' or provider_session_id like ? escape '\\'
          order by updated_at desc`)
             .all(`${escapeLike(idOrPrefix)}%`, `${escapeLike(idOrPrefix)}%`);
-        return matches.length === 1 ? rowToLocalAgentRecord(matches[0]) : undefined;
+        return matches.length === 1 ? rowToSubagentSession(matches[0]) : undefined;
+    }
+    getInScope(idOrPrefix, scope) {
+        const session = this.get(idOrPrefix);
+        if (!session)
+            return undefined;
+        if (scope.workspaceId && session.workspaceId !== scope.workspaceId)
+            return undefined;
+        if (scope.workspaceRoot && session.workspaceRoot !== resolve(scope.workspaceRoot))
+            return undefined;
+        return session;
     }
     update(id, patch) {
         const current = this.getById(id);
@@ -93,12 +123,18 @@ export class LocalAgentStore {
           thinking = ?,
           provider_session_id = ?,
           status = ?,
-          latest_response = ?,
-          error = ?,
-          hook_reports_json = ?,
+          active_run_id = ?,
+          active_activity_id = ?,
+          active_run_started_at = ?,
+          latest_run_id = ?,
+          latest_run_outcome = ?,
+          latest_run_finished_at = ?,
+          latest_response = null,
+          error = null,
+          hook_reports_json = null,
           updated_at = ?
          where id = ?`)
-            .run(updated.workspaceId ?? null, resolve(updated.workspaceRoot), updated.profileName, updated.provider, updated.model ?? null, updated.thinking ?? null, updated.providerSessionId ?? null, updated.status, updated.latestResponse ?? null, updated.error ?? null, updated.hookReports ? JSON.stringify(updated.hookReports) : null, updated.updatedAt, updated.id);
+            .run(updated.workspaceId ?? null, resolve(updated.workspaceRoot), updated.profileName, updated.provider, updated.model ?? null, updated.thinking ?? null, updated.providerSessionId ?? null, updated.status, updated.activeRun?.id ?? null, updated.activeRun?.activityId ?? null, updated.activeRun?.startedAt ?? null, updated.latestRun?.id ?? null, updated.latestRun && updated.latestRun.status !== "running" ? updated.latestRun.status : null, updated.latestRun?.finishedAt ?? null, updated.updatedAt, updated.id);
         return updated;
     }
     close() {
@@ -108,13 +144,29 @@ export class LocalAgentStore {
         const row = this.database.sqlite
             .prepare("select * from local_agent_sessions where id = ?")
             .get(id);
-        return row ? rowToLocalAgentRecord(row) : undefined;
+        return row ? rowToSubagentSession(row) : undefined;
     }
 }
-export function createLocalAgentStore(config) {
-    return new LocalAgentStore(config.stateDir);
+export function createSubagentSessionStore(config) {
+    return new SubagentSessionStore(config.stateDir);
 }
-function rowToLocalAgentRecord(row) {
+function rowToSubagentSession(row) {
+    const activeRun = row.active_run_id
+        ? {
+            id: row.active_run_id,
+            status: "running",
+            ...(row.active_activity_id ? { activityId: row.active_activity_id } : {}),
+            ...(row.active_run_started_at ? { startedAt: row.active_run_started_at } : {}),
+        }
+        : undefined;
+    const latestOutcome = readOutcome(row.latest_run_outcome);
+    const latestRun = row.latest_run_id && latestOutcome
+        ? {
+            id: row.latest_run_id,
+            status: latestOutcome,
+            ...(row.latest_run_finished_at ? { finishedAt: row.latest_run_finished_at } : {}),
+        }
+        : undefined;
     return {
         id: row.id,
         workspaceId: row.workspace_id ?? undefined,
@@ -124,34 +176,18 @@ function rowToLocalAgentRecord(row) {
         model: row.model ?? undefined,
         thinking: row.thinking ?? undefined,
         providerSessionId: row.provider_session_id ?? undefined,
-        status: readStatus(row.status),
-        latestResponse: row.latest_response ?? undefined,
-        error: row.error ?? undefined,
-        hookReports: parseHookReports(row.hook_reports_json),
+        status: activeRun || row.status === "starting" || row.status === "running" ? "running" : "idle",
+        ...(activeRun ? { activeRun } : {}),
+        ...(latestRun ? { latestRun } : {}),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
 }
-function parseHookReports(value) {
-    if (!value)
-        return undefined;
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function readStatus(status) {
-    if (status === "starting" ||
-        status === "running" ||
-        status === "idle" ||
-        status === "error" ||
-        status === "stopped") {
-        return status;
+function readOutcome(value) {
+    if (value === "succeeded" || value === "failed" || value === "cancelled" || value === "interrupted") {
+        return value;
     }
-    return "error";
+    return undefined;
 }
 function escapeLike(value) {
     return value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");