@mrc2204/opencode-bridge 0.1.1 → 0.1.3

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

@@ -1,11 +1,15 @@
 import {
   normalizeTypedEventV1,
   parseSseFramesFromBuffer,
-  resolveSessionId
-} from "./chunk-6NIQKNRA.js";
+  resolveSessionId,
+  summarizeLifecycle
+} 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";
@@ -55,6 +59,7 @@ function getRuntimeConfig(cfg) {
   return {
     opencodeServerUrl: fileCfg.opencodeServerUrl || cfg?.opencodeServerUrl,
     projectRegistry: fileCfg.projectRegistry || cfg?.projectRegistry || [],
+    executionAgentMappings: fileCfg.executionAgentMappings || cfg?.executionAgentMappings || [],
     hookBaseUrl: fileCfg.hookBaseUrl || cfg?.hookBaseUrl,
     hookToken: fileCfg.hookToken || cfg?.hookToken
   };
@@ -94,13 +99,66 @@ function findRegistryEntry(cfg, projectId, repoRoot) {
   }
   return void 0;
 }
+function resolveExecutionAgent(input) {
+  const requestedAgentId = asString(input.requestedAgentId);
+  if (!requestedAgentId) {
+    return {
+      ok: false,
+      requestedAgentId: "",
+      mappingConfigured: false,
+      error: "requestedAgentId is required"
+    };
+  }
+  const explicitExecutionAgentId = asString(input.explicitExecutionAgentId);
+  if (explicitExecutionAgentId) {
+    return {
+      ok: true,
+      requestedAgentId,
+      resolvedAgentId: explicitExecutionAgentId,
+      strategy: "explicit_param"
+    };
+  }
+  const runtimeCfg = getRuntimeConfig(input.cfg);
+  const mappings = asArray(runtimeCfg.executionAgentMappings).map((x) => x && typeof x === "object" ? x : {}).map((x) => ({
+    requestedAgentId: asString(x.requestedAgentId),
+    executionAgentId: asString(x.executionAgentId)
+  })).filter((x) => x.requestedAgentId && x.executionAgentId);
+  if (mappings.length > 0) {
+    const matched = mappings.find((x) => x.requestedAgentId === requestedAgentId);
+    if (!matched) {
+      return {
+        ok: false,
+        requestedAgentId,
+        mappingConfigured: true,
+        error: `Execution agent mapping is configured but no mapping matched requestedAgentId=${requestedAgentId}`
+      };
+    }
+    return {
+      ok: true,
+      requestedAgentId,
+      resolvedAgentId: matched.executionAgentId,
+      strategy: "config_mapping"
+    };
+  }
+  return {
+    ok: true,
+    requestedAgentId,
+    resolvedAgentId: requestedAgentId,
+    strategy: "identity"
+  };
+}
 function buildEnvelope(input) {
   return {
     task_id: input.taskId,
     run_id: input.runId,
-    agent_id: input.agentId,
-    session_key: buildSessionKey(input.agentId, input.taskId),
+    agent_id: input.resolvedAgentId,
+    requested_agent_id: input.requestedAgentId,
+    resolved_agent_id: input.resolvedAgentId,
+    session_key: buildSessionKey(input.resolvedAgentId, input.taskId),
     origin_session_key: input.originSessionKey,
+    ...input.originSessionId ? { origin_session_id: input.originSessionId } : {},
+    callback_target_session_key: input.originSessionKey,
+    ...input.originSessionId ? { callback_target_session_id: input.originSessionId } : {},
     project_id: input.projectId,
     repo_root: input.repoRoot,
     opencode_server_url: input.serverUrl,
@@ -113,6 +171,7 @@ function buildEnvelope(input) {
 function mapEventToState(event) {
   switch (event) {
     case "task.started":
+      return "planning";
     case "task.progress":
       return "running";
     case "permission.requested":
@@ -127,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;
@@ -160,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");
 }
@@ -247,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"
   });
@@ -314,12 +456,20 @@ async function fetchJsonSafe(url) {
 }
 function resolveSessionForRun(input) {
   const artifactEnvelope = input.runStatus?.envelope;
+  const callbackTargetSessionId = typeof artifactEnvelope?.callback_target_session_id === "string" ? artifactEnvelope.callback_target_session_id : void 0;
+  const originSessionId = typeof artifactEnvelope?.origin_session_id === "string" ? artifactEnvelope.origin_session_id : void 0;
+  const callbackTargetSessionKey = typeof artifactEnvelope?.callback_target_session_key === "string" ? artifactEnvelope.callback_target_session_key : void 0;
+  const originSessionKey = typeof artifactEnvelope?.origin_session_key === "string" ? artifactEnvelope.origin_session_key : void 0;
+  const executionSessionKey = typeof artifactEnvelope?.session_key === "string" ? artifactEnvelope.session_key : void 0;
+  const artifactSessionId = callbackTargetSessionId || originSessionId || (typeof artifactEnvelope?.session_id === "string" ? artifactEnvelope.session_id : void 0) || (typeof artifactEnvelope?.sessionId === "string" ? artifactEnvelope.sessionId : void 0);
+  const artifactSessionKey = callbackTargetSessionKey || originSessionKey || executionSessionKey;
+  const hasCallerSessionKey = Boolean(callbackTargetSessionKey || originSessionKey);
   const resolved = resolveSessionId({
     explicitSessionId: input.sessionId,
-    runId: input.runId || input.runStatus?.runId,
-    taskId: input.runStatus?.taskId,
-    sessionKey: artifactEnvelope?.session_key,
-    artifactSessionId: (typeof artifactEnvelope?.session_id === "string" ? artifactEnvelope.session_id : void 0) || (typeof artifactEnvelope?.sessionId === "string" ? artifactEnvelope.sessionId : void 0),
+    runId: hasCallerSessionKey ? void 0 : input.runId || input.runStatus?.runId,
+    taskId: hasCallerSessionKey ? void 0 : input.runStatus?.taskId,
+    sessionKey: artifactSessionKey,
+    artifactSessionId,
     sessionList: input.sessionList
   });
   return { sessionId: resolved.sessionId, strategy: resolved.strategy, ...resolved.score !== void 0 ? { score: resolved.score } : {} };
@@ -355,6 +505,11 @@ async function collectSseEvents(serverUrl, scope, options) {
           data: typed.payload,
           normalizedKind: typed.kind,
           summary: typed.summary,
+          lifecycle_state: typed.lifecycleState,
+          files_changed: typed.filesChanged,
+          verify_summary: typed.verifySummary,
+          blockers: typed.blockers,
+          completion_summary: typed.completionSummary,
           runId: typed.runId || options?.runIdHint,
           taskId: typed.taskId || options?.taskIdHint,
           sessionId: typed.sessionId || options?.sessionIdHint,
@@ -377,6 +532,11 @@ async function collectSseEvents(serverUrl, scope, options) {
           data: typed.payload,
           normalizedKind: typed.kind,
           summary: typed.summary,
+          lifecycle_state: typed.lifecycleState,
+          files_changed: typed.filesChanged,
+          verify_summary: typed.verifySummary,
+          blockers: typed.blockers,
+          completion_summary: typed.completionSummary,
           runId: typed.runId || options?.runIdHint,
           taskId: typed.taskId || options?.taskIdHint,
           sessionId: typed.sessionId || options?.sessionIdHint,
@@ -401,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,
@@ -424,10 +850,30 @@ function buildHookPolicyChecklist(agentId, sessionKey) {
 }
 
 // src/registrar.ts
+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",
@@ -437,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: "0.1.0", 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", "session_key", "origin_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, 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 });
@@ -455,7 +901,7 @@ function registerOpenCodeBridgeTools(api, cfg) {
     name: "opencode_build_envelope",
     label: "OpenCode Build Envelope",
     description: "D\u1EF1ng routing envelope chu\u1EA9n cho task delegate sang OpenCode v\u1EDBi sessionKey convention hook:opencode:<agentId>:<taskId>.",
-    parameters: { type: "object", properties: { taskId: { type: "string" }, runId: { type: "string" }, agentId: { type: "string" }, originSessionKey: { type: "string" }, projectId: { type: "string" }, repoRoot: { type: "string" }, channel: { type: "string" }, to: { type: "string" }, deliver: { type: "boolean" }, priority: { type: "string" } }, required: ["taskId", "runId", "agentId", "originSessionKey", "projectId", "repoRoot"] },
+    parameters: { type: "object", properties: { taskId: { type: "string" }, runId: { type: "string" }, agentId: { type: "string", description: "Requester/origin agent id" }, executionAgentId: { type: "string", description: "Optional explicit OpenCode execution agent id" }, originSessionKey: { type: "string" }, originSessionId: { type: "string" }, projectId: { type: "string" }, repoRoot: { type: "string" }, channel: { type: "string" }, to: { type: "string" }, deliver: { type: "boolean" }, priority: { type: "string" } }, required: ["taskId", "runId", "agentId", "originSessionKey", "projectId", "repoRoot"] },
     async execute(_id, params) {
       const entry = findRegistryEntry(cfg, params?.projectId, params?.repoRoot);
       const serverUrl = entry?.serverUrl;
@@ -465,11 +911,25 @@ function registerOpenCodeBridgeTools(api, cfg) {
           content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Missing project registry mapping. Use opencode_serve_spawn for the project or add a matching projectRegistry entry in ~/.openclaw/opencode-bridge/config.json first." }, null, 2) }]
         };
       }
+      const requestedAgentId = asString(params?.agentId);
+      const resolved = resolveExecutionAgent({
+        cfg,
+        requestedAgentId: requestedAgentId || "",
+        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 envelope = buildEnvelope({
         taskId: params.taskId,
         runId: params.runId,
-        agentId: params.agentId,
+        requestedAgentId: resolved.requestedAgentId,
+        resolvedAgentId: resolved.resolvedAgentId,
         originSessionKey: params.originSessionKey,
+        originSessionId: asString(params.originSessionId),
         projectId: params.projectId,
         repoRoot: params.repoRoot,
         serverUrl,
@@ -479,7 +939,7 @@ function registerOpenCodeBridgeTools(api, cfg) {
         priority: params.priority
       });
       return {
-        content: [{ type: "text", text: JSON.stringify({ ok: true, envelope, registryMatch: entry || null }, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify({ ok: true, envelope, agentResolution: resolved, registryMatch: entry || null }, null, 2) }]
       };
     }
   }, { optional: true });
@@ -493,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",
@@ -532,11 +1086,31 @@ function registerOpenCodeBridgeTools(api, cfg) {
         runId
       });
       const sessionId = resolution.sessionId;
-      const state = artifact?.state || (sessionId ? "running" : "queued");
+      const eventScope = sessionId ? "session" : "global";
+      const events = await collectSseEvents(serverUrl, eventScope, {
+        limit: DEFAULT_EVENT_LIMIT,
+        timeoutMs: DEFAULT_OBS_TIMEOUT_MS,
+        runIdHint: runId,
+        taskIdHint: artifact?.taskId,
+        sessionIdHint: sessionId
+      });
+      const lifecycleSummary = 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
+        }))
+      );
+      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,
@@ -550,8 +1124,16 @@ function registerOpenCodeBridgeTools(api, cfg) {
           }
         },
         state,
+        currentState: lifecycleSummary.currentState || state,
+        current_state: lifecycleSummary.currentState || state,
         lastEvent: artifact?.lastEvent,
+        last_event_kind: artifact?.lastEvent,
         lastSummary: artifact?.lastSummary,
+        last_event_at: artifact?.updatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+        files_changed: lifecycleSummary.files_changed,
+        verify_summary: lifecycleSummary.verify_summary,
+        blockers: lifecycleSummary.blockers,
+        completion_summary: lifecycleSummary.completion_summary || artifact?.lastSummary || null,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         timestamps: {
           ...artifact?.updatedAt ? { artifactUpdatedAt: artifact.updatedAt } : {},
@@ -799,16 +1381,17 @@ function registerOpenCodeBridgeTools(api, cfg) {
 }
 
 // src/index.ts
+var PLUGIN_VERSION2 = "0.1.3";
 var plugin = {
   id: "opencode-bridge",
   name: "OpenCode Bridge",
-  version: "0.1.0",
+  version: PLUGIN_VERSION2,
   register(api) {
     const cfg = api?.pluginConfig || {};
     registerOpenCodeBridgeTools(api, cfg);
   }
 };
-var index_default = plugin;
+var src_default = plugin;
 export {
-  index_default as default
+  src_default as default
 };