@rzx/ohs 1.2.24 → 1.2.25

package/dist/frontend/index.js

@@ -338,6 +338,23 @@ var init_validation = __esm(() => {
 });
 
 // ../../packages/domain-contracts/src/inputs/metadata.ts
+function assertPromptMetadataAllowed(input) {
+  for (const namespace of ["metadata", "runMetadata"]) {
+    const metadata = input[namespace];
+    if (!metadata || typeof metadata !== "object")
+      continue;
+    if (Object.hasOwn(metadata, "outputSchema")) {
+      const field = `${namespace}.outputSchema`;
+      throw new DomainValidationError(`${field} is a stored snapshot; use explicit outputSchema`, field);
+    }
+    for (const name of ["pluginUi", "uiAction", "pluginUiSubmission", "pluginAppAction", "pluginAppSubmission", "pluginAppSource"]) {
+      if (Object.hasOwn(metadata, name)) {
+        const field = `${namespace}.${name}`;
+        throw new DomainValidationError(`${field} is reserved for the host`, field);
+      }
+    }
+  }
+}
 var init_metadata = __esm(() => {
   init_validation_error();
 });
@@ -650,11 +667,43 @@ function decodeClearedSessionWorktreeBinding(value, expectedSessionId) {
   }
   return session;
 }
+function decodeJobTarget(value) {
+  const target = object(value, "jobTarget");
+  const kind = enumField(target, "kind", "jobTarget", ["terminal", "shell", "agent", "dream", "workflow"]);
+  if (!stringField(target, "jobId", "jobTarget").trim())
+    throw new ProtocolDataError("jobTarget.jobId is required", "jobTarget.jobId");
+  if (kind === "agent" && !stringField(target, "runId", "jobTarget").trim())
+    throw new ProtocolDataError("jobTarget.runId is required", "jobTarget.runId");
+  return target;
+}
+function decodeJobInputReceipt(value) {
+  const receipt = object(value, "jobInputReceipt");
+  for (const field of ["sessionId", "inputId", "runId"]) {
+    if (!stringField(receipt, field, "jobInputReceipt").trim())
+      throw new ProtocolDataError(`jobInputReceipt.${field} is required`, `jobInputReceipt.${field}`);
+  }
+  return receipt;
+}
+function decodeJobListResult(value) {
+  const result = object(value, "jobListResult");
+  if (!Array.isArray(result.jobs) || !Array.isArray(result.errors))
+    throw new ProtocolDataError("Jobs list requires jobs and errors arrays", "jobListResult");
+  result.jobs.forEach(decodeJobSnapshot);
+  for (const error of result.errors) {
+    const item = object(error, "jobListResult.errors");
+    enumField(item, "kind", "jobListResult.errors", ["terminal", "shell", "agent", "dream", "workflow"]);
+    stringField(item, "message", "jobListResult.errors");
+  }
+  return result;
+}
 function decodeJobSnapshot(value) {
   const job = object(value, "job");
   for (const field of ["id", "label", "ownerSession", "cwd"])
     stringField(job, field, "job");
   enumField(job, "kind", "job", ["terminal", "shell", "agent", "dream", "workflow"]);
+  const target = decodeJobTarget(job.target);
+  if (target.kind !== job.kind || target.jobId !== job.id)
+    throw new ProtocolDataError("job target does not match snapshot", "job.target");
   enumField(job, "status", "job", ["running", "stopping", "completed", "killed", "failed"]);
   const capabilities = recordField(job, "capabilities", "job");
   for (const field of ["read", "wait", "send", "cancel"]) {
@@ -1100,6 +1149,18 @@ var init_plugin_apps2 = __esm(() => {
 });
 
 // ../../packages/protocol/src/requests/requests.ts
+function assertPromptMetadataAllowed2(input) {
+  adaptDomainInput(() => assertPromptMetadataAllowed(input));
+}
+function adaptDomainInput(read) {
+  try {
+    return read();
+  } catch (error) {
+    if (error instanceof DomainValidationError)
+      throw new ProtocolValidationError(error.message, error.field, error.reason);
+    throw error;
+  }
+}
 var ProtocolValidationError;
 var init_requests = __esm(() => {
   init_inputs();
@@ -1359,7 +1420,7 @@ function parseAttachmentTransferCapabilities(value) {
     uploadModes
   };
 }
-var CURRENT_PROTOCOL_VERSION = 5, PROTOCOL_VERSION_HEADER = "x-vykor-protocol-version";
+var CURRENT_PROTOCOL_VERSION = 7, PROTOCOL_VERSION_HEADER = "x-vykor-protocol-version";
 var init_capabilities = __esm(() => {
   init_attachment();
 });
@@ -1629,9 +1690,13 @@ var init_plugin_ui_history = __esm(() => {
   init_domain_validation();
 });
 
+// ../../packages/agent-contracts/src/tools/result-text.ts
+var init_result_text = () => {};
+
 // ../../packages/agent-contracts/src/tools/tool-data.ts
 var MCP_CALL_RESULT_MAX_BYTES;
 var init_tool_data = __esm(() => {
+  init_result_text();
   MCP_CALL_RESULT_MAX_BYTES = 1024 * 1024;
 });
 
@@ -2690,6 +2755,15 @@ class SessionResource {
   constructor(transport) {
     this.transport = transport;
   }
+  async checkOutputSchema(input, signal) {
+    assertPromptMetadataAllowed2(input);
+    if (input.outputSchema === undefined)
+      return;
+    const capabilities = await this.transport.ensureProtocol(signal);
+    if ((capabilities.features.structuredDelivery ?? 0) < 1) {
+      throw new Error("Server does not support structured delivery (outputSchema)");
+    }
+  }
   async search(options) {
     const { signal, ...query } = options;
     const response = await this.transport.request(this.transport.path("/sessions/search", query), { signal });
@@ -2769,6 +2843,7 @@ class SessionResource {
     return response.part;
   }
   async admitPrompt(sessionId, input, options = {}) {
+    await this.checkOutputSchema(input, options.signal);
     return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts`, {
       method: "POST",
       body: { ...input, id: input.id ?? createPromptRequestId() },
@@ -2776,6 +2851,7 @@ class SessionResource {
     });
   }
   async editLatestPrompt(sessionId, input, options = {}) {
+    await this.checkOutputSchema(input, options.signal);
     return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/latest/edit`, {
       method: "POST",
       body: input,
@@ -2789,6 +2865,7 @@ class SessionResource {
     return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/${encodeURIComponent(inputId)}/cancel`, { method: "POST", body: input, signal: options.signal });
   }
   async resumeInterruptedRun(sessionId, runId, input = {}, options = {}) {
+    await this.checkOutputSchema(input, options.signal);
     return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/runs/${encodeURIComponent(runId)}/resume`, {
       method: "POST",
       body: { ...input, id: input.id ?? createPromptRequestId() },
@@ -3030,7 +3107,7 @@ class JobResource {
       ...statuses ? { statuses: statuses.join(",") } : {},
       ...includeFinished !== undefined ? { includeFinished: String(includeFinished) } : {}
     }), { signal });
-    return responseArray(response, "jobs", decodeJobSnapshot);
+    return decodeJobListResult(response);
   }
   async createBackgroundShell(input, options = {}) {
     return await this.transport.request("/background-shells", {
@@ -3039,28 +3116,32 @@ class JobResource {
       signal: options.signal
     });
   }
-  async read(jobId, options) {
+  async read(target, options) {
     const { signal, ...query } = options;
-    const response = await this.transport.request(this.transport.path(`/jobs/${encodeURIComponent(jobId)}`, query), { signal });
+    const response = await this.transport.request(this.transport.path(`/jobs/${encodeURIComponent(target.jobId)}`, { ...query, kind: target.kind, ...target.kind === "agent" ? { runId: target.runId } : {} }), { signal });
     return decodeJobReadResult(response);
   }
-  async wait(jobId, input, options = {}) {
-    const response = await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/wait`, {
+  async wait(target, input, options = {}) {
+    const response = await this.transport.request(`/jobs/${encodeURIComponent(target.jobId)}/wait`, {
       method: "POST",
-      body: input,
+      body: { ...input, target },
       signal: options.signal
     });
     return decodeJobWaitResult(response);
   }
-  async send(jobId, input, options = {}) {
-    await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/input`, {
+  async send(target, input, options = {}) {
+    const response = await this.transport.request(`/jobs/${encodeURIComponent(target.jobId)}/input`, {
       method: "POST",
-      body: input,
+      body: { ...input, target },
       signal: options.signal
     });
+    if (responseField(response, "sent") !== true)
+      throw new ProtocolDataError("Job input was not accepted", "sent");
+    const receipt = response.receipt;
+    return receipt === undefined ? undefined : decodeJobInputReceipt(receipt);
   }
-  async cancel(jobId, input, options = {}) {
-    const response = await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/cancel`, { method: "POST", body: input, signal: options.signal });
+  async cancel(target, input, options = {}) {
+    const response = await this.transport.request(`/jobs/${encodeURIComponent(target.jobId)}/cancel`, { method: "POST", body: { ...input, target }, signal: options.signal });
     return decodeJobSnapshot(responseField(response, "snapshot"));
   }
 }
@@ -3879,43 +3960,162 @@ var init_session_stream_state = __esm(() => {
 });
 
 // ../../packages/client/src/state/sync.ts
-var init_sync = () => {};
+async function* runEventSync(client, options, initialState = createInitialClientState(), onLiveEvent) {
+  let state = initialState;
+  let cursor = Math.max(0, options.cursor ?? 0, state.lastSeq);
+  let attempt = 0;
+  const signal = options.signal;
+  const delayMs = options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+  const reduce = options.sessionId ? applySessionStreamEvent : options.globalReducer ?? applyEvent;
+  if (signal?.aborted)
+    return;
+  const refreshSession = async (initial) => {
+    const snapshot = await client.sessions.getState(options.sessionId, {
+      signal,
+      partView: options.partView
+    });
+    if (signal?.aborted)
+      return;
+    const next = initial ? applySessionSnapshot(state, snapshot) : applySessionStreamSnapshot(state, snapshot);
+    state = Object.keys(next.eventsBySeq).length ? { ...next, eventsBySeq: {} } : next;
+    cursor = Math.max(cursor, snapshot.cursor, state.lastSeq);
+  };
+  try {
+    if (options.sessionId) {
+      await refreshSession(true);
+    } else {
+      const replay = await client.events.list({
+        cursor: options.cursor,
+        partView: options.partView,
+        signal
+      });
+      if (signal?.aborted)
+        return;
+      for (const event of replay) {
+        if (signal?.aborted)
+          return;
+        state = reduce(state, event);
+        yield { event, state, source: "replay" };
+      }
+      cursor = Math.max(cursor, state.lastSeq);
+    }
+    if (signal?.aborted)
+      return;
+    yield { state, source: "snapshot" };
+    let needsSnapshot = false;
+    while (!signal?.aborted) {
+      try {
+        if (needsSnapshot) {
+          await refreshSession(false);
+          if (signal?.aborted)
+            return;
+          needsSnapshot = false;
+          yield { state, source: "snapshot" };
+        }
+        if (signal?.aborted)
+          return;
+        for await (const event of client.events.stream({
+          cursor,
+          sessionId: options.sessionId,
+          signal,
+          partView: options.partView,
+          transportReconnect: false,
+          idleTimeoutMs: options.idleTimeoutMs
+        })) {
+          if (signal?.aborted)
+            return;
+          onLiveEvent?.();
+          if (signal?.aborted)
+            return;
+          attempt = 0;
+          if (event.seq > cursor + 1 && !options.sessionId) {
+            const gap = await client.events.list({ cursor, partView: options.partView, signal });
+            if (signal?.aborted)
+              return;
+            for (const missed of gap) {
+              if (signal?.aborted)
+                return;
+              const before = state;
+              state = reduce(state, missed);
+              if (state !== before)
+                yield { event: missed, state, source: "replay" };
+            }
+            cursor = Math.max(cursor, state.lastSeq);
+          }
+          if (signal?.aborted)
+            return;
+          const before = state;
+          state = reduce(state, event);
+          cursor = Math.max(cursor, state.lastSeq);
+          if (state !== before)
+            yield { event, state, source: "live" };
+        }
+      } catch (error) {
+        if (error instanceof UnsupportedSessionEventSchemaVersionError)
+          throw error;
+        if (isAbortError(error) || signal?.aborted)
+          return;
+      }
+      if (signal?.aborted)
+        return;
+      needsSnapshot = Boolean(options.sessionId);
+      yield { state, source: "reconnecting" };
+      if (!await waitForReconnect2(delayMs(attempt), signal))
+        return;
+      attempt += 1;
+    }
+  } catch (error) {
+    if (!isAbortError(error) && !signal?.aborted)
+      throw error;
+  }
+}
+async function waitForReconnect2(ms, signal) {
+  if (signal?.aborted)
+    return false;
+  if (ms <= 0)
+    return true;
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve(false);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(!signal?.aborted);
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function isAbortError(error) {
+  return Boolean(error && typeof error === "object" && "name" in error && error.name === "AbortError");
+}
+var DEFAULT_RECONNECT_DELAY_MS = (attempt) => Math.min(30000, 250 * 2 ** Math.max(0, attempt));
+var init_sync = __esm(() => {
+  init_reducer();
+  init_session_stream_state();
+});
 
 // ../../packages/client/src/state/session-sync-controller.ts
 class SessionSyncController {
-  client;
-  sessionId;
+  options;
   initialCursor;
   generation;
-  externalSignal;
-  reconnectDelayMs;
-  onUpdate;
-  onStatusChange;
-  onError;
   abortController = new AbortController;
   state;
   status = "idle";
   running = false;
   constructor(options) {
-    this.client = options.client;
-    this.sessionId = options.sessionId;
+    this.options = { ...options };
     this.state = options.initialState ?? createInitialClientState();
     if ((options.cursor ?? 0) > 0 && !options.initialState) {
       throw new Error("A non-zero cursor requires initialState so durable state is not skipped");
     }
     this.initialCursor = Math.max(0, options.cursor ?? 0, this.state.lastSeq);
     this.generation = options.generation ?? 0;
-    this.externalSignal = options.signal;
-    this.reconnectDelayMs = options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
-    this.onUpdate = options.onUpdate;
-    this.onStatusChange = options.onStatusChange;
-    this.onError = options.onError;
-    if (this.externalSignal) {
-      if (this.externalSignal.aborted) {
-        this.abortController.abort(this.externalSignal.reason);
-      } else {
-        this.externalSignal.addEventListener("abort", () => this.abortController.abort(this.externalSignal?.reason), { once: true });
-      }
+    if (options.signal?.aborted) {
+      this.abortController.abort(options.signal.reason);
+    } else {
+      options.signal?.addEventListener("abort", () => this.abort(options.signal?.reason), { once: true });
     }
   }
   get currentStatus() {
@@ -3937,169 +4137,59 @@ class SessionSyncController {
     if (this.status === status)
       return;
     this.status = status;
-    this.onStatusChange?.(status, this.generation);
-  }
-  emitUpdate(update) {
-    if (this.abortController.signal.aborted)
-      return;
-    this.state = update.state;
-    this.onUpdate?.(update, this.generation);
+    this.options.onStatusChange?.(status, this.generation);
   }
   async start() {
     if (this.running)
       return;
-    this.running = true;
-    const signal = this.abortController.signal;
+    const signal = this.signal;
     if (signal.aborted) {
       this.setStatus("idle");
       return;
     }
-    let cursor = this.initialCursor;
-    let attempt = 0;
-    const refreshSession = async (sessionId) => {
-      const snapshot = await this.client.sessions.getState(sessionId, { signal });
-      if (signal.aborted)
-        return;
-      const next = this.status === "connecting" ? applySessionSnapshot(this.state, snapshot) : applySessionStreamSnapshot(this.state, snapshot);
-      this.state = Object.keys(next.eventsBySeq).length ? { ...next, eventsBySeq: {} } : next;
-      cursor = Math.max(cursor, snapshot.cursor, this.state.lastSeq);
-      this.setStatus("connected");
-      this.emitUpdate({ state: this.state, source: "snapshot" });
-    };
+    this.running = true;
     try {
       this.setStatus("connecting");
-      if (this.sessionId) {
-        await refreshSession(this.sessionId);
-      } else {
-        const replay = await this.client.events.list({
-          cursor,
-          sessionId: this.sessionId,
-          signal
-        });
+      for await (const update of runEventSync(this.options.client, {
+        sessionId: this.options.sessionId,
+        cursor: this.initialCursor,
+        signal,
+        reconnectDelayMs: this.options.reconnectDelayMs
+      }, this.state, () => this.setStatus("connected"))) {
         if (signal.aborted)
           return;
-        for (const event of replay) {
-          this.state = applyEvent(this.state, event);
-          this.emitUpdate({ event, state: this.state, source: "replay" });
-        }
-        cursor = Math.max(cursor, this.state.lastSeq);
-        this.setStatus("connected");
-      }
-      while (!signal.aborted) {
-        try {
-          if (this.sessionId && attempt > 0) {
-            await refreshSession(this.sessionId);
-            if (signal.aborted)
-              return;
-          }
-          for await (const event of this.client.events.stream({
-            cursor,
-            sessionId: this.sessionId,
-            signal,
-            transportReconnect: false
-          })) {
-            if (signal.aborted)
-              return;
-            attempt = 0;
-            this.setStatus("connected");
-            if (event.seq > cursor + 1 && !this.sessionId) {
-              const gap = await this.client.events.list({
-                cursor,
-                sessionId: this.sessionId,
-                signal
-              });
-              if (signal.aborted)
-                return;
-              for (const missed of gap) {
-                const beforeGap = this.state;
-                this.state = applyEvent(this.state, missed);
-                if (this.state !== beforeGap) {
-                  this.emitUpdate({ event: missed, state: this.state, source: "replay" });
-                }
-              }
-              cursor = Math.max(cursor, this.state.lastSeq);
-            }
-            const before = this.state;
-            this.state = this.sessionId ? applySessionStreamEvent(this.state, event) : applyEvent(this.state, event);
-            cursor = Math.max(cursor, this.state.lastSeq);
-            if (this.state !== before) {
-              this.emitUpdate({ event, state: this.state, source: "live" });
-            }
-          }
-          if (signal.aborted)
-            return;
-          this.setStatus("reconnecting");
-          this.emitUpdate({ state: this.state, source: "reconnecting" });
-          const delay = this.reconnectDelayMs(attempt);
-          attempt += 1;
-          cursor = this.state.lastSeq;
-          if (!await this.waitForDelay(delay, signal))
-            return;
-        } catch (error) {
-          if (error instanceof UnsupportedSessionEventSchemaVersionError) {
-            throw error;
-          }
-          if (this.isAbortError(error) || signal.aborted)
-            return;
+        this.state = update.state;
+        if (update.source === "reconnecting")
           this.setStatus("reconnecting");
-          this.emitUpdate({ state: this.state, source: "reconnecting" });
-          const delay = this.reconnectDelayMs(attempt);
-          attempt += 1;
-          cursor = this.state.lastSeq;
-          if (!await this.waitForDelay(delay, signal))
-            return;
-        }
+        else if (update.source !== "replay")
+          this.setStatus("connected");
+        if (signal.aborted)
+          return;
+        if (update.source === "snapshot" && !this.options.sessionId)
+          continue;
+        this.options.onUpdate?.(update, this.generation);
       }
     } catch (error) {
-      if (!this.isAbortError(error) && !signal.aborted) {
+      if (!signal.aborted && !(error instanceof Error && error.name === "AbortError")) {
         this.setStatus("error");
-        this.onError?.(error, this.generation);
+        this.options.onError?.(error, this.generation);
       }
     } finally {
       this.running = false;
-      if (signal.aborted && this.status !== "error") {
+      if (signal.aborted && this.status !== "error")
         this.setStatus("idle");
-      }
     }
   }
-  isAbortError(error) {
-    if (!error || typeof error !== "object")
-      return false;
-    if ("name" in error && error.name === "AbortError")
-      return true;
-    return false;
-  }
-  waitForDelay(ms, signal) {
-    if (ms <= 0)
-      return Promise.resolve(!signal.aborted);
-    return new Promise((resolve) => {
-      if (signal.aborted) {
-        resolve(false);
-        return;
-      }
-      const timer = setTimeout(() => {
-        signal.removeEventListener("abort", onAbort);
-        resolve(!signal.aborted);
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        resolve(false);
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
-    });
-  }
 }
-var DEFAULT_RECONNECT_DELAY_MS = (attempt) => Math.min(30000, 250 * 2 ** Math.max(0, attempt));
 var init_session_sync_controller = __esm(() => {
   init_reducer();
-  init_session_stream_state();
+  init_sync();
 });
 
 // ../../packages/client/src/state/index.ts
 var init_state = __esm(() => {
   init_reducer();
   init_selectors();
-  init_sync();
   init_session_sync_controller();
 });
 
@@ -4158,12 +4248,12 @@ async function handleDiagnosticCommand(slash, host, emit, readPresentation) {
     const estimatedTokens = Math.max(1, Math.ceil(text.length / 4));
     const [memory, jobsResult, settings] = await Promise.all([
       client.system.listMemory({ cwd }).catch(() => ({ entries: [] })),
-      client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
+      client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((listed) => ({ jobs: listed.jobs, errors: listed.errors })).catch((error) => ({
         error: error instanceof Error ? error.message : String(error)
       })),
       client.system.getSettings().catch(() => ({}))
     ]);
-    const jobsSummary = "jobs" in jobsResult ? String(jobsResult.jobs.length) : `unavailable (${jobsResult.error})`;
+    const jobsSummary = "jobs" in jobsResult ? `${jobsResult.jobs.length}${"errors" in jobsResult && jobsResult.errors.length ? ` (${jobsResult.errors.map((error) => `${error.kind}: ${error.message}`).join("; ")})` : ""}` : `unavailable (${jobsResult.error})`;
     emit([
       "Session stats:",
       `- messages: ${messageCount}`,
@@ -4178,20 +4268,22 @@ async function handleDiagnosticCommand(slash, host, emit, readPresentation) {
   if (slash.name === "/agents") {
     if (!sessionId)
       return "handled";
-    const agents = await client.jobs.list({
+    const listed = await client.jobs.list({
       sessionId,
       kinds: ["agent"],
       includeFinished: true,
       limit: 100
     });
-    if (agents.length === 0) {
+    const agents = listed.jobs;
+    if (agents.length === 0 && !listed.errors.length) {
       emit("No Agent Jobs.");
       return "handled";
     }
     emit([
       `Agent Jobs (${agents.length}):`,
       "",
-      ...agents.map((job) => `  ${job.id} [${job.status}] ${job.label}`)
+      ...agents.map((job) => `  ${job.id} [${job.status}] ${job.label}`),
+      ...listed.errors.map((error) => `${error.kind}: ${error.message}`)
     ].join(`
 `));
     return "handled";
@@ -4201,11 +4293,11 @@ async function handleDiagnosticCommand(slash, host, emit, readPresentation) {
     client.auth.getStatus().catch(() => null),
     client.system.listMemory({ cwd }).catch(() => ({ directory: "(unavailable)", entries: [] })),
     sessionId ? client.system.getSessionMcp(sessionId).catch(() => []) : Promise.resolve([]),
-    sessionId ? client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
+    sessionId ? client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((listed) => ({ jobs: listed.jobs, errors: listed.errors })).catch((error) => ({
       error: error instanceof Error ? error.message : String(error)
     })) : Promise.resolve({ jobs: [] })
   ]);
-  const jobsSummary = "jobs" in jobsResult ? String(jobsResult.jobs.length) : `unavailable (${jobsResult.error})`;
+  const jobsSummary = "jobs" in jobsResult ? `${jobsResult.jobs.length}${"errors" in jobsResult && jobsResult.errors.length ? ` (${jobsResult.errors.map((error) => `${error.kind}: ${error.message}`).join("; ")})` : ""}` : `unavailable (${jobsResult.error})`;
   const bucket = sessionId ? clientState.buckets[sessionId] : undefined;
   const diagnostics = await host.getRuntimeDiagnostics?.();
   const runtime = diagnostics?.runtime ?? "(not provided by this host)";
@@ -4300,41 +4392,44 @@ async function handleJobCommand(slash, host, emit, readPresentation) {
   if (!sessionId)
     return "handled";
   const args = slash.args.trim();
-  const [sub, id, ...extra] = args.split(/\s+/).filter(Boolean);
-  if ((!sub || sub === "list") && !id) {
+  const [sub, kind, id, runId, ...extra] = args.split(/\s+/).filter(Boolean);
+  if ((!sub || sub === "list") && !kind) {
     await readPresentation(`jobs:${sessionId}`, "Jobs", async () => {
-      const jobs = await client.jobs.list({
+      const listed = await client.jobs.list({
         sessionId,
         includeFinished: true,
         limit: 100
       });
-      if (jobs.length === 0)
+      const { jobs, errors } = listed;
+      if (jobs.length === 0 && errors.length === 0)
         return "No Jobs.";
       return [
         `Jobs (${jobs.length}):`,
         "",
-        ...jobs.map((job) => `  ${job.id} [${job.status}] ${job.kind}: ${job.label}`)
+        ...jobs.map((job) => `  ${job.id} [${job.status}] ${job.kind}: ${job.label}${job.target.kind === "agent" ? ` runId=${job.target.runId}` : ""}`),
+        ...errors.map((error) => `${error.kind}: ${error.message}`)
       ].join(`
 `);
     });
     return "handled";
   }
-  if (sub === "show" && id && extra.length === 0) {
+  const target = kind === "agent" && id && runId ? { kind, jobId: id, runId } : ["shell", "terminal", "workflow", "dream"].includes(kind ?? "") && id && !runId ? { kind, jobId: id } : undefined;
+  if (sub === "show" && target && extra.length === 0) {
     await readPresentation(`job:${sessionId}:${id}`, "Jobs", async () => {
-      const result = await client.jobs.read(id, { sessionId });
+      const result = await client.jobs.read(target, { sessionId });
       return formatJobReadResult(result);
     });
     return "handled";
   }
-  if (sub === "cancel" && id && extra.length === 0) {
-    const snapshot = await client.jobs.cancel(id, {
+  if (sub === "cancel" && target && extra.length === 0) {
+    const snapshot = await client.jobs.cancel(target, {
       sessionId,
       reason: "Cancelled from slash command"
     });
     emit(`Job ${snapshot.id} status: ${snapshot.status}.`);
     return "handled";
   }
-  emit("Usage: /jobs [list | show ID | cancel ID]");
+  emit("Usage: /jobs [list | show KIND ID [RUN_ID] | cancel KIND ID [RUN_ID]]");
   return "handled";
 }
 
@@ -5865,7 +5960,12 @@ async function executeTuiAction(action, ctx) {
             ctx.jobControlAbortRef.current = controller;
             let response;
             try {
-              response = await client.jobs.cancel(action.job_id, {
+              response = await client.jobs.cancel((() => {
+                const selected = ctx.jobStateRef.current.jobs.find((job) => job.id === action.job_id)?.target;
+                if (!selected)
+                  throw new Error("\u8BF7\u5148\u9009\u62E9\u4E00\u4E2A\u5F53\u524D\u4EFB\u52A1\u3002");
+                return selected;
+              })(), {
                 sessionId: currentSessionId,
                 reason: action.reason
               }, { signal: controller.signal });
@@ -5909,7 +6009,12 @@ async function executeTuiAction(action, ctx) {
             const controller = new AbortController;
             ctx.jobControlAbortRef.current = controller;
             try {
-              await client.jobs.send(action.job_id, {
+              await client.jobs.send((() => {
+                const selected = ctx.jobStateRef.current.jobs.find((job) => job.id === action.job_id)?.target;
+                if (!selected)
+                  throw new Error("\u8BF7\u5148\u9009\u62E9\u4E00\u4E2A\u5F53\u524D\u4EFB\u52A1\u3002");
+                return selected;
+              })(), {
                 sessionId: currentSessionId,
                 data: action.data
               }, { signal: controller.signal });
@@ -6142,9 +6247,9 @@ function useServerSync(config, onError) {
       });
       if (activeSessionIdRef.current !== sessionId || jobGenerationRef.current !== generation)
         return;
-      const validated = validateJobSnapshots(response, sessionId);
-      if (validated.error) {
-        const validationError = validated.error;
+      const validated = validateJobSnapshots(response.jobs, sessionId);
+      if (validated.error || response.errors.length) {
+        const validationError = validated.error ?? response.errors.map((error) => `${error.kind}: ${error.message}`).join("; ");
         const now = Date.now();
         setJobState((current) => {
           const next = validated.jobs.length > 0 ? {
@@ -6193,7 +6298,10 @@ function useServerSync(config, onError) {
     jobDetailStateRef.current = loading;
     setJobDetailState(loading);
     try {
-      const response = await client.jobs.read(jobId, {
+      const selected = jobStateRef.current.jobs.find((job) => job.id === jobId)?.target;
+      if (!selected)
+        throw new Error("\u8BF7\u5148\u9009\u62E9\u4E00\u4E2A\u5F53\u524D\u4EFB\u52A1\u3002");
+      const response = await client.jobs.read(selected, {
         sessionId,
         signal: controller.signal
       });
@@ -10446,4 +10554,4 @@ try {
   process.exit(1);
 }
 
-//# debugId=30CD0A6402EF364864756E2164756E21
+//# debugId=D9F985CEDC561F0364756E2164756E21