@mrc2204/opencode-bridge 0.1.2 → 0.1.3

package/dist/{index.js → src/index.js}

@@ -3,10 +3,13 @@ import {
   parseSseFramesFromBuffer,
   resolveSessionId,
   summarizeLifecycle
-} from "./chunk-LCJRXKI3.js";
+} from "./chunk-OVQ5X54C.js";
+import {
+  buildTaggedSessionTitle
+} from "./chunk-TDVN5AFB.js";
 
 // src/runtime.ts
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
 import { join } from "path";
 import { spawn } from "child_process";
 import { createServer } from "net";
@@ -183,6 +186,30 @@ function mapEventToState(event) {
       return "running";
   }
 }
+function assertCallbackTargetSessionKey(envelope) {
+  const callbackTargetSessionKey = asString(envelope?.callback_target_session_key);
+  if (!callbackTargetSessionKey) {
+    throw new Error("Invalid routing envelope: missing callback_target_session_key (required for current-session callback integrity)");
+  }
+  return callbackTargetSessionKey;
+}
+function buildHooksAgentCallback(input) {
+  const state = mapEventToState(input.event);
+  const message = input.summary || `OpenCode event=${input.event} state=${state} task=${input.envelope.task_id} run=${input.envelope.run_id} project=${input.envelope.project_id} requestedAgent=${input.envelope.requested_agent_id} resolvedAgent=${input.envelope.resolved_agent_id}`;
+  const callbackTargetSessionKey = assertCallbackTargetSessionKey(input.envelope);
+  return {
+    message,
+    name: "OpenCode",
+    // callback should wake requester/origin lane, not execution lane
+    agentId: input.envelope.requested_agent_id,
+    sessionKey: callbackTargetSessionKey,
+    ...input.envelope.callback_target_session_id ? { sessionId: input.envelope.callback_target_session_id } : {},
+    wakeMode: "now",
+    deliver: false,
+    ...input.envelope.channel ? { channel: input.envelope.channel } : {},
+    ...input.envelope.to ? { to: input.envelope.to } : {}
+  };
+}
 function evaluateLifecycle(input) {
   const nowMs = input.nowMs ?? Date.now();
   const softStallMs = input.softStallMs ?? DEFAULT_SOFT_STALL_MS;
@@ -216,14 +243,46 @@ function evaluateLifecycle(input) {
 function getRunStateDir() {
   return join(getBridgeStateDir(), "runs");
 }
+function writeRunStatus(status) {
+  const dir = getRunStateDir();
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${status.runId}.json`);
+  writeFileSync(path, JSON.stringify(status, null, 2), "utf8");
+  return path;
+}
 function readRunStatus(runId) {
   const path = join(getRunStateDir(), `${runId}.json`);
   if (!existsSync(path)) return null;
   return JSON.parse(readFileSync(path, "utf8"));
 }
+function patchRunStatus(runId, patch) {
+  const current = readRunStatus(runId);
+  if (!current) return null;
+  const next = typeof patch === "function" ? patch(current) : { ...current, ...patch };
+  writeRunStatus(next);
+  return next;
+}
+function listRunStatuses() {
+  const dir = getRunStateDir();
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => {
+    try {
+      return JSON.parse(readFileSync(join(dir, name), "utf8"));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
 function getAuditDir() {
   return join(getBridgeStateDir(), "audit");
 }
+function appendAudit(record) {
+  const dir = getAuditDir();
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "callbacks.jsonl");
+  writeFileSync(path, JSON.stringify(record) + "\n", { encoding: "utf8", flag: "a" });
+  return path;
+}
 function getServeRegistryPath() {
   return join(getBridgeStateDir(), "registry.json");
 }
@@ -303,16 +362,43 @@ async function waitForHealth(serverUrl, timeoutMs = 1e4) {
   }
   return false;
 }
+async function fetchServeProjectBinding(serverUrl) {
+  const normalizedUrl = serverUrl.replace(/\/$/, "");
+  const [projectRes, pathRes] = await Promise.all([
+    fetchJsonSafe(`${normalizedUrl}/project/current`),
+    fetchJsonSafe(`${normalizedUrl}/path`)
+  ]);
+  const project = projectRes.ok ? projectRes.data : void 0;
+  const path = pathRes.ok ? pathRes.data : void 0;
+  const directory = asString(project?.directory) || asString(project?.path) || asString(path?.directory) || asString(path?.cwd) || asString(path?.path);
+  if (directory) {
+    return { ok: true, directory, project, path };
+  }
+  return {
+    ok: false,
+    project,
+    path,
+    error: projectRes.error || pathRes.error || "Could not determine serve project binding"
+  };
+}
+async function isServeBoundToRepo(serverUrl, repoRoot) {
+  const binding = await fetchServeProjectBinding(serverUrl);
+  return binding.ok && binding.directory === repoRoot;
+}
 async function spawnServeForProject(input) {
   const existing = normalizeServeRegistry(readServeRegistry()).entries.find((x) => x.project_id === input.project_id || x.repo_root === input.repo_root);
   if (existing && existing.status === "running") {
     const healthy2 = await waitForHealth(existing.opencode_server_url, 2e3);
     if (healthy2) {
-      return { reused: true, entry: existing, registryPath: getServeRegistryPath() };
+      const boundToRepo = await isServeBoundToRepo(existing.opencode_server_url, input.repo_root);
+      if (boundToRepo) {
+        return { reused: true, entry: existing, registryPath: getServeRegistryPath() };
+      }
     }
   }
   const port = await allocatePort();
   const child = spawn("opencode", ["serve", "--hostname", "127.0.0.1", "--port", String(port)], {
+    cwd: input.repo_root,
     detached: true,
     stdio: "ignore"
   });
@@ -475,9 +561,275 @@ async function collectSseEvents(serverUrl, scope, options) {
     clearTimeout(timeout);
   }
 }
+async function executeHooksAgentCallback(hookBaseUrl, hookToken, callback) {
+  const response = await fetch(`${hookBaseUrl.replace(/\/$/, "")}/hooks/agent`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${hookToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(callback)
+  });
+  const text = await response.text();
+  return {
+    ok: response.ok,
+    status: response.status,
+    body: text
+  };
+}
+function coerceLifecycleState(value) {
+  if (!value) return "running";
+  if (value === "queued" || value === "server_ready" || value === "session_created" || value === "prompt_sent" || value === "planning" || value === "coding" || value === "verifying" || value === "blocked" || value === "running" || value === "awaiting_permission" || value === "stalled" || value === "failed" || value === "completed") {
+    return value;
+  }
+  return "running";
+}
+function isTerminalLifecycleState(state) {
+  return state === "completed" || state === "failed";
+}
+function buildTerminalEventFromState(state, fallback) {
+  if (state === "completed") return "task.completed";
+  if (state === "failed") return "task.failed";
+  return fallback || "task.progress";
+}
+async function createSessionForEnvelope(envelope) {
+  const serverUrl = envelope.opencode_server_url.replace(/\/$/, "");
+  const taggedTitle = buildTaggedSessionTitle({
+    runId: envelope.run_id,
+    taskId: envelope.task_id,
+    requested: envelope.requested_agent_id,
+    resolved: envelope.resolved_agent_id,
+    callbackSession: envelope.callback_target_session_key,
+    callbackSessionId: envelope.callback_target_session_id,
+    projectId: envelope.project_id,
+    repoRoot: envelope.repo_root
+  });
+  const createdRes = await fetch(`${serverUrl}/session`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ title: taggedTitle })
+  });
+  const createdText = await createdRes.text();
+  let created;
+  try {
+    created = createdText ? JSON.parse(createdText) : null;
+  } catch {
+    created = { raw: createdText };
+  }
+  if (!createdRes.ok) {
+    throw new Error(`session create failed: ${createdRes.status} ${createdText}`);
+  }
+  const sessionId = asString(created?.id);
+  if (!sessionId) {
+    throw new Error("session create failed: missing session id");
+  }
+  return { sessionId, created };
+}
+async function sendPromptAsyncForEnvelope(envelope, sessionId, prompt) {
+  const serverUrl = envelope.opencode_server_url.replace(/\/$/, "");
+  const response = await fetch(`${serverUrl}/session/${sessionId}/prompt_async`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      agent: envelope.resolved_agent_id,
+      parts: [{ type: "text", text: prompt }]
+    })
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`prompt_async failed: ${response.status} ${text}`);
+  }
+}
+async function maybeSendTerminalCallback(input) {
+  const runtimeCfg = getRuntimeConfig(input.cfg);
+  if (!runtimeCfg.hookBaseUrl || !runtimeCfg.hookToken) {
+    const updated = patchRunStatus(input.runStatus.runId, (current) => ({
+      ...current,
+      callbackError: "hook config missing",
+      callbackAttempts: (current.callbackAttempts || 0) + 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    return { ok: false, skipped: true, reason: "hook_config_missing", runStatus: updated || input.runStatus };
+  }
+  if (input.runStatus.callbackSentAt) {
+    return { ok: true, skipped: true, reason: "already_sent", runStatus: input.runStatus };
+  }
+  const callback = buildHooksAgentCallback({
+    event: input.event,
+    envelope: input.runStatus.envelope,
+    summary: input.summary || input.runStatus.lastSummary
+  });
+  const attempts = (input.runStatus.callbackAttempts || 0) + 1;
+  try {
+    const result = await executeHooksAgentCallback(runtimeCfg.hookBaseUrl, runtimeCfg.hookToken, callback);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    appendAudit({
+      taskId: input.runStatus.taskId,
+      runId: input.runStatus.runId,
+      agentId: callback.agentId,
+      requestedAgentId: input.runStatus.envelope.requested_agent_id,
+      resolvedAgentId: input.runStatus.envelope.resolved_agent_id,
+      sessionKey: input.runStatus.envelope.session_key,
+      callbackTargetSessionKey: input.runStatus.envelope.callback_target_session_key,
+      callbackTargetSessionId: input.runStatus.envelope.callback_target_session_id,
+      event: input.event,
+      callbackStatus: result.status,
+      callbackOk: result.ok,
+      callbackBody: result.body,
+      createdAt
+    });
+    const updated = patchRunStatus(input.runStatus.runId, (current) => ({
+      ...current,
+      callbackAttempts: attempts,
+      callbackSentAt: result.ok ? createdAt : current.callbackSentAt,
+      callbackStatus: result.status,
+      callbackOk: result.ok,
+      callbackBody: result.body,
+      callbackError: result.ok ? void 0 : `hook returned status=${result.status}`,
+      updatedAt: createdAt
+    }));
+    return { ok: result.ok, skipped: false, callback, result, runStatus: updated || input.runStatus };
+  } catch (error) {
+    const message = error?.message || String(error);
+    const updated = patchRunStatus(input.runStatus.runId, (current) => ({
+      ...current,
+      callbackAttempts: attempts,
+      callbackError: message,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    return { ok: false, skipped: false, error: message, runStatus: updated || input.runStatus };
+  }
+}
+async function watchRunToTerminal(input) {
+  const pollIntervalMs = Math.max(250, asNumber(input.pollIntervalMs) || 1e3);
+  const maxWaitMs = Math.max(1e3, asNumber(input.maxWaitMs) || 5 * 60 * 1e3);
+  const startedAt = Date.now();
+  let current = patchRunStatus(input.runId, (status) => ({
+    ...status,
+    watcherStartedAt: status.watcherStartedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    watcherHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+    watcherState: "active",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+  if (!current) {
+    throw new Error(`Run status not found for runId=${input.runId}`);
+  }
+  while (Date.now() - startedAt <= maxWaitMs) {
+    current = readRunStatus(input.runId);
+    if (!current) throw new Error(`Run status disappeared for runId=${input.runId}`);
+    const events = await collectSseEvents(current.envelope.opencode_server_url, "global", {
+      limit: DEFAULT_EVENT_LIMIT,
+      timeoutMs: Math.max(200, pollIntervalMs),
+      runIdHint: current.runId,
+      taskIdHint: current.taskId,
+      sessionIdHint: current.sessionId
+    });
+    if (events.length > 0) {
+      const summary = summarizeLifecycle(
+        events.map((event) => ({
+          kind: event.normalizedKind,
+          summary: event.summary,
+          lifecycleState: event.lifecycle_state,
+          filesChanged: event.files_changed,
+          verifySummary: event.verify_summary,
+          blockers: event.blockers,
+          completionSummary: event.completion_summary,
+          timestamp: event.timestamp
+        }))
+      );
+      current = patchRunStatus(input.runId, (status) => ({
+        ...status,
+        state: coerceLifecycleState(summary.currentState),
+        lastEvent: summary.last_event_kind || status.lastEvent || null,
+        lastSummary: summary.completion_summary || events[events.length - 1]?.summary || status.lastSummary,
+        sessionId: status.sessionId || events.find((event) => event.sessionId)?.sessionId,
+        watcherHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })) || current;
+    } else {
+      current = patchRunStatus(input.runId, (status) => ({
+        ...status,
+        watcherHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })) || current;
+    }
+    if (isTerminalLifecycleState(current.state)) {
+      const callback = await maybeSendTerminalCallback({
+        cfg: input.cfg,
+        runStatus: current,
+        event: buildTerminalEventFromState(current.state, current.lastEvent),
+        summary: current.lastSummary
+      });
+      current = patchRunStatus(input.runId, (status) => ({
+        ...status,
+        watcherCompletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        watcherState: callback.ok ? "completed" : "failed",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      })) || current;
+      return { ok: callback.ok, terminal: true, runStatus: current, callback };
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  current = patchRunStatus(input.runId, (status) => ({
+    ...status,
+    watcherCompletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    watcherState: "failed",
+    callbackError: status.callbackError || "watcher_timeout",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })) || current;
+  return { ok: false, terminal: false, timeout: true, runStatus: current };
+}
+async function startExecutionRun(input) {
+  const initial = {
+    taskId: input.envelope.task_id,
+    runId: input.envelope.run_id,
+    state: "queued",
+    lastEvent: null,
+    lastSummary: void 0,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    envelope: input.envelope,
+    watcherState: "pending"
+  };
+  writeRunStatus(initial);
+  const session = await createSessionForEnvelope(input.envelope);
+  let current = patchRunStatus(input.envelope.run_id, (status) => ({
+    ...status,
+    sessionId: session.sessionId,
+    state: "session_created",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })) || initial;
+  await sendPromptAsyncForEnvelope(input.envelope, session.sessionId, input.prompt);
+  current = patchRunStatus(input.envelope.run_id, (status) => ({
+    ...status,
+    state: "prompt_sent",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })) || current;
+  void watchRunToTerminal({
+    cfg: input.cfg,
+    runId: input.envelope.run_id,
+    pollIntervalMs: input.pollIntervalMs,
+    maxWaitMs: input.maxWaitMs
+  }).catch((error) => {
+    patchRunStatus(input.envelope.run_id, (status) => ({
+      ...status,
+      watcherCompletedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      watcherState: "failed",
+      callbackError: status.callbackError || error?.message || String(error),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  });
+  return {
+    ok: true,
+    runId: input.envelope.run_id,
+    taskId: input.envelope.task_id,
+    sessionId: session.sessionId,
+    state: current.state,
+    watcherStarted: true
+  };
+}
 function buildHookPolicyChecklist(agentId, sessionKey) {
   return {
-    callbackPrimary: "/hooks/agent",
+    primaryCallbackPath: "/hooks/agent",
     requirements: {
       hooksEnabled: true,
       allowRequestSessionKey: true,
@@ -498,11 +850,30 @@ function buildHookPolicyChecklist(agentId, sessionKey) {
 }
 
 // src/registrar.ts
-var PLUGIN_VERSION = "0.1.1";
+var PLUGIN_VERSION = "0.1.3";
+function buildExecutionPrompt(params, envelope) {
+  const providedPrompt = asString(params?.prompt);
+  if (providedPrompt) return providedPrompt;
+  const objective = asString(params?.objective) || asString(params?.message) || `Complete task ${envelope.task_id}`;
+  const constraints = Array.isArray(params?.constraints) ? params.constraints.filter((x) => typeof x === "string" && x.trim()) : [];
+  const acceptance = Array.isArray(params?.acceptanceCriteria) ? params.acceptanceCriteria.filter((x) => typeof x === "string" && x.trim()) : [];
+  return [
+    `Task: ${objective}`,
+    `Run ID: ${envelope.run_id}`,
+    `Task ID: ${envelope.task_id}`,
+    `Requested agent: ${envelope.requested_agent_id}`,
+    `Resolved execution agent: ${envelope.resolved_agent_id}`,
+    constraints.length ? `Constraints:
+- ${constraints.join("\n- ")}` : void 0,
+    acceptance.length ? `Acceptance criteria:
+- ${acceptance.join("\n- ")}` : void 0,
+    "When complete, summarize files changed, verification performed, blockers (if any), and completion outcome in the session output."
+  ].filter(Boolean).join("\n\n");
+}
 function registerOpenCodeBridgeTools(api, cfg) {
-  console.log("[opencode-bridge] scaffold loaded");
+  console.log("[opencode-bridge] plugin loaded");
   console.log(`[opencode-bridge] opencodeServerUrl=${cfg.opencodeServerUrl || "(unset)"}`);
-  console.log("[opencode-bridge] registering opencode_* tool set");
+  console.log("[opencode-bridge] registering opencode_* tools");
   api.registerTool({
     name: "opencode_status",
     label: "OpenCode Status",
@@ -512,7 +883,7 @@ function registerOpenCodeBridgeTools(api, cfg) {
       const runtimeCfg = getRuntimeConfig(cfg);
       const registry = normalizeRegistry(runtimeCfg.projectRegistry);
       return {
-        content: [{ type: "text", text: JSON.stringify({ ok: true, pluginId: "opencode-bridge", version: PLUGIN_VERSION, assumption: "1 project = 1 opencode serve instance", sessionKeyConvention: "hook:opencode:<agentId>:<taskId>", lifecycleStates: ["queued", "server_ready", "session_created", "prompt_sent", "running", "awaiting_permission", "stalled", "failed", "completed"], requiredEnvelopeFields: ["task_id", "run_id", "agent_id", "requested_agent_id", "resolved_agent_id", "session_key", "origin_session_key", "callback_target_session_key", "project_id", "repo_root", "opencode_server_url"], callbackPrimary: "/hooks/agent", callbackNotPrimary: ["/hooks/wake", "cron", "group:sessions"], config: { bridgeConfigPath: getBridgeConfigPath(), opencodeServerUrl: runtimeCfg.opencodeServerUrl || null, hookBaseUrl: runtimeCfg.hookBaseUrl || null, hookTokenPresent: Boolean(runtimeCfg.hookToken), projectRegistry: registry, executionAgentMappings: runtimeCfg.executionAgentMappings || [], stateDir: getBridgeStateDir(), runStateDir: getRunStateDir(), auditDir: getAuditDir() }, note: "Runtime-ops scaffold in progress. Plugin-owned config/state is stored under ~/.openclaw/opencode-bridge. New projects are auto-registered only when using opencode_serve_spawn (not by passive envelope build alone)." }, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify({ ok: true, pluginId: "opencode-bridge", version: PLUGIN_VERSION, assumption: "1 project = 1 opencode serve instance", sessionKeyConvention: "hook:opencode:<agentId>:<taskId>", lifecycleStates: ["queued", "server_ready", "session_created", "prompt_sent", "planning", "coding", "verifying", "blocked", "running", "awaiting_permission", "stalled", "failed", "completed"], requiredEnvelopeFields: ["task_id", "run_id", "agent_id", "requested_agent_id", "resolved_agent_id", "session_key", "origin_session_key", "callback_target_session_key", "project_id", "repo_root", "opencode_server_url"], primaryCallbackPath: "/hooks/agent", alternativeSignalPaths: ["/hooks/wake", "cron", "group:sessions"], config: { bridgeConfigPath: getBridgeConfigPath(), opencodeServerUrl: runtimeCfg.opencodeServerUrl || null, hookBaseUrl: runtimeCfg.hookBaseUrl || null, hookTokenPresent: Boolean(runtimeCfg.hookToken), projectRegistry: registry, executionAgentMappings: runtimeCfg.executionAgentMappings || [], stateDir: getBridgeStateDir(), runStateDir: getRunStateDir(), auditDir: getAuditDir() }, note: "Plugin-owned config/state is stored under ~/.openclaw/opencode-bridge. New projects are auto-registered only when using opencode_serve_spawn, not by passive envelope build alone." }, null, 2) }]
       };
     }
   }, { optional: true });
@@ -582,6 +953,100 @@ function registerOpenCodeBridgeTools(api, cfg) {
       return { content: [{ type: "text", text: JSON.stringify({ ok: true, checklist }, null, 2) }] };
     }
   }, { optional: true });
+  api.registerTool({
+    name: "opencode_execute_task",
+    label: "OpenCode Execute Task",
+    description: "Execution entrypoint: resolve/spawn serve, create session, send prompt async, start SSE-driven watcher, callback once v\u1EC1 /hooks/agent khi terminal.",
+    parameters: {
+      type: "object",
+      properties: {
+        taskId: { type: "string" },
+        runId: { type: "string" },
+        agentId: { type: "string", description: "Requester/origin agent id" },
+        executionAgentId: { type: "string" },
+        originSessionKey: { type: "string" },
+        originSessionId: { type: "string" },
+        projectId: { type: "string" },
+        repoRoot: { type: "string" },
+        prompt: { type: "string" },
+        objective: { type: "string" },
+        message: { type: "string" },
+        constraints: { type: "array", items: { type: "string" } },
+        acceptanceCriteria: { type: "array", items: { type: "string" } },
+        channel: { type: "string" },
+        to: { type: "string" },
+        deliver: { type: "boolean" },
+        priority: { type: "string" },
+        idleTimeoutMs: { type: "number" },
+        pollIntervalMs: { type: "number" },
+        maxWaitMs: { type: "number" }
+      },
+      required: ["taskId", "runId", "agentId", "originSessionKey", "projectId", "repoRoot"]
+    },
+    async execute(_id, params) {
+      const resolved = resolveExecutionAgent({
+        cfg,
+        requestedAgentId: asString(params?.agentId) || "",
+        explicitExecutionAgentId: asString(params?.executionAgentId)
+      });
+      if (!resolved.ok) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: JSON.stringify({ ok: false, error: resolved.error, requestedAgentId: resolved.requestedAgentId, mappingConfigured: resolved.mappingConfigured }, null, 2) }]
+        };
+      }
+      const spawned = await spawnServeForProject({
+        project_id: params.projectId,
+        repo_root: params.repoRoot,
+        idle_timeout_ms: asNumber(params.idleTimeoutMs)
+      });
+      const serverUrl = spawned.entry.opencode_server_url;
+      const envelope = buildEnvelope({
+        taskId: params.taskId,
+        runId: params.runId,
+        requestedAgentId: resolved.requestedAgentId,
+        resolvedAgentId: resolved.resolvedAgentId,
+        originSessionKey: params.originSessionKey,
+        originSessionId: asString(params.originSessionId),
+        projectId: params.projectId,
+        repoRoot: params.repoRoot,
+        serverUrl,
+        channel: params.channel,
+        to: params.to,
+        deliver: params.deliver,
+        priority: params.priority
+      });
+      const prompt = buildExecutionPrompt(params, envelope);
+      const execution = await startExecutionRun({
+        cfg,
+        envelope,
+        prompt,
+        pollIntervalMs: asNumber(params.pollIntervalMs),
+        maxWaitMs: asNumber(params.maxWaitMs)
+      });
+      const snapshot = listRunStatuses().find((item) => item.runId === params.runId) || null;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            ok: true,
+            spawned,
+            envelope,
+            prompt,
+            execution: {
+              ok: execution.ok,
+              runId: execution.runId,
+              taskId: execution.taskId,
+              sessionId: execution.sessionId,
+              state: execution.state,
+              watcherStarted: execution.watcherStarted
+            },
+            runStatus: snapshot
+          }, null, 2)
+        }]
+      };
+    }
+  }, { optional: true });
   api.registerTool({
     name: "opencode_evaluate_lifecycle",
     label: "OpenCode Evaluate Lifecycle",
@@ -641,11 +1106,11 @@ function registerOpenCodeBridgeTools(api, cfg) {
           timestamp: event.timestamp
         }))
       );
-      const state = lifecycleSummary.current_state || artifact?.state || (sessionId ? "running" : "queued");
+      const state = lifecycleSummary.currentState || artifact?.state || (sessionId ? "running" : "queued");
       const response = {
         ok: true,
         source: {
-          runStatusArtifact: Boolean(artifact),
+          runArtifact: Boolean(artifact),
           opencodeApi: true
         },
         runId: runId || void 0,
@@ -659,7 +1124,8 @@ function registerOpenCodeBridgeTools(api, cfg) {
           }
         },
         state,
-        current_state: lifecycleSummary.current_state || state,
+        currentState: lifecycleSummary.currentState || state,
+        current_state: lifecycleSummary.currentState || state,
         lastEvent: artifact?.lastEvent,
         last_event_kind: artifact?.lastEvent,
         lastSummary: artifact?.lastSummary,
@@ -915,7 +1381,7 @@ function registerOpenCodeBridgeTools(api, cfg) {
 }
 
 // src/index.ts
-var PLUGIN_VERSION2 = "0.1.1";
+var PLUGIN_VERSION2 = "0.1.3";
 var plugin = {
   id: "opencode-bridge",
   name: "OpenCode Bridge",
@@ -925,7 +1391,7 @@ var plugin = {
     registerOpenCodeBridgeTools(api, cfg);
   }
 };
-var index_default = plugin;
+var src_default = plugin;
 export {
-  index_default as default
+  src_default as default
 };

package/dist/{observability.d.ts → src/observability.d.ts}

@@ -68,6 +68,7 @@ declare function summarizeLifecycle(events?: Array<{
     completionSummary?: string | null;
     timestamp?: string;
 }>): {
+    currentState: "planning" | "coding" | "verifying" | "blocked" | "running" | "awaiting_permission" | "stalled" | "failed" | "completed" | null;
     current_state: "planning" | "coding" | "verifying" | "blocked" | "running" | "awaiting_permission" | "stalled" | "failed" | "completed" | null;
     last_event_kind: OpenCodeEventKind | null;
     last_event_at: string | null;

package/dist/{observability.js → src/observability.js}

@@ -6,7 +6,7 @@ import {
   resolveSessionId,
   summarizeLifecycle,
   unwrapGlobalPayload
-} from "./chunk-LCJRXKI3.js";
+} from "./chunk-OVQ5X54C.js";
 export {
   normalizeOpenCodeEvent,
   normalizeTypedEventV1,

package/dist/src/shared-contracts.d.ts

@@ -0,0 +1,33 @@
+type BridgeSessionTagFields = {
+    runId: string;
+    taskId: string;
+    requested: string;
+    resolved: string;
+    callbackSession: string;
+    callbackSessionId?: string;
+    projectId?: string;
+    repoRoot?: string;
+};
+type OpenCodePluginCallbackAuditRecord = {
+    phase?: string;
+    event_type?: string;
+    session_id?: string;
+    title?: string;
+    tags?: Record<string, string> | null;
+    dedupeKey?: string;
+    ok?: boolean;
+    status?: number;
+    reason?: string;
+    body?: string;
+    payload?: any;
+    raw?: any;
+    created_at: string;
+};
+declare function buildTaggedSessionTitle(fields: BridgeSessionTagFields): string;
+declare function parseTaggedSessionTitle(title?: string): Record<string, string> | null;
+declare function buildPluginCallbackDedupeKey(input: {
+    sessionId?: string;
+    runId?: string;
+}): string;
+
+export { type BridgeSessionTagFields, type OpenCodePluginCallbackAuditRecord, buildPluginCallbackDedupeKey, buildTaggedSessionTitle, parseTaggedSessionTitle };

package/dist/src/shared-contracts.js

@@ -0,0 +1,10 @@
+import {
+  buildPluginCallbackDedupeKey,
+  buildTaggedSessionTitle,
+  parseTaggedSessionTitle
+} from "./chunk-TDVN5AFB.js";
+export {
+  buildPluginCallbackDedupeKey,
+  buildTaggedSessionTitle,
+  parseTaggedSessionTitle
+};

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "opencode-bridge",
   "name": "OpenCode Bridge",
-  "description": "Bridge plugin scaffold for OpenClaw ↔ OpenCode orchestration.",
-  "version": "0.1.1",
+  "description": "Bridge plugin for OpenClaw ↔ OpenCode orchestration, execution routing, and callback observability.",
+  "version": "0.1.3",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,