@akira-tl/forgerelay 0.6.2 → 0.7.1

package/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable ForgeRelay changes are documented here.
 
 ## [Unreleased]
 
+## [0.7.1] - 2026-08-30
+
+### Added
+
+- `subagent.session resume` 现在基于 provider-native continuation 继续已有 Session；Codex、Claude、OpenCode、Pi 支持真实 continuation，Cursor/Copilot 明确保持 start-only。
+
+### Changed
+
+- Session 固定创建时的 provider/profile/model/thinking，并严格限制在所属 Execution Workspace；busy resume、跨 Workspace 访问和不受支持的 continuation 都返回明确错误。
+
+### Fixed
+
+- Windows restart mailbox 测试在清理临时 SQLite state 前显式关闭 restored server，避免 `EBUSY`。
+
+## [0.7.0] - 2026-08-30
+
+### Added
+
+- 新增 first-class `subagent.session` Capability tracer：Host 可通过现有 Capability Gateway 发现并启动 provider-backed Subagent Session、查询 `status`、列出当前 Execution Workspace 拥有的 Session，并通过有界单次 delivery mailbox 接收后台 Run 的最终结果；canonical Core MCP tool 仍保持九个。
+- 为 ForgeRelay Subagent 引入稳定的 Session / Run identity 和 workspace-scoped coordination，使每次 delegated execution 都有明确的 Run 生命周期、Activity 关联和 provider continuation 映射，而无需经由 `bash -> forgerelay agents ...` CLI 间接执行。
+
+### Changed
+
+- 将 Claude Code、Codex、OpenCode、Pi 等 provider 的原生 session store 作为 conversation history 真源；ForgeRelay SQLite 停止写入 delegated prompt、profile body、final response、Hook report history 和 provider event/items，仅保留轻量 ownership、provider/profile/model/thinking 与 active/latest Run 协调元数据。
+- Provider adapter contract 收敛为 continuation identity、final response 与必要执行元数据，provider streaming/messages/events 只瞬时消费；profile body 仅在 Session 首次启动时交给 provider，ForgeRelay 不保存正文副本。
+
 ## [0.6.2] - 2026-08-29
 
 ### Added

package/capabilities/subagents/GUIDE.md

@@ -1,69 +1,129 @@
-# ForgeRelay Subagents
+# ForgeRelay Subagent
 
-当任务涉及委派给另一个本地 coding agent、获取第二意见、并行调查，或用户明确点名 subagent 时读取本指南。
+当任务需要委派给另一个本地 coding agent、获取第二意见、并行调查，或用户明确点名 Subagent/provider 时读取本指南。
 
-## 当前接口边界
+## 当前接口
 
-0.3 仍然使用 ForgeRelay CLI 协调 provider-backed local subagent；当前没有 first-class MCP subagent tool。不要把 Host 自己的 subagent 功能与 ForgeRelay subagent 混为一谈。
+启用 Subagent 后，`open_workspace` 会在 `capabilityCatalog` 中公开 `subagent.session`，同时返回紧凑的 provider/profile 元数据。不要为 Subagent 寻找或假设额外的 Core MCP tool；长期可见 Core tool surface 保持不变。
 
-启用方式：
+通过统一 `capability` gateway 调用：
 
-```bash
-FORGERELAY_SUBAGENTS=1 forgerelay serve
+```text
+name = subagent.session
+action = run
 ```
 
-启用后，`open_workspace` 会返回紧凑的 `agentProviders` 和 `agents` 元数据。配置 profile 通常来自全局 ForgeRelay 配置目录以及项目内：
+当前支持四个 operation：
 
-```text
-.forgerelay/agents/*.md
-.devspace/agents/*.md
+- `start`：创建 Subagent Session，并立即启动第一个 Subagent Run；
+- `resume`：在支持真实 continuation 的 provider 上继续现有 Session；
+- `status`：读取当前 Workspace 中一个 Session 的协调状态；
+- `list`：列出当前 Workspace 拥有的 Session 摘要。
+
+`subagent.session` 不支持 `batch.execute`。
+
+## start
+
+使用 profile：
+
+```json
+{
+  "operation": "start",
+  "target": "reviewer",
+  "prompt": "检查当前改动的并发与错误处理。"
+}
 ```
 
-旧 `.devspace` 路径仅用于迁移兼容。
+也可以把 ForgeRelay 支持的 provider 名直接作为 `target`。创建新 Session 时可以显式给出 `model` / `thinking`；profile 已有默认值时通常无需重复覆盖。
 
-## 何时使用
+返回值包含：
 
-不要因为存在 profile 就自动委派普通开发工作。只有在用户要求委派、第二意见、并行工作或指定 subagent/provider 时才使用，并明确告诉用户正在使用另一个 subagent。
+- `session.id`：ForgeRelay 的 Subagent Session identity；
+- `session.status`：`running` 或 `idle`；
+- `run.id`：本次 delegated execution 的 Subagent Run identity；
+- provider/profile/model 等紧凑协调元数据。
 
-选择 profile 时以 `open_workspace` 返回的 compact profile catalog 为准。`forgerelay agents ls` 显示的是当前 workspace 的已有 subagent sessions，不是 profile 定义列表。
+首次 `start` 使用当时有效的 profile body 作为 provider-native conversation 的初始 instructions。ForgeRelay 不把 profile body 复制进自己的 Session SQLite。
 
-## 常用命令
+## resume
 
-正常委派只需要：
+已有 Session 完成一次 Run 后，可发送新的 delegated prompt：
 
-```bash
-forgerelay agents ls
-forgerelay agents run <profile-or-provider-or-id> "<prompt>"
-forgerelay agents show <id>
+```json
+{
+  "operation": "resume",
+  "sessionId": "agt_...",
+  "prompt": "继续检查测试覆盖。"
+}
 ```
 
-语义：
+`resume` 只接受 `sessionId + prompt`，不能改变 model/thinking。Session 创建时确定的 provider/profile/model/thinking 在整个 Session 生命周期中保持固定；resume 不重新读取或注入当前 profile body，而是使用 provider-native continuation history。
 
-- `run <profile>`：启动配置好的 profile；
-- `run <provider>`：没有合适 profile 时直接启动 ForgeRelay 内建 provider；
-- `run <id>`：向现有 agent session 发送 follow-up；
-- `show <id>`：查看状态和最新响应；仍在运行时可稍后再次调用；
-- shell workspace 环境会把 CLI 操作自动限定到当前 ForgeRelay workspace。
+同一个 Session 最多只有一个 active Run；Session 正在执行时再次 resume 会返回 `subagent.busy`，不会排队或并发执行。Codex、Claude、OpenCode、Pi 支持真实 continuation；Cursor/Copilot 当前明确标记为 start-only，resume 返回 `subagent.continuation_unsupported`，不会伪装成新 provider session。
 
-如确实需要覆盖 profile/provider 默认值，可使用：
+## status / list
 
-```bash
-forgerelay agents run <profile-or-provider> --model <model> "<prompt>"
-forgerelay agents run <profile-or-provider> --thinking <level> "<prompt>"
+查询一个 Session：
+
+```json
+{
+  "operation": "status",
+  "sessionId": "agt_..."
+}
 ```
 
-`thinking` 是 provider-specific passthrough；ForgeRelay 不在 provider 之间翻译 reasoning level。
+列出当前 Workspace 的 Session：
+
+```json
+{
+  "operation": "list"
+}
+```
+
+Session 受实际 Execution Workspace 所有权约束；Session ID 不是跨 Workspace 的访问凭证。`status` / `resume` 都只能访问当前实际 Execution Workspace 拥有的 Session，`list` 也只返回当前 Workspace 的紧凑摘要。
+
+Session 返回中会给出 `continuationSupported` 与 `resumable`；`open_workspace` 的 provider metadata 也会明确给出 `continuationSupported`。当前尚未通过 first-class Capability 开放 `stop` 或 `delete`，不要伪造这些 operation，也不要用新的 Core MCP tool 绕过 Capability Gateway。
+
+## 后台完成与结果交付
+
+`start` 接受执行后会尽快把 Session/Run identity 返回给 Host，Subagent Run 在后台继续执行。
+
+Run 完成后：
+
+- ForgeRelay 创建一个 linked `subagent_result` Activity，只记录 Session/Run/provider/status 等有界元数据；
+- final response 放入有界 delivery mailbox，等待同一 Workspace 的后续 ForgeRelay 调用领取；
+- 成功领取后 mailbox 条目立即删除，同一个 completion 不重复交付；
+- 未领取 completion 可以跨正常 ForgeRelay 进程重启保留。
+
+如果需要等待结果，使用 `status` 进行有节制的后续查询；不要高频短轮询。
+
+## 数据所有权
+
+Claude Code、Codex、OpenCode、Pi 等 provider 自己的 session store 是 conversation history 的真源。ForgeRelay 只保存恢复、Workspace ownership 和执行协调所需的小型元数据。
+
+ForgeRelay 不把以下内容保存进 Subagent Session SQLite 或 Activity Audit：
+
+- delegated prompt；
+- profile body；
+- provider transcript/messages/events/items；
+- final response 正文；
+- 完整 Hook report 历史；
+- 完整 Subagent Run 历史。
+
+Activity 只保留操作摘要；delivery mailbox 只用于尚未交付的 bounded completion，不是 conversation/history store。
+
+## Hooks
 
-除非正在明确调试 ForgeRelay provider integration，不要绕过 ForgeRelay 直接运行 `codex`、`claude`、`opencode`、`pi`、`cursor-agent`、`copilot` 等 provider CLI。
+`SubagentStart` / `SubagentStop` 在每一次 Subagent Run 生命周期中触发。Hook payload 使用 Session/Run/profile/provider/model/thinking/status 等协调元数据，不包含 delegated prompt 或 final response。
 
-## Prompt 与验证
+## CLI 兼容
 
-Subagent 只收到你发送的 prompt 和它自己的 profile instructions，因此 prompt 必须自包含：目标、相关模块/文件、约束、验收标准，以及它能否修改文件。
+`forgerelay agents` 仍可用于本地诊断和兼容性操作，但 Host 正常委派优先使用 `subagent.session` Capability，不要通过 `bash -> forgerelay agents ...` 实现 first-class Subagent。
 
-Subagent 的结果不是自动验证过的最终答案。收到响应后：
+## 验证责任
 
-- 写入型任务：检查实际改动并运行相关测试；
-- 只读调查：核对关键结论是否有仓库证据；
-- 向用户说明使用了哪个 profile/provider、它给出的结论、你做了哪些验证，以及剩余风险。
+Subagent 返回不是自动验证过的最终结论。收到结果后仍应按照任务类型验证：
 
-`SubagentStart` / `SubagentStop` lifecycle Hooks 会在 worker 生命周期中触发；异步报告会随 ForgeRelay session 持久化并可由 `forgerelay agents show` 查看。
+- 写入型任务检查真实 diff，并运行相关测试；
+- 只读调查核对关键结论对应的仓库事实；
+- 向用户说明使用的 profile/provider、核心结论、已做验证与剩余风险。

package/dist/activity/lifecycle.js

@@ -32,7 +32,7 @@ export class ActivityLifecycle {
         const activityId = executionContext.activityId;
         try {
             const result = await options.operation(executionContext);
-            this.finish(activityId, result, options.outcome?.(result) ?? { type: "succeeded" });
+            this.finish(activityId, options.auditResult?.(result) ?? result, options.outcome?.(result) ?? { type: "succeeded" });
             return result;
         }
         catch (error) {

package/dist/capabilities.js

@@ -92,7 +92,7 @@ export function buildCapabilityFingerprint(config, version, context = {}) {
         capabilities.push("batch.execute");
     }
     if (config.subagents) {
-        capabilities.push("subagent.profiles");
+        capabilities.push("subagent.session");
     }
     if (config.artifactsEnabled && context.artifactDownloadSupported) {
         capabilities.push("artifact.native-download");

package/dist/capability-registry.js

@@ -130,6 +130,25 @@ export function createCapabilityRegistry(dependencies) {
         line: z.number().int(),
         column: z.number().int(),
     };
+    const subagentSessionInput = z.discriminatedUnion("operation", [
+        z.object({
+            operation: z.literal("start"),
+            target: z.string().min(1),
+            prompt: z.string().min(1),
+            model: z.string().min(1).optional(),
+            thinking: z.string().min(1).optional(),
+        }).strict(),
+        z.object({
+            operation: z.literal("resume"),
+            sessionId: z.string().min(1),
+            prompt: z.string().min(1),
+        }).strict(),
+        z.object({
+            operation: z.literal("status"),
+            sessionId: z.string().min(1),
+        }).strict(),
+        z.object({ operation: z.literal("list") }).strict(),
+    ]);
     const codeIntelligenceInput = z.discriminatedUnion("operation", [
         z.object({ operation: z.literal("definition"), ...positionInput }).strict(),
         z.object({ operation: z.literal("hover"), ...positionInput }).strict(),
@@ -201,6 +220,21 @@ export function createCapabilityRegistry(dependencies) {
                     run: async (input, context, options) => dependencies.codeIntelligence.run(input, context, options),
                 }]
             : []),
+        ...(dependencies.subagentSession
+            ? [{
+                    name: "subagent.session",
+                    description: "Coordinate provider-backed Subagent Sessions in the current Execution Workspace.",
+                    guideName: "subagents",
+                    readGuideBeforeFirstUse: true,
+                    batchPolicy: "unsupported",
+                    inputSchema: subagentSessionInput,
+                    availability: () => ({
+                        available: dependencies.subagentSession?.available ?? false,
+                        reason: dependencies.subagentSession?.unavailableReason,
+                    }),
+                    run: async (input, context, options) => dependencies.subagentSession.run(input, context, options),
+                }]
+            : []),
         ...(dependencies.batchExecute
             ? [{
                     name: "batch.execute",

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 import { mkdtempSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,13 +11,12 @@ import * as prompts from "@clack/prompts";
 import { getShellConfig } from "@earendil-works/pi-coding-agent";
 import { satisfies } from "semver";
 import { loadConfig } from "./config.js";
-import { formatVisibleHookReports, HookRunner } from "./hooks.js";
 import { runHooksCommand } from "./hook-cli.js";
-import { runLocalAgentProvider } from "./local-agent-adapters.js";
-import { isLocalAgentProvider, loadLocalAgentProfiles, } from "./local-agent-profiles.js";
-import { assertLocalAgentProviderAvailable, formatLocalAgentProviderAvailabilitySummary, } from "./local-agent-availability.js";
-import { formatAvailableLocalAgentTargets, parseLocalAgentRunArgs, resolveLocalAgentTarget, } from "./local-agent-targets.js";
-import { createLocalAgentStore } from "./local-agent-store.js";
+import { executeSubagentSession } from "./subagents/sessions/execution.js";
+import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.js";
+import { SubagentSessionManager } from "./subagents/sessions/manager.js";
+import { formatSubagentProviderAvailabilitySummary } from "./subagents/providers/availability.js";
+import { parseSubagentRunArgs } from "./subagents/cli-target.js";
 import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadDevspaceFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, writeForgeRelayRemote, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
@@ -193,7 +192,7 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app, close, localAgentProviders } = createServer(config);
+    const { app, close, subagentProviders } = createServer(config);
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
         console.log(`public base url: ${config.publicBaseUrl}`);
@@ -205,7 +204,7 @@ async function serve() {
         console.log("auth: Owner password approval required");
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
         if (config.subagents) {
-            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+            console.log(`subagent providers: ${formatSubagentProviderAvailabilitySummary(subagentProviders)}`);
         }
     });
     let shuttingDown = false;
@@ -492,92 +491,79 @@ async function runAgentsCommand(args) {
     }
 }
 async function runAgentsList() {
-    const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    const agents = store.list(resolveCurrentWorkspaceScope());
-    if (agents.length === 0) {
-        console.log("No subagent sessions found for this workspace.");
-        return;
+    const manager = createCliSubagentSessionManager();
+    try {
+        const agents = manager.list(resolveCurrentWorkspaceScope());
+        if (agents.length === 0) {
+            console.log("No subagent sessions found for this workspace.");
+            return;
+        }
+        for (const agent of agents) {
+            console.log(formatAgentLine(agent));
+        }
     }
-    for (const agent of agents) {
-        console.log(formatAgentLine(agent));
+    finally {
+        manager.close();
     }
 }
 async function runAgentsRun(args) {
-    const parsed = parseLocalAgentRunArgs(args);
-    const config = loadConfig();
+    const parsed = parseSubagentRunArgs(args);
     const workspaceRoot = resolveCurrentWorkspaceRoot();
-    const store = createLocalAgentStore(config);
-    const existing = store.get(parsed.target);
-    if (existing) {
-        if (!isLocalAgentProvider(existing.provider)) {
-            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
-        }
-        assertLocalAgentProviderAvailable(existing.provider);
-        const promptFile = writeAgentPromptFile(parsed.prompt);
-        store.update(existing.id, {
-            status: "starting",
-            model: parsed.model ?? existing.model,
-            thinking: parsed.thinking ?? existing.thinking,
-            latestResponse: undefined,
-            error: undefined,
-            hookReports: undefined,
-        });
-        spawnAgentWorker(existing.id, promptFile);
-        console.log(formatAgentLine({
-            ...existing,
-            status: "running",
-            model: parsed.model ?? existing.model,
-            thinking: parsed.thinking ?? existing.thinking,
-        }));
-        return;
-    }
-    const profiles = await loadLocalAgentProfiles(config, workspaceRoot);
-    const target = resolveLocalAgentTarget(parsed.target, profiles, parsed.model, parsed.thinking);
-    if (!target) {
-        throw new Error(`Unknown subagent profile, provider, or id: ${parsed.target}. Available ${formatAvailableLocalAgentTargets(profiles)}`);
+    const manager = createCliSubagentSessionManager();
+    try {
+        const existing = manager.get(parsed.target);
+        if (existing && (parsed.model || parsed.thinking))
+            throw new Error("Existing Subagent Sessions cannot override model or thinking.");
+        const started = existing
+            ? manager.resume({ sessionId: existing.id, prompt: parsed.prompt })
+            : await manager.start({
+                workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+                workspaceRoot,
+                target: parsed.target,
+                prompt: parsed.prompt,
+                model: parsed.model,
+                thinking: parsed.thinking,
+            });
+        console.log(formatAgentLine(started.session));
+    }
+    finally {
+        manager.close();
     }
-    assertLocalAgentProviderAvailable(target.provider);
-    const promptFile = writeAgentPromptFile(parsed.prompt);
-    const record = store.create({
-        workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
-        workspaceRoot,
-        profileName: target.name,
-        provider: target.provider,
-        model: target.model,
-        thinking: target.thinking,
-    });
-    spawnAgentWorker(record.id, promptFile);
-    console.log(formatAgentLine({ ...record, status: "running" }));
 }
 async function runAgentsShow(args) {
     const [id] = args;
     if (!id)
         throw new Error("Usage: forgerelay agents show <id>");
     const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    let record = store.get(id);
-    if (!record)
-        throw new Error(`Unknown subagent id: ${id}`);
-    const deadline = Date.now() + 15_000;
-    while ((record.status === "starting" || record.status === "running") && Date.now() < deadline) {
-        await sleep(500);
-        record = store.get(id) ?? record;
-    }
-    console.log(formatAgentLine(record));
-    const hookSummary = formatVisibleHookReports(record.hookReports ?? []);
-    if (hookSummary)
-        console.log(hookSummary);
-    if (record.latestResponse) {
-        console.log(record.latestResponse);
-        return;
-    }
-    if (record.error) {
-        console.log(record.error);
-        return;
+    const manager = createCliSubagentSessionManager(config);
+    try {
+        let record = manager.get(id);
+        if (!record)
+            throw new Error(`Unknown subagent id: ${id}`);
+        const deadline = Date.now() + 15_000;
+        while (record.status === "running" && Date.now() < deadline) {
+            await sleep(500);
+            record = manager.get(id) ?? record;
+        }
+        console.log(formatAgentLine(record));
+        if (record.workspaceId) {
+            const deliveries = new SubagentDeliveryMailbox(config.stateDir).claimSession(record.workspaceId, record.id);
+            for (const delivery of deliveries) {
+                const text = delivery.outcome === "succeeded" ? delivery.finalResponse : delivery.error;
+                if (text)
+                    console.log(text);
+            }
+            if (deliveries.length > 0)
+                return;
+        }
+        if (record.latestRun)
+            console.log(`Latest run ${record.latestRun.id}: ${record.latestRun.status}`);
+        if (record.status === "running") {
+            console.log(`No final response yet. Call \`forgerelay agents show ${record.id}\` again later.`);
+        }
     }
-    if (record.status === "starting" || record.status === "running") {
-        console.log(`No final response yet. Call \`forgerelay agents show ${record.id}\` again later.`);
+    finally {
+        manager.close();
     }
 }
 async function runAgentsWorker(args) {
@@ -586,96 +572,25 @@ async function runAgentsWorker(args) {
         throw new Error("Usage: forgerelay agents __worker <id> --prompt-file <path>");
     }
     const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    const record = store.get(id);
-    if (!record)
-        throw new Error(`Unknown subagent id: ${id}`);
-    const hooks = new HookRunner(config.hooks, config.logging);
-    const hookInvocation = {
-        workspaceId: record.workspaceId,
-        workspaceRoot: record.workspaceRoot,
-        payload: {
-            agentId: record.id,
-            profile: record.profileName,
-            provider: record.provider,
-            model: record.model,
-            thinking: record.thinking,
+    const prompt = await readFile(promptFile, "utf8");
+    await rm(promptFile, { force: true });
+    await executeSubagentSession(config, id, prompt);
+}
+function createCliSubagentSessionManager(config = loadConfig()) {
+    return new SubagentSessionManager(config, {
+        launch(request) {
+            const promptFile = writeSubagentPromptFile(request.prompt);
+            spawnSubagentWorker(request.sessionId, promptFile);
         },
-    };
-    store.update(record.id, { status: "running", error: undefined, hookReports: undefined });
-    const hookReports = await hooks.run("SubagentStart", hookInvocation);
-    store.update(record.id, { hookReports });
-    try {
-        const profiles = await loadLocalAgentProfiles(config, record.workspaceRoot);
-        const profile = profiles.find((candidate) => candidate.name === record.profileName);
-        const prompt = await readFile(promptFile, "utf8");
-        const result = profile
-            ? await runLocalAgentProfile(profile, record, prompt)
-            : await runRawLocalAgentProvider(record, prompt);
-        hookReports.push(...await hooks.run("SubagentStop", {
-            ...hookInvocation,
-            payload: {
-                ...hookInvocation.payload,
-                status: "idle",
-                providerSessionId: result.providerSessionId,
-            },
-        }));
-        store.update(record.id, {
-            providerSessionId: result.providerSessionId ?? undefined,
-            status: "idle",
-            latestResponse: result.finalResponse,
-            error: undefined,
-            hookReports,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        hookReports.push(...await hooks.run("SubagentStop", {
-            ...hookInvocation,
-            payload: {
-                ...hookInvocation.payload,
-                status: "error",
-            },
-        }));
-        store.update(record.id, {
-            status: "error",
-            error: message,
-            hookReports,
-        });
-    }
-}
-async function runLocalAgentProfile(profile, record, prompt) {
-    const body = profile.body.trim();
-    const fullPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
-    return runLocalAgentProvider(profile.provider, {
-        prompt: fullPrompt,
-        workspace: record.workspaceRoot,
-        providerSessionId: record.providerSessionId,
-        writeMode: "allowed",
-        model: record.model ?? profile.model,
-        thinking: record.thinking ?? profile.thinking,
-    });
-}
-async function runRawLocalAgentProvider(record, prompt) {
-    if (record.profileName !== record.provider || !isLocalAgentProvider(record.provider)) {
-        throw new Error(`Subagent profile not found: ${record.profileName}`);
-    }
-    return runLocalAgentProvider(record.provider, {
-        prompt,
-        workspace: record.workspaceRoot,
-        providerSessionId: record.providerSessionId,
-        writeMode: "allowed",
-        model: record.model,
-        thinking: record.thinking,
     });
 }
-function spawnAgentWorker(agentId, promptFile) {
+function spawnSubagentWorker(sessionId, promptFile) {
     const child = spawn(process.execPath, [
         ...process.execArgv,
         fileURLToPath(import.meta.url),
         "agents",
         "__worker",
-        agentId,
+        sessionId,
         "--prompt-file",
         promptFile,
     ], {
@@ -685,7 +600,7 @@ function spawnAgentWorker(agentId, promptFile) {
     });
     child.unref();
 }
-function writeAgentPromptFile(prompt) {
+function writeSubagentPromptFile(prompt) {
     const directory = mkdtempSync(join(tmpdir(), "forgerelay-agent-prompt-"));
     const filePath = join(directory, "prompt.txt");
     writeFileSync(filePath, prompt, { mode: 0o600 });

package/dist/db/migrations.js

@@ -64,6 +64,11 @@ const migrations = [
         name: "activity-host-turn-workspace",
         up: migrateActivityHostTurnWorkspace,
     },
+    {
+        version: 14,
+        name: "subagent-session-coordination",
+        up: migrateSubagentSessionCoordination,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -344,6 +349,15 @@ function migrateBashOutputAuditColumns(sqlite) {
     addColumnIfMissing(sqlite, "bash_output_streams", "returned", "integer not null default 0");
     addColumnIfMissing(sqlite, "bash_output_streams", "completion_claimed_at", "text");
 }
+function migrateSubagentSessionCoordination(sqlite) {
+    migrateLocalAgentSessions(sqlite);
+    addColumnIfMissing(sqlite, "local_agent_sessions", "active_run_id", "text");
+    addColumnIfMissing(sqlite, "local_agent_sessions", "active_activity_id", "text");
+    addColumnIfMissing(sqlite, "local_agent_sessions", "active_run_started_at", "text");
+    addColumnIfMissing(sqlite, "local_agent_sessions", "latest_run_id", "text");
+    addColumnIfMissing(sqlite, "local_agent_sessions", "latest_run_outcome", "text");
+    addColumnIfMissing(sqlite, "local_agent_sessions", "latest_run_finished_at", "text");
+}
 function migrateActivityHostTurnWorkspace(sqlite) {
     migrateActivityHostTurns(sqlite);
     addColumnIfMissing(sqlite, "activity_host_turns", "workspace_id", "text");

package/dist/db/schema.js

@@ -152,6 +152,12 @@ export const localAgentSessions = sqliteTable("local_agent_sessions", {
     thinking: text("thinking"),
     providerSessionId: text("provider_session_id"),
     status: text("status").notNull(),
+    activeRunId: text("active_run_id"),
+    activeActivityId: text("active_activity_id"),
+    activeRunStartedAt: text("active_run_started_at"),
+    latestRunId: text("latest_run_id"),
+    latestRunOutcome: text("latest_run_outcome"),
+    latestRunFinishedAt: text("latest_run_finished_at"),
     latestResponse: text("latest_response"),
     error: text("error"),
     hookReportsJson: text("hook_reports_json"),