@linzumi/cli 0.0.71-beta → 0.0.73-beta

package/dist/index.js

@@ -1831,6 +1831,10 @@ function interruptQueuedMessages(queue, throughSeq) {
 }
 function fuseQueuedMessages(selected) {
   const last = selected[selected.length - 1];
+  const receivedAtMs = selected.reduce(
+    (earliest, message) => message.receivedAtMs === void 0 ? earliest : earliest === void 0 ? message.receivedAtMs : Math.min(earliest, message.receivedAtMs),
+    void 0
+  );
   if (last === void 0) {
     return void 0;
   }
@@ -1839,7 +1843,8 @@ function fuseQueuedMessages(selected) {
     actorSlug: "kandan",
     actorUserId: void 0,
     body: selected.map(codexInputForQueuedKandanMessage).join("\n\n---\n\n"),
-    attachments: selected.flatMap((message) => message.attachments)
+    attachments: selected.flatMap((message) => message.attachments),
+    receivedAtMs
   };
 }
 var init_kandanQueue = __esm({
@@ -4069,7 +4074,10 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
         interruptedActiveSeq,
         {
           status: "processed"
-        }
+        },
+        void 0,
+        void 0,
+        state.codexThreadId
       );
       break;
     case "starting":
@@ -4093,10 +4101,18 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
   });
   if (interrupted.ok) {
     for (const seq of interrupted.selectedSeqs) {
-      await publishMessageState(args, state.kandanThreadId, seq, {
-        status: "processing",
-        reason: "interrupt requested"
-      });
+      await publishMessageState(
+        args,
+        state.kandanThreadId,
+        seq,
+        {
+          status: "processing",
+          reason: "interrupt requested"
+        },
+        void 0,
+        void 0,
+        state.codexThreadId
+      );
     }
   }
   await drainKandanMessageQueue(args, state, payloadContext);
@@ -4365,6 +4381,9 @@ async function resolvePendingPortForwardRequest(args, state, payloadContext, con
   if (request === void 0) {
     return void 0;
   }
+  if (control.threadId !== void 0 && state.codexThreadId !== control.threadId) {
+    return void 0;
+  }
   if (!portForwardControlSenderAllowed(args, payloadContext, control)) {
     args.log("port_forward.request_resolution_ignored", {
       request_id: control.requestId,
@@ -4633,11 +4652,19 @@ async function publishPortForwardPrompt(args, state, payloadContext, candidate)
       allowedActorUserId: args.options.channelSession.listenUser.toLowerCase() === (payloadContext.runnerIdentity.actorUsername ?? "").toLowerCase() ? payloadContext.runnerIdentity.actorUserId : void 0
     }
   };
-  await publishMessageState(args, state.kandanThreadId, sourceSeq, {
-    status: "processing",
-    reason: "awaiting approval",
-    approval: state.activeProcessingState.approval
-  });
+  await publishMessageState(
+    args,
+    state.kandanThreadId,
+    sourceSeq,
+    {
+      status: "processing",
+      reason: "awaiting approval",
+      approval: state.activeProcessingState.approval
+    },
+    void 0,
+    void 0,
+    state.codexThreadId
+  );
   await publishForwardPortRequestedEvent(args, state, request, processIdentity);
   args.log("port_forward.request_pending", {
     request_id: requestId,
@@ -4826,7 +4853,10 @@ async function publishMessageStateForPortForwardResult(args, state, request, sta
               {
                 status: "processing",
                 reason: "running terminal command"
-              }
+              },
+              void 0,
+              void 0,
+              state.codexThreadId
             );
             return;
           }
@@ -4851,15 +4881,31 @@ async function publishMessageStateForPortForwardResult(args, state, request, sta
   }
   switch (status) {
     case "processed":
-      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
-        status: "processed"
-      });
+      await publishMessageState(
+        args,
+        state.kandanThreadId,
+        request.sourceSeq,
+        {
+          status: "processed"
+        },
+        void 0,
+        void 0,
+        state.codexThreadId
+      );
       break;
     case "failed":
-      await publishMessageState(args, state.kandanThreadId, request.sourceSeq, {
-        status: "failed",
-        reason: failedReason
-      });
+      await publishMessageState(
+        args,
+        state.kandanThreadId,
+        request.sourceSeq,
+        {
+          status: "failed",
+          reason: failedReason
+        },
+        void 0,
+        void 0,
+        state.codexThreadId
+      );
       break;
   }
 }
@@ -4873,6 +4919,10 @@ function parsePortForwardDecision(body) {
     requestId: match[2] ?? ""
   };
 }
+function runnerConsoleBodyPreview(body) {
+  const normalized = body.replace(/\s+/g, " ").trim();
+  return normalized.length <= 50 ? normalized : `${normalized.slice(0, 47)}...`;
+}
 async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext, event) {
   const session = args.options.channelSession;
   if (event.type !== "thread.message") {
@@ -4991,17 +5041,25 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
     });
     return;
   }
+  const receivedAtMs = Date.now();
   enqueuePendingKandanMessage(state.queue, {
     seq: event.seq,
     actorSlug: event.actorSlug,
     actorUserId: event.actorUserId,
     body: event.body,
-    attachments: event.attachments
+    attachments: event.attachments,
+    receivedAtMs
   });
   args.log("kandan.message_queued", {
     seq: event.seq,
     actor_slug: event.actorSlug ?? null,
     actor_user_id: event.actorUserId ?? null,
+    linzumi_thread_id: state.kandanThreadId ?? null,
+    codex_thread_id: state.codexThreadId ?? null,
+    runner_console: {
+      body_preview: runnerConsoleBodyPreview(event.body),
+      message_received_at_ms: receivedAtMs
+    },
     queue_depth: pendingKandanMessageQueueLength(state.queue)
   });
   await publishKandanMessageState(args, event, { status: "queued" });
@@ -5070,13 +5128,20 @@ async function startThreadMessageTurn(args, state, payloadContext, message) {
     actorSlug: message.actorSlug,
     actorUserId: message.actorUserId,
     body: message.body,
-    attachments: []
+    attachments: [],
+    receivedAtMs: Date.now()
   };
   enqueuePendingKandanMessage(state.queue, queued);
   args.log("kandan.message_queued", {
     seq: queued.seq,
     actor_slug: queued.actorSlug ?? null,
     actor_user_id: queued.actorUserId ?? null,
+    linzumi_thread_id: state.kandanThreadId ?? null,
+    codex_thread_id: state.codexThreadId ?? null,
+    runner_console: {
+      body_preview: runnerConsoleBodyPreview(queued.body),
+      message_received_at_ms: queued.receivedAtMs ?? Date.now()
+    },
     queue_depth: pendingKandanMessageQueueLength(state.queue)
   });
   await publishQueuedMessageState(args, state, queued, { status: "queued" });
@@ -5199,7 +5264,12 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
     queued_seq: next.seq,
     actor_slug: next.actorSlug ?? null,
     actor_user_id: next.actorUserId ?? null,
+    linzumi_thread_id: state.kandanThreadId ?? null,
     codex_thread_id: state.codexThreadId ?? null,
+    runner_console: {
+      body_preview: runnerConsoleBodyPreview(next.body),
+      message_received_at_ms: next.receivedAtMs ?? Date.now()
+    },
     queue_depth: pendingKandanMessageQueueLength(state.queue)
   });
   await publishQueuedMessageState(args, state, next, {
@@ -5239,9 +5309,17 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
       state.turn = { status: "idle" };
       clearActiveProcessingState(state, next.seq);
       if (state.kandanThreadId !== void 0) {
-        await publishMessageState(args, state.kandanThreadId, next.seq, {
-          status: "processed"
-        });
+        await publishMessageState(
+          args,
+          state.kandanThreadId,
+          next.seq,
+          {
+            status: "processed"
+          },
+          void 0,
+          void 0,
+          state.codexThreadId
+        );
       }
       await drainKandanMessageQueue(args, state, payloadContext);
     }
@@ -5257,7 +5335,7 @@ async function drainKandanMessageQueue(args, state, payloadContext) {
         state.codexThreadId = newCodexThreadId;
         await bindCurrentCodexThread(args, state);
         args.log("codex.thread_rebound", {
-          kandan_thread_id: state.kandanThreadId,
+          linzumi_thread_id: state.kandanThreadId,
           old_codex_thread_id: oldCodexThreadId ?? null,
           new_codex_thread_id: newCodexThreadId
         });
@@ -5917,7 +5995,12 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
           );
           break;
       }
-      logCompletedCodexOutput(args, params.turnId, params.output.message);
+      logCompletedCodexOutput(
+        args,
+        state,
+        params.turnId,
+        params.output.message
+      );
       break;
     }
     case "cached_reasoning": {
@@ -5939,7 +6022,7 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
         message.structured
       );
       forgetStreamingReasoningOutput(state, output.itemKey);
-      logCompletedCodexOutput(args, params.turnId, message);
+      logCompletedCodexOutput(args, state, params.turnId, message);
       break;
     }
     case "cached_command": {
@@ -5966,7 +6049,7 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
         message.structured
       );
       forgetStreamingCommandOutput(state, output.itemKey);
-      logCompletedCodexOutput(args, params.turnId, message);
+      logCompletedCodexOutput(args, state, params.turnId, message);
       break;
     }
     case "cached_file_change": {
@@ -5989,16 +6072,21 @@ async function postCompletedOutputProjection(args, state, payloadContext, params
         message.structured
       );
       forgetStreamingFileChangeOutput(state, output.itemKey);
-      logCompletedCodexOutput(args, params.turnId, message);
+      logCompletedCodexOutput(args, state, params.turnId, message);
       break;
     }
   }
 }
-function logCompletedCodexOutput(args, turnId, message) {
+function logCompletedCodexOutput(args, state, turnId, message) {
   args.log("kandan.codex_output_forwarded", {
     turn_id: turnId,
     item_key: message.itemKey,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     structured_kind: stringValue(message.structured.kind) ?? null,
+    runner_console: {
+      body_preview: runnerConsoleBodyPreview(message.body)
+    },
     command: stringValue(message.structured.command) ?? null,
     file_paths: fileChangePaths(message.structured)
   });
@@ -6232,6 +6320,8 @@ async function forwardAssistantDeltaPayload(args, state, delta, payloadContext)
   args.log("kandan.codex_delta_forwarded", {
     item_key: delta.itemKey,
     turn_id: delta.turnId ?? null,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     content_length: nextContent.length
   });
 }
@@ -6478,6 +6568,8 @@ async function forwardReasoningDeltaPayload(args, state, delta, payloadContext)
   args.log("kandan.codex_reasoning_delta_forwarded", {
     item_key: delta.itemKey,
     turn_id: turnId,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     content_length: nextContent.length
   });
 }
@@ -6666,6 +6758,8 @@ async function forwardCommandOutputDeltaPayload(args, state, delta, payloadConte
   args.log("kandan.codex_command_output_forwarded", {
     item_key: delta.itemKey,
     turn_id: turnId,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     process_id: delta.processId ?? null,
     stream: delta.stream,
     output_length: persistedOutput.length
@@ -6749,6 +6843,8 @@ async function forwardFileChangeDeltaPayload(args, state, delta, payloadContext)
   args.log("kandan.codex_file_change_forwarded", {
     item_key: delta.itemKey,
     turn_id: turnId,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     patch_length: patchText.length
   });
 }
@@ -6887,6 +6983,8 @@ async function forwardTerminalInput(args, state, params, payloadContext) {
   args.log("kandan.codex_output_forwarded", {
     turn_id: turnId,
     item_key: terminal.itemKey,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     structured_kind: "codex_terminal_input",
     command: null,
     file_paths: []
@@ -6974,6 +7072,8 @@ async function forwardWebSearchProgress(args, state, params, payloadContext) {
   args.log("kandan.codex_web_search_progress_forwarded", {
     turn_id: progress.turnId,
     item_key: progress.itemKey,
+    linzumi_thread_id: state.kandanThreadId,
+    codex_thread_id: state.codexThreadId,
     query_count: queries.length
   });
 }
@@ -7755,7 +7855,9 @@ async function stopCodexTyping(args, state) {
     {
       workspace: session.workspaceSlug,
       channel: session.channelSlug,
-      thread_id: state.kandanThreadId
+      thread_id: state.kandanThreadId,
+      instance_id: args.instanceId,
+      codex_thread_id: state.codexThreadId ?? null
     },
     args.log
   );
@@ -7774,7 +7876,9 @@ function startCodexTypingHeartbeat(args, state, threadId) {
       {
         workspace: session.workspaceSlug,
         channel: session.channelSlug,
-        thread_id: threadId
+        thread_id: threadId,
+        instance_id: args.instanceId,
+        codex_thread_id: state.codexThreadId ?? null
       },
       args.log
     ).then(() => refreshActiveProcessingHeartbeat(args, state)).catch((error) => {
@@ -7819,7 +7923,8 @@ async function publishQueuedMessageState(args, state, message, messageState) {
     message.seq,
     messageState,
     message.actorSlug,
-    message.actorUserId
+    message.actorUserId,
+    state.codexThreadId
   );
 }
 async function publishMessageState(args, threadId, seq, state, actorSlug, actorUserId, codexThreadId) {
@@ -7828,6 +7933,7 @@ async function publishMessageState(args, threadId, seq, state, actorSlug, actorU
     workspace: session.workspaceSlug,
     channel: session.channelSlug,
     thread_id: threadId,
+    instance_id: args.instanceId,
     ...codexThreadId === void 0 ? {} : { codex_thread_id: codexThreadId },
     seq,
     status: state.status,
@@ -7881,10 +7987,18 @@ async function failActiveCodexTurn(args, state, turnId, reason, payloadContext)
   }
   const seq = activeQueuedSeqForTurn(state.turn, turnId);
   if (seq !== void 0 && state.kandanThreadId !== void 0) {
-    await publishMessageState(args, state.kandanThreadId, seq, {
-      status: "failed",
-      reason
-    });
+    await publishMessageState(
+      args,
+      state.kandanThreadId,
+      seq,
+      {
+        status: "failed",
+        reason
+      },
+      void 0,
+      void 0,
+      state.codexThreadId
+    );
     clearActiveProcessingState(state, seq);
   }
   forgetLocalTuiTurnId(state, turnId);
@@ -7907,10 +8021,18 @@ async function refreshActiveProcessingState(args, state, turnId, reason) {
     return;
   }
   state.activeProcessingState = { seq, reason };
-  await publishMessageState(args, state.kandanThreadId, seq, {
-    status: "processing",
-    reason
-  });
+  await publishMessageState(
+    args,
+    state.kandanThreadId,
+    seq,
+    {
+      status: "processing",
+      reason
+    },
+    void 0,
+    void 0,
+    state.codexThreadId
+  );
 }
 async function refreshActiveProcessingHeartbeat(args, state) {
   const activeProcessingState = state.activeProcessingState;
@@ -8827,7 +8949,7 @@ function createRunnerLogger(logFile, consoleReporter) {
 `,
       "utf8"
     );
-    consoleReporter?.(event, redacted);
+    consoleReporter?.(event, runnerConsolePayload(redacted, payload));
   });
   Object.defineProperty(logger, "close", {
     value: () => closeStream(stream)
@@ -8882,12 +9004,19 @@ function redactObject(value) {
   const headerName = typeof value.name === "string" ? value.name.toLowerCase() : void 0;
   const shouldRedactHeaderValue = headerName === "authorization" || headerName === "cookie" || headerName === "set-cookie";
   return Object.fromEntries(
-    Object.entries(value).map(([key, entry]) => [
+    Object.entries(value).filter(([key]) => key !== "runner_console").map(([key, entry]) => [
       key,
       shouldRedactHeaderValue && key === "value" ? sensitiveMarker : redactValue(entry, key)
     ])
   );
 }
+function runnerConsolePayload(redacted, original) {
+  const consoleFields = objectValue2(original.runner_console);
+  return consoleFields === void 0 ? redacted : { ...redacted, ...redactForCliLog(consoleFields) };
+}
+function objectValue2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
 function redactArgs(args) {
   let redactNext = false;
   return args.map((arg) => {
@@ -9130,7 +9259,9 @@ var init_mcpConfig = __esm({
 });
 
 // src/codexAppServer.ts
-import { spawn } from "node:child_process";
+import {
+  spawn
+} from "node:child_process";
 import { createServer } from "node:net";
 async function chooseLoopbackPort() {
   return new Promise((resolve11, reject) => {
@@ -9158,6 +9289,7 @@ async function startCodexAppServer(codexBin, cwd, options = {}) {
   const port = await chooseLoopbackPort();
   const url = `ws://127.0.0.1:${port}`;
   const args = codexAppServerArgs(url, options);
+  const stdio = codexAppServerStdio(process.stdout.isTTY === true);
   writeCliAuditEvent("process.spawn", {
     command: codexBin,
     args,
@@ -9167,9 +9299,15 @@ async function startCodexAppServer(codexBin, cwd, options = {}) {
   const child = spawn(codexBin, args, {
     cwd,
     env: codexAppServerEnv(options.env),
-    stdio: ["ignore", "inherit", "inherit"],
+    stdio,
     detached: true
   });
+  if (stdio[1] === "pipe") {
+    drainCodexAppServerOutput(child, "stdout");
+  }
+  if (stdio[2] === "pipe") {
+    drainCodexAppServerOutput(child, "stderr");
+  }
   const stop = () => stopCodexAppServerProcess(child);
   writeCliAuditEvent("process.spawned", {
     command: codexBin,
@@ -9203,6 +9341,25 @@ async function startCodexAppServer(codexBin, cwd, options = {}) {
   }
   return { url, process: child, stop };
 }
+function codexAppServerStdio(stdoutIsTty) {
+  return stdoutIsTty ? ["ignore", "pipe", "pipe"] : ["ignore", "inherit", "inherit"];
+}
+function drainCodexAppServerOutput(child, streamName) {
+  const stream = child[streamName];
+  if (stream === null) {
+    return;
+  }
+  stream.on("data", (chunk) => {
+    const text2 = chunk.toString();
+    writeCliAuditEvent("process.output", {
+      pid: child.pid,
+      purpose: "codex.app_server",
+      stream: streamName,
+      chars: text2.length,
+      output: text2
+    });
+  });
+}
 function codexAppServerEnv(overrides) {
   const env = { ...process.env };
   for (const key of blockedCodexAppServerEnvKeys) {
@@ -9543,9 +9700,9 @@ function codexConfigWithTrustedProject(config, projectPath) {
 trust_level = "trusted"
 `;
   }
-  const table = config.slice(range.start, range.end);
+  const table2 = config.slice(range.start, range.end);
   const trustLine = /^(\s*trust_level\s*=\s*).*(\r?)$/m;
-  const nextTable = trustLine.test(table) ? table.replace(trustLine, '$1"trusted"$2') : `${trimTrailingNewlines(table)}
+  const nextTable = trustLine.test(table2) ? table2.replace(trustLine, '$1"trusted"$2') : `${trimTrailingNewlines(table2)}
 trust_level = "trusted"
 `;
   return `${config.slice(0, range.start)}${nextTable}${config.slice(range.end)}`;
@@ -9577,6 +9734,125 @@ var init_codexProjectTrust = __esm({
   }
 });
 
+// src/codexNotificationConsoleStats.ts
+function codexNotificationConsoleLogPayload(method, params) {
+  return {
+    method,
+    metadata: extractCodexIds(params),
+    ...codexNotificationConsoleStats(method, params)
+  };
+}
+function codexNotificationConsoleStats(method, params) {
+  switch (method) {
+    case "thread/tokenUsage/updated":
+      return {
+        token_usage_summary: tokenUsageSummary(params) ?? "seen (no details)"
+      };
+    case "account/rateLimits/updated":
+      return {
+        rate_limit_summary: rateLimitSummary(params) ?? "seen (no details)"
+      };
+    default:
+      return {};
+  }
+}
+function tokenUsageSummary(params) {
+  const usage = objectValue3(params.tokenUsage) ?? objectValue3(params.token_usage) ?? objectValue3(params.usage) ?? params;
+  const total = tokenUsageBreakdownSummary(objectValue3(usage.total)) ?? tokenUsageBreakdownSummary(objectValue3(usage.totalUsage)) ?? tokenUsageBreakdownSummary(objectValue3(usage.total_usage)) ?? tokenUsageBreakdownSummary(objectValue3(params.totalTokenUsage)) ?? tokenUsageBreakdownSummary(objectValue3(params.total_token_usage)) ?? tokenUsageBreakdownSummary(usage);
+  const last = tokenUsageBreakdownSummary(objectValue3(usage.last)) ?? tokenUsageBreakdownSummary(objectValue3(usage.lastUsage)) ?? tokenUsageBreakdownSummary(objectValue3(usage.last_usage)) ?? tokenUsageBreakdownSummary(objectValue3(params.lastTokenUsage)) ?? tokenUsageBreakdownSummary(objectValue3(params.last_token_usage));
+  const summary = [
+    total === void 0 ? void 0 : `total ${total}`,
+    last === void 0 ? void 0 : `last ${last}`
+  ].filter((value) => value !== void 0);
+  return summary.length === 0 ? void 0 : summary.join(" | ");
+}
+function tokenUsageBreakdownSummary(breakdown) {
+  if (breakdown === void 0) {
+    return void 0;
+  }
+  const inputDetails = objectValue3(breakdown.inputTokensDetails) ?? objectValue3(breakdown.input_tokens_details);
+  const outputDetails = objectValue3(breakdown.outputTokensDetails) ?? objectValue3(breakdown.output_tokens_details);
+  const input = integerValue2(breakdown.inputTokens) ?? integerValue2(breakdown.input_tokens) ?? integerValue2(breakdown.promptTokens) ?? integerValue2(breakdown.prompt_tokens);
+  const output = integerValue2(breakdown.outputTokens) ?? integerValue2(breakdown.output_tokens) ?? integerValue2(breakdown.completionTokens) ?? integerValue2(breakdown.completion_tokens);
+  const total = integerValue2(breakdown.totalTokens) ?? integerValue2(breakdown.total_tokens);
+  const cached = integerValue2(breakdown.cachedInputTokens) ?? integerValue2(breakdown.cached_input_tokens) ?? integerValue2(breakdown.cacheReadInputTokens) ?? integerValue2(breakdown.cache_read_input_tokens) ?? integerValue2(inputDetails?.cachedTokens) ?? integerValue2(inputDetails?.cached_tokens);
+  const reasoning = integerValue2(breakdown.reasoningOutputTokens) ?? integerValue2(breakdown.reasoning_output_tokens) ?? integerValue2(breakdown.reasoningTokens) ?? integerValue2(breakdown.reasoning_tokens) ?? integerValue2(outputDetails?.reasoningTokens) ?? integerValue2(outputDetails?.reasoning_tokens);
+  const values = [
+    input === void 0 ? void 0 : `${input} in`,
+    output === void 0 ? void 0 : `${output} out`,
+    total === void 0 ? void 0 : `${total} total`,
+    cached === void 0 ? void 0 : `${cached} cached`,
+    reasoning === void 0 ? void 0 : `${reasoning} reasoning`
+  ].filter((value) => value !== void 0);
+  return values.length === 0 ? void 0 : values.join(" / ");
+}
+function rateLimitSummary(params) {
+  const rateLimits = objectValue3(params.rateLimits) ?? objectValue3(params.rate_limits) ?? objectValue3(params.limits) ?? params;
+  const direct = rateLimitBucketSummary(rateLimits, void 0);
+  const children = Object.entries(rateLimits).flatMap(([name, value]) => {
+    const bucket = objectValue3(value);
+    return bucket === void 0 ? [] : [rateLimitBucketSummary(bucket, name)];
+  });
+  const summaries = [direct, ...children].filter(
+    (value) => value !== void 0
+  );
+  return summaries.length === 0 ? void 0 : summaries.join(" | ");
+}
+function rateLimitBucketSummary(bucket, fallbackName) {
+  const name = stringValue2(bucket.limitName) ?? stringValue2(bucket.limit_name) ?? stringValue2(bucket.name) ?? stringValue2(bucket.type) ?? fallbackName;
+  const plan = stringValue2(bucket.planType) ?? stringValue2(bucket.plan_type) ?? stringValue2(bucket.plan);
+  const remaining = integerValue2(bucket.remaining) ?? integerValue2(bucket.remainingRequests) ?? integerValue2(bucket.remaining_requests) ?? integerValue2(bucket.remainingTokens) ?? integerValue2(bucket.remaining_tokens);
+  const limit = integerValue2(bucket.limit) ?? integerValue2(bucket.requestLimit) ?? integerValue2(bucket.request_limit) ?? integerValue2(bucket.limitRequests) ?? integerValue2(bucket.limit_requests) ?? integerValue2(bucket.tokenLimit) ?? integerValue2(bucket.token_limit) ?? integerValue2(bucket.limitTokens) ?? integerValue2(bucket.limit_tokens);
+  const reset = stringValue2(bucket.resetAt) ?? stringValue2(bucket.reset_at) ?? stringValue2(bucket.resetsAt) ?? stringValue2(bucket.resets_at) ?? unixTimestampValue(bucket.resetsAt) ?? unixTimestampValue(bucket.resets_at) ?? secondsValue(bucket.resetAfterSeconds) ?? secondsValue(bucket.reset_after_seconds) ?? secondsValue(bucket.retryAfterSeconds) ?? secondsValue(bucket.retry_after_seconds);
+  const usedPercent = integerValue2(bucket.usedPercent) ?? integerValue2(bucket.used_percent);
+  const windowDurationMins = integerValue2(bucket.windowDurationMins) ?? integerValue2(bucket.window_duration_mins);
+  const label = [name, plan].filter((value) => value !== void 0).join(" ");
+  const prefix = label === "" ? void 0 : label;
+  const remainingSummary = remaining === void 0 ? void 0 : limit === void 0 ? `${remaining} remaining` : `${remaining}/${limit} remaining`;
+  const fields = [
+    remainingSummary,
+    usedPercent === void 0 ? void 0 : `${usedPercent}% used`,
+    windowDurationMins === void 0 ? void 0 : `${windowDurationMins}m window`,
+    reset === void 0 ? void 0 : `reset ${reset}`
+  ].filter((value) => value !== void 0);
+  switch (fields.length) {
+    case 0:
+      return prefix === void 0 ? void 0 : `${prefix} seen (no details)`;
+    default:
+      return prefix === void 0 ? fields.join(" ") : `${prefix} ${fields.join(" ")}`;
+  }
+}
+function secondsValue(value) {
+  const seconds = integerValue2(value);
+  return seconds === void 0 ? void 0 : `${seconds}s`;
+}
+function unixTimestampValue(value) {
+  const seconds = integerValue2(value);
+  return seconds === void 0 ? void 0 : new Date(seconds * 1e3).toISOString();
+}
+function objectValue3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function integerValue2(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isSafeInteger(parsed) && parsed.toString() === value.trim() ? parsed : void 0;
+}
+var init_codexNotificationConsoleStats = __esm({
+  "src/codexNotificationConsoleStats.ts"() {
+    "use strict";
+    init_protocol();
+  }
+});
+
 // src/localCapabilities.ts
 import { realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
@@ -13351,7 +13627,7 @@ var linzumiCliVersion, linzumiCliVersionText;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    linzumiCliVersion = "0.0.71-beta";
+    linzumiCliVersion = "0.0.73-beta";
     linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
   }
 });
@@ -13623,13 +13899,193 @@ var init_runnerLock = __esm({
 });
 
 // src/runnerConsoleReporter.ts
+import blessed from "blessed";
 function reportRunnerConsoleEvent(event, payload) {
+  if (shouldRenderDashboard()) {
+    const tui = initializeDashboardTui(dashboardState);
+    updateRunnerConsoleDashboard(dashboardState, event, payload, Date.now());
+    if (tui !== void 0) {
+      tui.render(Date.now());
+      return;
+    }
+    initializeDashboardKeyboard(dashboardState);
+    initializeDashboardTicker(dashboardState);
+    const screen = renderRunnerConsoleDashboard(dashboardState, Date.now());
+    if (screen !== void 0) {
+      redrawScreen(screen);
+      return;
+    }
+  }
   const line = formatRunnerConsoleEvent(event, payload);
   if (line !== void 0) {
     process.stdout.write(`${line}
 `);
   }
 }
+function shouldRenderDashboard() {
+  switch (process.env.LINZUMI_RUNNER_CONSOLE) {
+    case "dashboard":
+      return true;
+    case "lines":
+      return false;
+    default:
+      return process.stdout.isTTY === true;
+  }
+}
+function updateRunnerConsoleDashboard(state, event, payload, nowMs) {
+  state.lastUpdateAtMs = nowMs;
+  const previousJobKey = latestDashboardJob(state)?.key;
+  switch (event) {
+    case "kandan.message_queued":
+    case "codex.turn_starting": {
+      const job = dashboardJobForPayload(state, payload, nowMs);
+      job.linzumiThreadId = stringValue3(payload.linzumi_thread_id) ?? job.linzumiThreadId;
+      job.codexThreadId = stringValue3(payload.codex_thread_id) ?? job.codexThreadId;
+      job.lastIncomingPreview = stringValue3(payload.body_preview) ?? job.lastIncomingPreview;
+      job.lastIncomingAtMs = numberValue(payload.message_received_at_ms) ?? job.lastIncomingAtMs;
+      job.queueDepth = numberValue(payload.queue_depth) ?? job.queueDepth;
+      job.eventType = dashboardEventLabel(event);
+      job.updatedAtMs = nowMs;
+      break;
+    }
+    case "codex.notification": {
+      const tokenUsage = stringValue3(payload.token_usage_summary);
+      const rateLimit = stringValue3(payload.rate_limit_summary);
+      if (tokenUsage !== void 0) {
+        state.tokenUsage = tokenUsage;
+      }
+      if (rateLimit !== void 0) {
+        state.rateLimit = mergeRateLimitSummary(state.rateLimit, rateLimit);
+      }
+      const method = stringValue3(payload.method);
+      const metadata = objectValue4(payload.metadata);
+      const metadataHasJobSignal = stringValue3(metadata?.threadId) !== void 0 || stringValue3(metadata?.turnId) !== void 0 || stringValue3(metadata?.itemId) !== void 0;
+      if (!metadataHasJobSignal) {
+        break;
+      }
+      const codexThreadId = stringValue3(metadata?.threadId);
+      const job = codexThreadId === void 0 ? latestDashboardJob(state) : dashboardJobForKey(state, `codex:${codexThreadId}`, nowMs);
+      if (job !== void 0) {
+        job.codexThreadId = codexThreadId ?? job.codexThreadId;
+        job.tokenUsage = tokenUsage ?? job.tokenUsage;
+        job.latestCodexEventId = codexEventId(payload);
+        job.eventType = method ?? event;
+        job.turnId = stringValue3(metadata?.turnId) ?? job.turnId;
+        job.updatedAtMs = nowMs;
+      }
+      break;
+    }
+    case "kandan.codex_output_forwarded":
+    case "kandan.codex_delta_forwarded":
+    case "kandan.codex_reasoning_delta_forwarded":
+    case "kandan.codex_command_output_forwarded":
+    case "kandan.codex_file_change_forwarded":
+    case "kandan.codex_web_search_progress_forwarded": {
+      const job = dashboardJobForPayload(state, payload, nowMs);
+      job.latestCodexEventId = stringValue3(payload.item_key) ?? job.latestCodexEventId;
+      job.eventType = codexOutputDashboardLabel(event, payload);
+      job.turnId = stringValue3(payload.turn_id) ?? job.turnId;
+      if (stringValue3(payload.structured_kind) === "codex_assistant_message") {
+        job.lastAssistantPreview = stringValue3(payload.body_preview) ?? job.lastAssistantPreview;
+        job.lastAssistantAtMs = nowMs;
+      }
+      job.updatedAtMs = nowMs;
+      break;
+    }
+    default:
+      break;
+  }
+  rememberRawLine(state, event, payload, previousJobKey);
+}
+function renderRunnerConsoleDashboard(state, nowMs) {
+  if (state.jobs.size === 0 && state.tokenUsage === void 0 && state.rateLimit === void 0) {
+    return void 0;
+  }
+  const jobs = Array.from(state.jobs.values()).sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+  switch (state.mode.type) {
+    case "table":
+      return renderDashboardTable(state, jobs, nowMs);
+    case "raw_all":
+      return renderRawDashboard(
+        state,
+        "Raw Stream",
+        void 0,
+        "esc: table",
+        state.rawLines,
+        nowMs
+      );
+    case "raw_job": {
+      const jobKey = state.mode.jobKey;
+      const job = state.jobs.get(jobKey);
+      const title = `Raw Stream: ${shortId(job?.linzumiThreadId)} / ${agentId(job?.codexThreadId)}`;
+      return renderRawDashboard(
+        state,
+        title,
+        job?.tokenUsage,
+        "esc: table",
+        state.rawLines.filter((line) => line.jobKey === jobKey),
+        nowMs
+      );
+    }
+  }
+}
+function renderDashboardTable(state, jobs, nowMs) {
+  const model = dashboardTableModel(state, jobs, nowMs);
+  return [
+    "Linzumi Commander",
+    "",
+    `Jobs: ${jobs.length}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    `Overall Token Usage: ${state.tokenUsage ?? "?"}`,
+    `Account rate limits: ${state.rateLimit ?? "?"}`,
+    "Controls: up/down select | enter raw job | r raw stream | esc table",
+    "",
+    table(model.rows),
+    ""
+  ].join("\n");
+}
+function dashboardTableModel(state, jobs, nowMs) {
+  const selectedJobKey = selectedDashboardJobKey(state, jobs);
+  const rows = jobs.length === 0 ? [dashboardTableHeader(), emptyJobRow()] : [
+    dashboardTableHeader(),
+    ...jobs.map((job) => jobRow(job, selectedJobKey, nowMs))
+  ];
+  return {
+    jobs,
+    selectedJobKey,
+    rows
+  };
+}
+function dashboardTableHeader() {
+  return [
+    "",
+    "Linzumi thread",
+    "Agent",
+    "Last user message",
+    "Ago",
+    "Last assistant reply",
+    "Ago",
+    "Latest event",
+    "Event type"
+  ];
+}
+function mergeRateLimitSummary(previous, next) {
+  if (previous === void 0) {
+    return next;
+  }
+  const buckets = /* @__PURE__ */ new Map();
+  for (const summary of previous.split(" | ")) {
+    buckets.set(rateLimitSummaryKey(summary), summary);
+  }
+  for (const summary of next.split(" | ")) {
+    buckets.set(rateLimitSummaryKey(summary), summary);
+  }
+  return Array.from(buckets.values()).join(" | ");
+}
+function rateLimitSummaryKey(summary) {
+  return summary.split(" ", 1)[0] ?? summary;
+}
 function formatRunnerConsoleEvent(event, payload) {
   switch (event) {
     case "runner.instance_started":
@@ -13648,13 +14104,19 @@ function formatRunnerConsoleEvent(event, payload) {
     case "kandan.chat_event_failed":
       return `Incoming message handling failed: seq=${text(payload.seq)} reason=${text(payload.message)}`;
     case "kandan.reconnected":
-      return `Kandan reconnected: codex_session=${text(payload.codex_thread_id)} cursor=${text(payload.min_seq)}`;
+      return `Linzumi reconnected: codex_session=${text(payload.codex_thread_id)} cursor=${text(payload.min_seq)}`;
     case "codex.turn_starting":
       return `Incoming message from ${sender(payload)}: forwarding to Codex session ${text(payload.codex_thread_id)} seq=${text(payload.queued_seq)}`;
     case "codex.turn_started":
       return `Codex turn started: id=${text(payload.turn_id)}`;
-    case "codex.notification":
-      return `Codex event [id=${codexEventId(payload)}]: ${text(payload.method)}`;
+    case "codex.notification": {
+      const summary = [
+        stringValue3(payload.token_usage_summary),
+        stringValue3(payload.rate_limit_summary)
+      ].filter((value) => value !== void 0).join(" | ");
+      const suffix = summary === "" ? "" : ` ${summary}`;
+      return `Codex event [id=${codexEventId(payload)}]: ${text(payload.method)}${suffix}`;
+    }
     case "codex.turn_completed":
       return `Codex turn completed: id=${text(payload.turn_id)} outputs=${text(payload.output_count)}`;
     case "kandan.codex_output_forwarded":
@@ -13687,11 +14149,11 @@ function connectedRunnerMessage(payload) {
   ].filter((line) => line !== void 0).join("\n");
 }
 function optionalLine(label, value) {
-  const normalized = stringValue2(value) ?? numberValue(value)?.toString();
+  const normalized = stringValue3(value) ?? numberValue(value)?.toString();
   return normalized === void 0 ? void 0 : `${label}: ${normalized}`;
 }
 function optionalField(label, value) {
-  const normalized = stringValue2(value) ?? numberValue(value)?.toString();
+  const normalized = stringValue3(value) ?? numberValue(value)?.toString();
   return normalized === void 0 ? void 0 : `${label}=${normalized}`;
 }
 function ignoredMessage(payload) {
@@ -13715,17 +14177,17 @@ function replacementLines(value) {
       return [];
     }
     const record = entry;
-    const runnerId = stringValue2(record.runnerId);
+    const runnerId = stringValue3(record.runnerId);
     if (runnerId === void 0) {
       return [];
     }
-    const version = stringValue2(record.version);
+    const version = stringValue3(record.version);
     const suffix = version === void 0 ? "" : ` (CLI ${version})`;
     return [`Replaced older runner from this machine: ${runnerId}${suffix}`];
   });
 }
 function sender(payload) {
-  const slug = stringValue2(payload.actor_slug);
+  const slug = stringValue3(payload.actor_slug);
   const userId = numberValue(payload.actor_user_id);
   if (slug !== void 0 && userId !== void 0) {
     return `${slug}#${userId}`;
@@ -13733,7 +14195,7 @@ function sender(payload) {
   return slug ?? (userId === void 0 ? "unknown" : `user#${userId}`);
 }
 function codexOutputLabel(payload) {
-  const kind = stringValue2(payload.structured_kind) ?? "output";
+  const kind = stringValue3(payload.structured_kind) ?? "output";
   switch (kind) {
     case "codex_assistant_message":
       return "assistant_message";
@@ -13759,22 +14221,653 @@ function codexEventId(payload) {
   const metadata = payload.metadata;
   if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
     const record = metadata;
-    return stringValue2(record.turnId) ?? stringValue2(record.itemId) ?? stringValue2(record.threadId) ?? "?";
+    return stringValue3(record.turnId) ?? stringValue3(record.itemId) ?? stringValue3(record.threadId) ?? "?";
   }
   return "?";
 }
+function rememberRawLine(state, event, payload, previousJobKey) {
+  const line = formatRunnerConsoleEvent(event, payload);
+  if (line === void 0) {
+    return;
+  }
+  const jobKey = dashboardRawLineJobKey(state, payload, previousJobKey);
+  state.rawLines.push({ jobKey, line });
+  if (state.rawLines.length > maxRawLines) {
+    state.rawLines.splice(0, state.rawLines.length - maxRawLines);
+  }
+}
+function dashboardRawLineJobKey(state, payload, previousJobKey) {
+  const linzumiThreadId = stringValue3(payload.linzumi_thread_id);
+  const codexThreadId = stringValue3(payload.codex_thread_id);
+  if (linzumiThreadId !== void 0) {
+    return `linzumi:${linzumiThreadId}`;
+  }
+  if (codexThreadId !== void 0) {
+    return Array.from(state.jobs.values()).find(
+      (job) => job.codexThreadId === codexThreadId
+    )?.key;
+  }
+  const metadata = objectValue4(payload.metadata);
+  const metadataCodexThreadId = stringValue3(metadata?.threadId);
+  if (metadataCodexThreadId !== void 0) {
+    return Array.from(state.jobs.values()).find(
+      (job) => job.codexThreadId === metadataCodexThreadId
+    )?.key;
+  }
+  return previousJobKey;
+}
+function selectedDashboardJobKey(state, jobs) {
+  if (jobs.length === 0) {
+    state.selectedJobKey = void 0;
+    return void 0;
+  }
+  if (state.selectedJobKey === void 0 || jobs.every((job) => job.key !== state.selectedJobKey)) {
+    state.selectedJobKey = jobs[0]?.key;
+  }
+  return state.selectedJobKey;
+}
+function renderRawDashboard(state, title, tokenUsage, controls, lines, nowMs) {
+  const visibleLines = lines.slice(-40).map((entry) => entry.line);
+  return [
+    "Linzumi Commander",
+    "",
+    `${title}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    ...tokenUsage === void 0 ? [] : [`Token usage: ${tokenUsage}`],
+    `Controls: ${controls}`,
+    "",
+    ...visibleLines.length === 0 ? ["No raw events yet."] : visibleLines,
+    ""
+  ].join("\n");
+}
+function rawDashboardModel(state, mode) {
+  switch (mode.type) {
+    case "raw_all":
+      return {
+        title: "Raw Stream",
+        tokenUsage: void 0,
+        lines: state.rawLines.map((entry) => entry.line)
+      };
+    case "raw_job": {
+      const jobKey = mode.jobKey;
+      const job = state.jobs.get(jobKey);
+      return {
+        title: `Raw Stream: ${shortId(job?.linzumiThreadId)} / ${agentId(job?.codexThreadId)}`,
+        tokenUsage: job?.tokenUsage,
+        lines: state.rawLines.filter((line) => line.jobKey === jobKey).map((entry) => entry.line)
+      };
+    }
+  }
+}
+function dashboardJobs(state) {
+  return Array.from(state.jobs.values()).sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+}
+function selectDashboardJobAtVisibleIndex(state, index) {
+  const jobs = dashboardJobs(state);
+  const job = jobs[index];
+  if (job !== void 0) {
+    state.selectedJobKey = job.key;
+  }
+}
+function moveSelection(state, direction) {
+  const jobs = dashboardJobs(state);
+  if (jobs.length === 0) {
+    state.selectedJobKey = void 0;
+    return;
+  }
+  const selectedKey = selectedDashboardJobKey(state, jobs);
+  const currentIndex = Math.max(
+    0,
+    jobs.findIndex((job) => job.key === selectedKey)
+  );
+  const nextIndex = Math.min(
+    jobs.length - 1,
+    Math.max(0, currentIndex + direction)
+  );
+  state.selectedJobKey = jobs[nextIndex]?.key;
+}
+function initializeDashboardKeyboard(state) {
+  if (keyboardState.initialized || process.stdin.isTTY !== true || typeof process.stdin.setRawMode !== "function") {
+    return;
+  }
+  keyboardState.initialized = true;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", (chunk) => {
+    handleDashboardKey(state, chunk.toString("utf8"));
+  });
+}
+function initializeDashboardTicker(state) {
+  if (tickerState.stop !== void 0) {
+    return;
+  }
+  tickerState.stop = startRunnerConsoleDashboardTicker(state);
+}
+function initializeDashboardTui(state) {
+  if (tuiState.dashboard !== void 0) {
+    return tuiState.dashboard;
+  }
+  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+    return void 0;
+  }
+  const dashboard = createRunnerConsoleDashboardTui(state);
+  tuiState.dashboard = dashboard;
+  tuiState.stop = startRunnerConsoleDashboardRenderTicker(() => {
+    dashboard.render(Date.now());
+  });
+  return dashboard;
+}
+function startRunnerConsoleDashboardTicker(state, redraw = redrawScreen, intervalMs = 1e3) {
+  const interval = setInterval(() => {
+    const screen = renderRunnerConsoleDashboard(state, Date.now());
+    if (screen !== void 0) {
+      redraw(screen);
+    }
+  }, intervalMs);
+  interval.unref?.();
+  return () => {
+    clearInterval(interval);
+  };
+}
+function startRunnerConsoleDashboardRenderTicker(render, intervalMs = 1e3) {
+  const interval = setInterval(render, intervalMs);
+  interval.unref?.();
+  return () => {
+    clearInterval(interval);
+  };
+}
+function handleDashboardKey(state, key, exitProcess = () => process.kill(process.pid, "SIGINT")) {
+  if (key === ctrlCKey) {
+    exitProcess();
+    return;
+  }
+  updateRunnerConsoleDashboardMode(state, key);
+  const screen = renderRunnerConsoleDashboard(state, Date.now());
+  if (screen !== void 0) {
+    redrawScreen(screen);
+  }
+}
+function createRunnerConsoleDashboardTui(state, exitProcess = () => process.kill(process.pid, "SIGINT")) {
+  let rendering = false;
+  let rawScrollAnchor;
+  const screen = blessed.screen({
+    title: "Linzumi Commander",
+    smartCSR: true,
+    fullUnicode: true,
+    mouse: true
+  });
+  const header = blessed.box({
+    top: 0,
+    left: 0,
+    width: "100%",
+    height: 6,
+    tags: false
+  });
+  const tableElement = blessed.listtable({
+    top: 6,
+    left: 0,
+    width: "100%",
+    bottom: 1,
+    keys: true,
+    vi: true,
+    mouse: true,
+    scrollable: true,
+    alwaysScroll: true,
+    border: "line",
+    pad: 1,
+    data: [dashboardTableHeader(), emptyJobRow()],
+    scrollbar: {
+      ch: " ",
+      style: { inverse: true }
+    },
+    style: {
+      header: { bold: true },
+      cell: {
+        selected: {
+          inverse: true
+        }
+      },
+      border: {
+        fg: "grey"
+      }
+    }
+  });
+  const rawTitle = blessed.box({
+    top: 0,
+    left: 12,
+    right: 0,
+    height: 2,
+    tags: false,
+    hidden: true
+  });
+  const backButton = blessed.button({
+    top: 0,
+    left: 0,
+    width: 10,
+    height: 1,
+    content: "< Back",
+    mouse: true,
+    keys: true,
+    shrink: true,
+    hidden: true,
+    style: {
+      focus: { inverse: true },
+      hover: { inverse: true }
+    }
+  });
+  const rawBox = blessed.box({
+    top: 3,
+    left: 0,
+    width: "100%",
+    bottom: 0,
+    keys: true,
+    vi: true,
+    mouse: true,
+    scrollable: true,
+    alwaysScroll: true,
+    border: "line",
+    tags: false,
+    hidden: true,
+    scrollbar: {
+      ch: " ",
+      style: { inverse: true }
+    },
+    style: {
+      border: {
+        fg: "grey"
+      }
+    }
+  });
+  screen.append(header);
+  screen.append(tableElement);
+  screen.append(rawTitle);
+  screen.append(backButton);
+  screen.append(rawBox);
+  const showTable = () => {
+    state.mode = { type: "table" };
+    render(Date.now());
+  };
+  const showAllRaw = () => {
+    state.mode = { type: "raw_all" };
+    render(Date.now());
+  };
+  const showSelectedRaw = () => {
+    const selectedKey = selectedDashboardJobKey(state, dashboardJobs(state));
+    if (selectedKey !== void 0) {
+      state.mode = { type: "raw_job", jobKey: selectedKey };
+      render(Date.now());
+    }
+  };
+  screen.key(["C-c"], () => {
+    destroy();
+    exitProcess();
+  });
+  screen.key(["escape"], showTable);
+  screen.key(["r"], showAllRaw);
+  tableElement.key(["enter"], showSelectedRaw);
+  tableElement.on("select item", (_item, index) => {
+    if (rendering || state.mode.type !== "table") {
+      return;
+    }
+    selectDashboardJobAtVisibleIndex(state, index - 1);
+  });
+  tableElement.on("select", (_item, index) => {
+    if (rendering || state.mode.type !== "table") {
+      return;
+    }
+    selectDashboardJobAtVisibleIndex(state, index - 1);
+    showSelectedRaw();
+  });
+  backButton.on("press", showTable);
+  backButton.on("click", showTable);
+  function render(nowMs) {
+    rendering = true;
+    try {
+      switch (state.mode.type) {
+        case "table": {
+          const model = dashboardTableModel(state, dashboardJobs(state), nowMs);
+          header.setContent(tuiHeaderContent(state, model.jobs.length, nowMs));
+          header.show();
+          tableElement.setData(model.rows);
+          tableElement.show();
+          rawTitle.hide();
+          backButton.hide();
+          rawBox.hide();
+          rawScrollAnchor = void 0;
+          syncTuiTableSelection(tableElement, model);
+          tableElement.focus();
+          break;
+        }
+        case "raw_all":
+        case "raw_job": {
+          const model = rawDashboardModel(state, state.mode);
+          const nextRawScrollAnchor = `${state.mode.type}:${state.mode.type === "raw_job" ? state.mode.jobKey : "*"}:${model.lines.length}`;
+          header.hide();
+          tableElement.hide();
+          rawTitle.setContent(
+            [
+              `${model.title}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}  esc/back: table`,
+              model.tokenUsage === void 0 ? void 0 : `Token usage: ${model.tokenUsage}`
+            ].filter((value) => value !== void 0).join("\n")
+          );
+          rawBox.setContent(
+            model.lines.length === 0 ? "No raw events yet." : model.lines.join("\n")
+          );
+          rawTitle.show();
+          backButton.show();
+          rawBox.show();
+          if (rawScrollAnchor !== nextRawScrollAnchor) {
+            rawBox.setScrollPerc(100);
+            rawScrollAnchor = nextRawScrollAnchor;
+          }
+          rawBox.focus();
+          break;
+        }
+      }
+      screen.render();
+    } finally {
+      rendering = false;
+    }
+  }
+  function destroy() {
+    tuiState.stop?.();
+    tuiState.stop = void 0;
+    tuiState.dashboard = void 0;
+    screen.destroy();
+  }
+  return { render, destroy };
+}
+function syncTuiTableSelection(tableElement, model) {
+  const selectedIndex = model.jobs.findIndex(
+    (job) => job.key === model.selectedJobKey
+  );
+  const tableIndex = selectedIndex < 0 ? 1 : selectedIndex + 1;
+  tableElement.select(tableIndex);
+}
+function tuiHeaderContent(state, jobCount, nowMs) {
+  return [
+    "Linzumi Commander",
+    `Jobs: ${jobCount}  Last update: ${timeAgo(state.lastUpdateAtMs, nowMs)}`,
+    `Overall Token Usage: ${state.tokenUsage ?? "?"}`,
+    `Account rate limits: ${state.rateLimit ?? "?"}`,
+    "Controls: click row/enter raw job | r raw stream | esc/back table | mouse wheel scroll"
+  ].join("\n");
+}
+function updateRunnerConsoleDashboardMode(state, key) {
+  switch (key) {
+    case "r":
+      state.mode = { type: "raw_all" };
+      break;
+    case escapeKey:
+      state.mode = { type: "table" };
+      break;
+    case enterKey: {
+      const selectedKey = selectedDashboardJobKey(state, dashboardJobs(state));
+      if (selectedKey !== void 0) {
+        state.mode = { type: "raw_job", jobKey: selectedKey };
+      }
+      break;
+    }
+    case upKey:
+      moveSelection(state, -1);
+      break;
+    case downKey:
+      moveSelection(state, 1);
+      break;
+    default:
+      break;
+  }
+}
+function dashboardJobForPayload(state, payload, nowMs) {
+  const linzumiThreadId = stringValue3(payload.linzumi_thread_id);
+  const codexThreadId = stringValue3(payload.codex_thread_id);
+  const existingByCodex = codexThreadId !== void 0 ? Array.from(state.jobs.values()).find(
+    (job) => job.codexThreadId === codexThreadId
+  ) : void 0;
+  if (existingByCodex !== void 0) {
+    return promoteDashboardJobKey(state, existingByCodex, linzumiThreadId);
+  }
+  const key = linzumiThreadId === void 0 ? codexThreadId === void 0 ? "job:unknown" : `codex:${codexThreadId}` : `linzumi:${linzumiThreadId}`;
+  const existing = state.jobs.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const created = {
+    key,
+    linzumiThreadId,
+    codexThreadId,
+    tokenUsage: void 0,
+    lastIncomingPreview: void 0,
+    lastIncomingAtMs: void 0,
+    lastAssistantPreview: void 0,
+    lastAssistantAtMs: void 0,
+    latestCodexEventId: void 0,
+    eventType: void 0,
+    queueDepth: void 0,
+    turnId: void 0,
+    updatedAtMs: nowMs
+  };
+  state.jobs.set(key, created);
+  return created;
+}
+function promoteDashboardJobKey(state, job, linzumiThreadId) {
+  if (linzumiThreadId === void 0) {
+    return job;
+  }
+  const key = `linzumi:${linzumiThreadId}`;
+  if (job.key === key) {
+    job.linzumiThreadId = linzumiThreadId;
+    return job;
+  }
+  const promoted = { ...job, key, linzumiThreadId };
+  state.jobs.delete(job.key);
+  state.jobs.set(key, promoted);
+  if (state.selectedJobKey === job.key) {
+    state.selectedJobKey = key;
+  }
+  if (state.mode.type === "raw_job" && state.mode.jobKey === job.key) {
+    state.mode = { type: "raw_job", jobKey: key };
+  }
+  state.rawLines.splice(
+    0,
+    state.rawLines.length,
+    ...state.rawLines.map(
+      (line) => line.jobKey === job.key ? { ...line, jobKey: key } : line
+    )
+  );
+  return promoted;
+}
+function dashboardJobForKey(state, key, nowMs) {
+  if (key.startsWith("codex:")) {
+    const codexThreadId = key.slice("codex:".length);
+    const existingByCodex = Array.from(state.jobs.values()).find(
+      (job) => job.codexThreadId === codexThreadId
+    );
+    if (existingByCodex !== void 0) {
+      return existingByCodex;
+    }
+  }
+  const existing = state.jobs.get(key);
+  if (existing !== void 0) {
+    return existing;
+  }
+  const created = {
+    key,
+    linzumiThreadId: void 0,
+    codexThreadId: key.startsWith("codex:") ? key.slice("codex:".length) : void 0,
+    tokenUsage: void 0,
+    lastIncomingPreview: void 0,
+    lastIncomingAtMs: void 0,
+    lastAssistantPreview: void 0,
+    lastAssistantAtMs: void 0,
+    latestCodexEventId: void 0,
+    eventType: void 0,
+    queueDepth: void 0,
+    turnId: void 0,
+    updatedAtMs: nowMs
+  };
+  state.jobs.set(key, created);
+  return created;
+}
+function latestDashboardJob(state) {
+  return Array.from(state.jobs.values()).sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  )[0];
+}
+function jobRow(job, selectedJobKey, nowMs) {
+  return [
+    job.key === selectedJobKey ? ">" : " ",
+    shortId(job.linzumiThreadId),
+    agentId(job.codexThreadId),
+    truncate(job.lastIncomingPreview ?? "?", 50),
+    timeAgo(job.lastIncomingAtMs, nowMs),
+    truncate(job.lastAssistantPreview ?? "?", 50),
+    timeAgo(job.lastAssistantAtMs, nowMs),
+    lastFour(job.latestCodexEventId),
+    truncate(job.eventType ?? "?", 34)
+  ];
+}
+function emptyJobRow() {
+  return [" ", "?", "?", "?", "?", "?", "?", "?", "?"];
+}
+function codexOutputDashboardLabel(event, payload) {
+  switch (event) {
+    case "kandan.codex_output_forwarded":
+      return codexOutputLabel(payload);
+    case "kandan.codex_delta_forwarded":
+      return "assistant_delta";
+    case "kandan.codex_reasoning_delta_forwarded":
+      return "reasoning_delta";
+    case "kandan.codex_command_output_forwarded":
+      return `command_output ${text(payload.stream)}`;
+    case "kandan.codex_file_change_forwarded":
+      return "file_change";
+    case "kandan.codex_web_search_progress_forwarded":
+      return "search_progress";
+    default:
+      return event;
+  }
+}
+function dashboardEventLabel(event) {
+  switch (event) {
+    case "kandan.message_queued":
+      return "message_queued";
+    case "codex.turn_starting":
+      return "turn_starting";
+    default:
+      return event;
+  }
+}
+function table(rows) {
+  if (rows.length === 0) {
+    return "";
+  }
+  const widths = dashboardTableColumns.map((column) => column.width);
+  const divider = widths.map((width) => "-".repeat(width)).join("-+-");
+  return rows.map((row, index) => {
+    const line = row.map(
+      (cell, cellIndex) => fixedWidthCell(cell, widths[cellIndex] ?? displayWidth(cell))
+    ).join(" | ");
+    return index === 0 ? `${line}
+${divider}` : line;
+  }).join("\n");
+}
+function displayWidth(value) {
+  return value.length;
+}
+function shortId(value) {
+  return value === void 0 ? "?" : truncate(value, 18);
+}
+function agentId(codexThreadId) {
+  if (codexThreadId === void 0) {
+    return "?";
+  }
+  return `codex/...${lastN(codexThreadId, 5)}`;
+}
+function fixedWidthCell(value, width) {
+  return truncate(value, width).padEnd(width, " ");
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function lastFour(value) {
+  if (value === void 0) {
+    return "?";
+  }
+  return lastN(value, 4);
+}
+function lastN(value, count) {
+  return value.length <= count ? value : value.slice(-count);
+}
+function timeAgo(valueMs, nowMs) {
+  if (valueMs === void 0) {
+    return "?";
+  }
+  const seconds = Math.max(0, Math.floor((nowMs - valueMs) / 1e3));
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  return `${Math.floor(minutes / 60)}h`;
+}
+function objectValue4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
 function text(value) {
-  return stringValue2(value) ?? numberValue(value)?.toString() ?? "?";
+  return stringValue3(value) ?? numberValue(value)?.toString() ?? "?";
 }
-function stringValue2(value) {
+function stringValue3(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
 function numberValue(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+var dashboardState, maxRawLines, escapeKey, ctrlCKey, enterKey, upKey, downKey, dashboardTableColumns, redrawScreen, keyboardState, tickerState, tuiState;
 var init_runnerConsoleReporter = __esm({
   "src/runnerConsoleReporter.ts"() {
     "use strict";
+    dashboardState = {
+      jobs: /* @__PURE__ */ new Map(),
+      rawLines: [],
+      mode: { type: "table" },
+      selectedJobKey: void 0,
+      tokenUsage: void 0,
+      rateLimit: void 0,
+      lastUpdateAtMs: void 0
+    };
+    maxRawLines = 500;
+    escapeKey = "\x1B";
+    ctrlCKey = "";
+    enterKey = "\r";
+    upKey = "\x1B[A";
+    downKey = "\x1B[B";
+    dashboardTableColumns = [
+      { width: 1 },
+      { width: 20 },
+      { width: 16 },
+      { width: 38 },
+      { width: 6 },
+      { width: 42 },
+      { width: 6 },
+      { width: 12 },
+      { width: 24 }
+    ];
+    redrawScreen = (screen) => {
+      process.stdout.write(`\x1B[2J\x1B[H${screen}`);
+    };
+    keyboardState = { initialized: false };
+    tickerState = { stop: void 0 };
+    tuiState = {
+      dashboard: void 0,
+      stop: void 0
+    };
   }
 });
 
@@ -15536,7 +16629,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     if (workspaceSlug === void 0 || channelSlug === void 0 || kandanThreadId === void 0) {
       return void 0;
     }
-    const existingSession = dynamicChannelSessions.get(kandanThreadId);
+    const existingSession = dynamicChannelSessions.get(codexThreadId);
     if (existingSession !== void 0) {
       return existingSession;
     }
@@ -15599,16 +16692,15 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
       },
       log
     });
-    dynamicChannelSessions.set(kandanThreadId, session);
+    dynamicChannelSessions.set(codexThreadId, session);
     if (sessionCodex !== codex) {
       sessionCodex.onNotification((notification) => {
         seq.value += 1;
         const params = notification.params ?? {};
-        const metadata = extractCodexIds(params);
-        log("codex.notification", {
-          method: notification.method,
-          metadata
-        });
+        log(
+          "codex.notification",
+          codexNotificationConsoleLogPayload(notification.method, params)
+        );
         session.handleCodexNotification(notification.method, params);
       });
     }
@@ -15823,14 +16915,17 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
   codex.onNotification((notification) => {
     seq.value += 1;
     const params = notification.params ?? {};
-    const metadata = extractCodexIds(params);
+    const logPayload = codexNotificationConsoleLogPayload(
+      notification.method,
+      params
+    );
     if (channelSession === void 0) {
       void kandan.push(topic, "codex_notification", {
         instanceId,
         seq: seq.value,
         method: notification.method,
         params,
-        metadata,
+        metadata: logPayload.metadata,
         receivedAt: (/* @__PURE__ */ new Date()).toISOString()
       }).catch((error) => {
         log("kandan.codex_notification_push_failed", {
@@ -15838,10 +16933,7 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
         });
       });
     }
-    log("codex.notification", {
-      method: notification.method,
-      metadata
-    });
+    log("codex.notification", logPayload);
     channelSession?.handleCodexNotification(notification.method, params);
     for (const session of dynamicChannelSessions.values()) {
       session.handleCodexNotification(notification.method, params);
@@ -16170,13 +17262,35 @@ function controlThreadId(control) {
 async function resolveSessionControl(channelSession, dynamicChannelSessions, control) {
   const targetThreadId = controlThreadId(control);
   if (targetThreadId !== void 0) {
-    const targetDynamicSession = dynamicChannelSessions.get(targetThreadId);
+    const directDynamicSession = dynamicChannelSessions.get(targetThreadId);
+    const targetDynamicSessions = Array.from(
+      /* @__PURE__ */ new Set([
+        ...directDynamicSession === void 0 ? [] : [directDynamicSession],
+        ...Array.from(dynamicChannelSessions.values()).filter(
+          (session) => session.currentKandanThreadId() === targetThreadId
+        )
+      ])
+    );
     const targetSessions = [
       ...channelSession?.currentKandanThreadId() === targetThreadId ? [channelSession] : [],
-      ...targetDynamicSession !== void 0 && targetDynamicSession !== channelSession ? [targetDynamicSession] : []
+      ...targetDynamicSessions.filter((session) => session !== channelSession)
     ].filter(
       (session) => session !== void 0
     );
+    if (control.type === "update_thread_interaction_access") {
+      let firstHandled;
+      let firstOk;
+      for (const session of targetSessions) {
+        const handled = await session.handleControl(control);
+        if (handled !== void 0) {
+          firstHandled ??= handled;
+          if (handled.ok === true) {
+            firstOk ??= handled;
+          }
+        }
+      }
+      return firstOk ?? firstHandled;
+    }
     for (const session of targetSessions) {
       const handled = await session.handleControl(control);
       if (handled !== void 0) {
@@ -16430,7 +17544,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             topic,
             control,
             cwd.reason,
-            allowedCwds.value
+            allowedCwds.value,
+            { instanceId }
           );
         } catch (error) {
           log("kandan.start_instance_cwd_failed_state_push_failed", {
@@ -16454,7 +17569,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             topic,
             control,
             "failed",
-            startInstanceUnavailableReason(agentProvider)
+            startInstanceUnavailableReason(agentProvider),
+            { instanceId }
           );
         } catch (error) {
           log("kandan.start_instance_unavailable_state_push_failed", {
@@ -16472,7 +17588,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
       const processingStatePayload = startInstanceMessageStatePayload(
         control,
         "processing",
-        `starting ${startInstanceAgentLabel(agentProvider)} session`
+        `starting ${startInstanceAgentLabel(agentProvider)} session`,
+        { instanceId }
       );
       if (processingStatePayload !== void 0) {
         void kandan.push(topic, "message_state", processingStatePayload).catch((error) => {
@@ -16542,7 +17659,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             control,
             "failed",
             failureReason,
-            { codexThreadId: startedCodexThreadId }
+            { codexThreadId: startedCodexThreadId, instanceId }
           );
         } catch (_publishError) {
         }
@@ -16560,7 +17677,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             topic,
             control,
             cwd.reason,
-            allowedCwds.value
+            allowedCwds.value,
+            { instanceId }
           );
         } catch (error) {
           log("kandan.reconnect_thread_cwd_failed_state_push_failed", {
@@ -16596,7 +17714,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
             topic,
             control,
             "failed",
-            startInstanceUnavailableReason(agentProvider)
+            startInstanceUnavailableReason(agentProvider),
+            { instanceId }
           );
         } catch (error) {
           log("kandan.reconnect_thread_unavailable_state_push_failed", {
@@ -16635,7 +17754,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           const processingStatePayload = startInstanceMessageStatePayload(
             control,
             "processing",
-            "queued Claude Code input"
+            "queued Claude Code input",
+            { instanceId, codexThreadId }
           );
           if (processingStatePayload !== void 0) {
             void kandan.push(topic, "message_state", processingStatePayload).catch((error) => {
@@ -16670,7 +17790,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
                 topic,
                 control,
                 "failed",
-                reason
+                reason,
+                { instanceId, codexThreadId }
               );
             } catch (error) {
               log("kandan.reconnect_thread_queue_failed_state_push_failed", {
@@ -16700,7 +17821,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
                 topic,
                 control,
                 "failed",
-                reason
+                reason,
+                { instanceId, codexThreadId }
               );
             } catch (pushError) {
               log("kandan.reconnect_thread_queue_closed_state_push_failed", {
@@ -16739,7 +17861,8 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
           const processingStatePayload = startInstanceMessageStatePayload(
             control,
             "processing",
-            "resuming Claude Code session"
+            "resuming Claude Code session",
+            { instanceId, codexThreadId }
           );
           if (processingStatePayload !== void 0) {
             void kandan.push(topic, "message_state", processingStatePayload).catch((error) => {
@@ -16785,7 +17908,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
               control,
               "failed",
               failureReason,
-              { codexThreadId }
+              { codexThreadId, instanceId }
             );
           } catch (_publishError) {
           }
@@ -17536,7 +18659,8 @@ async function startClaudeCodeProviderInstance(args) {
         args.topic,
         args.control,
         "failed",
-        reason
+        reason,
+        { instanceId: args.instanceId }
       );
     } catch (error) {
       args.log(
@@ -18361,7 +19485,7 @@ async function publishStartInstanceMessageState(kandan, topic, control, status,
   }
   await kandan.push(topic, "message_state", payload);
 }
-async function publishStartInstanceCwdFailureMessageState(kandan, topic, control, reason, allowedCwds) {
+async function publishStartInstanceCwdFailureMessageState(kandan, topic, control, reason, allowedCwds, diagnostics = {}) {
   const rootSeq = integerValue(control.rootSeq);
   const sourceSeq = integerValue(control.sourceSeq) ?? rootSeq;
   if (sourceSeq === void 0) {
@@ -18377,6 +19501,7 @@ async function publishStartInstanceCwdFailureMessageState(kandan, topic, control
     workspace,
     channel,
     thread_id: threadId,
+    ...diagnostics.instanceId === void 0 ? {} : { instance_id: diagnostics.instanceId },
     seq: sourceSeq,
     status: "failed",
     reason,
@@ -18414,6 +19539,7 @@ function startInstanceMessageStatePayload(control, status, reason, diagnostics =
     workspace,
     channel,
     thread_id: threadId,
+    ...diagnostics.instanceId === void 0 ? {} : { instance_id: diagnostics.instanceId },
     seq: sourceSeq,
     status,
     reason,
@@ -19369,6 +20495,7 @@ var init_runner = __esm({
     init_codexAppServer();
     init_codexProjectTrust();
     init_codexRuntimeOptions();
+    init_codexNotificationConsoleStats();
     init_json();
     init_linzumiContext();
     init_localCapabilities();
@@ -29718,23 +30845,23 @@ var require_sbcs = __commonJS({
         this.ngramList = theNgramList;
         this.byteMap = theByteMap;
       }
-      search(table, value) {
+      search(table2, value) {
         let index = 0;
-        if (table[index + 32] <= value)
+        if (table2[index + 32] <= value)
           index += 32;
-        if (table[index + 16] <= value)
+        if (table2[index + 16] <= value)
           index += 16;
-        if (table[index + 8] <= value)
+        if (table2[index + 8] <= value)
           index += 8;
-        if (table[index + 4] <= value)
+        if (table2[index + 4] <= value)
           index += 4;
-        if (table[index + 2] <= value)
+        if (table2[index + 2] <= value)
           index += 2;
-        if (table[index + 1] <= value)
+        if (table2[index + 1] <= value)
           index += 1;
-        if (table[index] > value)
+        if (table2[index] > value)
           index -= 1;
-        if (index < 0 || table[index] != value)
+        if (index < 0 || table2[index] != value)
           return -1;
         return index;
       }
@@ -36373,15 +37500,15 @@ var require_dbcs_codec = __commonJS({
       this.nodeIdx = 0;
       return ret;
     };
-    function findIdx(table, val) {
-      if (table[0] > val) {
+    function findIdx(table2, val) {
+      if (table2[0] > val) {
         return -1;
       }
       var l = 0;
-      var r = table.length;
+      var r = table2.length;
       while (l < r - 1) {
         var mid = l + (r - l + 1 >> 1);
-        if (table[mid] <= val) {
+        if (table2[mid] <= val) {
           l = mid;
         } else {
           r = mid;
@@ -38432,8 +39559,8 @@ var init_esm6 = __esm({
       if (status === "loading") {
         helpTip = theme.style.help("Received");
       } else if (status === "idle") {
-        const enterKey = theme.style.key("enter");
-        helpTip = theme.style.help(`Press ${enterKey} to launch your preferred editor.`);
+        const enterKey2 = theme.style.key("enter");
+        helpTip = theme.style.help(`Press ${enterKey2} to launch your preferred editor.`);
       }
       let error = "";
       if (errorMsg) {
@@ -39463,15 +40590,15 @@ function signupErrorCodeFromResponseText(text2) {
 function renderEmailCodeStart(value) {
   const body = objectRecord(value, "signup email-code start response");
   return {
-    pendingId: stringValue4(body, "pending_id"),
-    email: stringValue4(body, "email")
+    pendingId: stringValue5(body, "pending_id"),
+    email: stringValue5(body, "email")
   };
 }
 function renderEmailCodeVerify(value) {
   const body = objectRecord(value, "signup email-code verify response");
   return {
-    accessToken: stringValue4(body, "access_token"),
-    refreshToken: stringValue4(body, "refresh_token"),
+    accessToken: stringValue5(body, "access_token"),
+    refreshToken: stringValue5(body, "refresh_token"),
     expiresInSeconds: positiveIntegerValue(body, "expires_in"),
     user: renderUserRef(requiredValue(body, "user")),
     isNewUser: booleanValue(body, "is_new_user"),
@@ -39511,7 +40638,7 @@ function renderMissionControlComplete(value) {
     localRunnerToken: renderLocalRunnerToken(
       requiredValue(body, "local_runner_token")
     ),
-    launchUrl: stringValue4(body, "launch_url"),
+    launchUrl: stringValue5(body, "launch_url"),
     ...missionControlUrl === void 0 ? {} : { missionControlUrl },
     config: {
       allowedCwds: arrayValue2(config, "allowed_cwds").map(
@@ -39531,21 +40658,21 @@ function renderLocalRunnerToken(value) {
   const body = objectRecord(value, "signup local runner token");
   const expiresInSeconds = optionalPositiveIntegerValue(body, "expires_in");
   return {
-    accessToken: stringValue4(body, "access_token"),
+    accessToken: stringValue5(body, "access_token"),
     ...expiresInSeconds === void 0 ? {} : { expiresInSeconds },
-    workspaceSlug: stringValue4(body, "workspace"),
-    channelSlug: stringValue4(body, "channel")
+    workspaceSlug: stringValue5(body, "workspace"),
+    channelSlug: stringValue5(body, "channel")
   };
 }
 function renderTaskStartResult(value) {
   const body = objectRecord(value, "signup task start");
-  const status = stringValue4(body, "status");
+  const status = stringValue5(body, "status");
   if (status !== "queued" && status !== "started" && status !== "failed") {
     throw new Error("signup task start status was incomplete");
   }
   return {
-    threadId: stringValue4(body, "thread_id"),
-    title: stringValue4(body, "title"),
+    threadId: stringValue5(body, "thread_id"),
+    title: stringValue5(body, "title"),
     status,
     ...optionalStringValue(body, "runner_id") === void 0 ? {} : { runnerId: optionalStringValue(body, "runner_id") },
     ...optionalStringValue(body, "error") === void 0 ? {} : { error: optionalStringValue(body, "error") }
@@ -39555,7 +40682,7 @@ function renderUserRef(value) {
   const body = objectRecord(value, "signup user");
   return {
     id: positiveIntegerValue(body, "id"),
-    username: stringValue4(body, "username"),
+    username: stringValue5(body, "username"),
     ...optionalStringValue(body, "display_name") === void 0 ? {} : { displayName: optionalStringValue(body, "display_name") },
     ...optionalStringValue(body, "primary_email") === void 0 ? {} : { primaryEmail: optionalStringValue(body, "primary_email") }
   };
@@ -39564,23 +40691,23 @@ function renderWorkspaceRef(value) {
   const body = objectRecord(value, "signup workspace");
   return {
     id: positiveIntegerValue(body, "id"),
-    slug: stringValue4(body, "slug"),
-    name: stringValue4(body, "name")
+    slug: stringValue5(body, "slug"),
+    name: stringValue5(body, "name")
   };
 }
 function renderChannelRef(value) {
   const body = objectRecord(value, "signup channel");
   return {
     id: positiveIntegerValue(body, "id"),
-    slug: stringValue4(body, "slug"),
-    name: stringValue4(body, "name")
+    slug: stringValue5(body, "slug"),
+    name: stringValue5(body, "name")
   };
 }
 function renderThreadRef(value) {
   const body = objectRecord(value, "signup thread");
   return {
-    threadId: stringValue4(body, "thread_id"),
-    title: stringValue4(body, "title"),
+    threadId: stringValue5(body, "thread_id"),
+    title: stringValue5(body, "title"),
     rootSeq: positiveIntegerValue(body, "root_seq"),
     threadSeq: positiveIntegerValue(body, "thread_seq")
   };
@@ -39598,7 +40725,7 @@ function requiredValue(record, key) {
   }
   return value;
 }
-function stringValue4(record, key) {
+function stringValue5(record, key) {
   return stringFromUnknown(requiredValue(record, key), `signup ${key}`);
 }
 function optionalStringValue(record, key) {
@@ -55960,16 +57087,16 @@ async function runMcpServer(args) {
   const kandanUrl = required(values, "api-url");
   const auth = await resolveMcpAuth({
     kandanUrl,
-    explicitToken: stringValue3(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
-    authFilePath: stringValue3(values, "auth-file"),
-    delegationAuthFilePath: stringValue3(values, "delegation-auth-file"),
-    workspaceSlug: stringValue3(values, "workspace"),
-    channelSlug: stringValue3(values, "channel")
-  });
-  const ownerUsername = stringValue3(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME;
-  const operatingMode = mcpOperatingMode(stringValue3(values, "mode"));
-  const cwd = stringValue3(values, "cwd") ?? process.cwd();
-  const defaultThreadId = stringValue3(values, "thread-id") ?? process.env.LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID;
+    explicitToken: stringValue4(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
+    authFilePath: stringValue4(values, "auth-file"),
+    delegationAuthFilePath: stringValue4(values, "delegation-auth-file"),
+    workspaceSlug: stringValue4(values, "workspace"),
+    channelSlug: stringValue4(values, "channel")
+  });
+  const ownerUsername = stringValue4(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME;
+  const operatingMode = mcpOperatingMode(stringValue4(values, "mode"));
+  const cwd = stringValue4(values, "cwd") ?? process.cwd();
+  const defaultThreadId = stringValue4(values, "thread-id") ?? process.env.LINZUMI_THREAD_RUNNER_KANDAN_THREAD_ID;
   const client = createLinzumiMcpApiClient({
     kandanUrl,
     accessToken: auth.accessToken,
@@ -56214,22 +57341,22 @@ function registerEmptyMcpResources(server) {
 async function runMcpConfig(args) {
   const values = strictFlagValues(args);
   const kandanUrl = required(values, "api-url");
-  const format = stringValue3(values, "format") ?? "codex";
-  const operatingMode = mcpOperatingMode(stringValue3(values, "mode"));
+  const format = stringValue4(values, "format") ?? "codex";
+  const operatingMode = mcpOperatingMode(stringValue4(values, "mode"));
   const token = values.get("include-token") === true ? (await resolveMcpAuth({
     kandanUrl,
-    explicitToken: stringValue3(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
-    authFilePath: stringValue3(values, "auth-file"),
-    delegationAuthFilePath: stringValue3(values, "delegation-auth-file"),
-    workspaceSlug: stringValue3(values, "workspace"),
-    channelSlug: stringValue3(values, "channel")
+    explicitToken: stringValue4(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
+    authFilePath: stringValue4(values, "auth-file"),
+    delegationAuthFilePath: stringValue4(values, "delegation-auth-file"),
+    workspaceSlug: stringValue4(values, "workspace"),
+    channelSlug: stringValue4(values, "channel")
   })).accessToken : void 0;
   const config = linzumiMcpServerConfig({
-    command: stringValue3(values, "command"),
+    command: stringValue4(values, "command"),
     kandanUrl,
     accessToken: token,
-    delegationAuthFilePath: stringValue3(values, "delegation-auth-file"),
-    ownerUsername: stringValue3(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME,
+    delegationAuthFilePath: stringValue4(values, "delegation-auth-file"),
+    ownerUsername: stringValue4(values, "owner-username") ?? process.env.LINZUMI_MCP_OWNER_USERNAME,
     operatingMode
   });
   switch (format) {
@@ -56248,19 +57375,19 @@ async function runMcpDoctor(args) {
   const kandanUrl = required(values, "api-url");
   const auth = await resolveMcpAuth({
     kandanUrl,
-    explicitToken: stringValue3(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
-    authFilePath: stringValue3(values, "auth-file"),
-    delegationAuthFilePath: stringValue3(values, "delegation-auth-file"),
-    workspaceSlug: stringValue3(values, "workspace"),
-    channelSlug: stringValue3(values, "channel")
+    explicitToken: stringValue4(values, "token") ?? process.env.LINZUMI_MCP_ACCESS_TOKEN,
+    authFilePath: stringValue4(values, "auth-file"),
+    delegationAuthFilePath: stringValue4(values, "delegation-auth-file"),
+    workspaceSlug: stringValue4(values, "workspace"),
+    channelSlug: stringValue4(values, "channel")
   });
   switch (auth.mode) {
     case "local-runner": {
       const ok = await validateLocalRunnerToken({
         kandanUrl,
         accessToken: auth.accessToken,
-        workspaceSlug: stringValue3(values, "workspace"),
-        channelSlug: stringValue3(values, "channel")
+        workspaceSlug: stringValue4(values, "workspace"),
+        channelSlug: stringValue4(values, "channel")
       });
       if (!ok) {
         throw new Error("Linzumi MCP auth validation failed");
@@ -56272,7 +57399,7 @@ async function runMcpDoctor(args) {
         kandanUrl,
         accessToken: auth.accessToken,
         authMode: auth.mode,
-        operatingMode: mcpOperatingMode(stringValue3(values, "mode"))
+        operatingMode: mcpOperatingMode(stringValue4(values, "mode"))
       });
       await client.validateAuth();
       break;
@@ -56343,7 +57470,7 @@ function strictFlagValues(args) {
   }
   return values;
 }
-function stringValue3(values, key) {
+function stringValue4(values, key) {
   const value = values.get(key);
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
@@ -56359,7 +57486,7 @@ function mcpOperatingMode(value) {
   }
 }
 function required(values, key) {
-  const value = stringValue3(values, key);
+  const value = stringValue4(values, key);
   if (value === void 0) {
     throw new Error(`--${key} is required`);
   }
@@ -56578,11 +57705,11 @@ function runHelloCommand(args) {
     process.stdout.write(helloHelpText());
     return;
   }
-  const rootPath = stringValue5(values, "dir");
-  const parentDir = stringValue5(values, "parent-dir");
-  const name = stringValue5(values, "name");
+  const rootPath = stringValue6(values, "dir");
+  const parentDir = stringValue6(values, "parent-dir");
+  const name = stringValue6(values, "name");
   const port = tcpPortValue(values, "port");
-  const host = stringValue5(values, "host");
+  const host = stringValue6(values, "host");
   const project = createHelloLinzumiProject({
     ...rootPath === void 0 ? {} : { rootPath },
     ...parentDir === void 0 ? {} : { parentDir: resolveUserPath(parentDir) },
@@ -56722,8 +57849,8 @@ async function runCommanderDaemonCommand(args) {
         runnerId,
         cwd,
         args: stripDaemonSupervisorFlags(flagArgs),
-        logFile: stringValue5(values, "log-file"),
-        statusDir: stringValue5(values, "status-dir")
+        logFile: stringValue6(values, "log-file"),
+        statusDir: stringValue6(values, "status-dir")
       });
       process.stdout.write("commander_status: daemon_started\n");
       process.stdout.write(`runner_id: ${record.runnerId}
@@ -56744,7 +57871,7 @@ async function runCommanderDaemonCommand(args) {
       const runnerId = ensureLocalRunnerIdForLinzumiUrl(kandanUrl);
       const status = commanderDaemonStatus(
         runnerId,
-        stringValue5(values, "status-dir")
+        stringValue6(values, "status-dir")
       );
       process.stdout.write(`${JSON.stringify(status)}
 `);
@@ -56758,7 +57885,7 @@ async function runCommanderDaemonCommand(args) {
       const result = await waitForCommanderDaemon({
         runnerId,
         timeoutMs,
-        statusDir: stringValue5(values, "status-dir")
+        statusDir: stringValue6(values, "status-dir")
       });
       if (result.ok) {
         process.stdout.write("commander_status: connected\n");
@@ -56776,7 +57903,7 @@ async function runCommanderDaemonCommand(args) {
       const runnerId = ensureLocalRunnerIdForLinzumiUrl(kandanUrl);
       const status = stopCommanderDaemon(
         runnerId,
-        stringValue5(values, "status-dir")
+        stringValue6(values, "status-dir")
       );
       process.stdout.write(`${JSON.stringify(status)}
 `);
@@ -56805,13 +57932,13 @@ async function runAuthCommand(args) {
     kandanUrl,
     workspaceSlug: target?.workspaceSlug,
     channelSlug: target?.channelSlug,
-    callbackHost: stringValue5(values, "oauth-callback-host")
+    callbackHost: stringValue6(values, "oauth-callback-host")
   });
   const cached = writeCachedLocalRunnerToken({
     kandanUrl,
     accessToken: token.accessToken,
     expiresInSeconds: token.expiresInSeconds,
-    authFilePath: stringValue5(values, "auth-file")
+    authFilePath: stringValue6(values, "auth-file")
   });
   process.stdout.write(
     `Saved Linzumi local runner auth for ${cached.kandanBaseUrl}
@@ -56838,11 +57965,11 @@ async function parseStartRunnerArgs(args, deps = {
   const requestedCwd = resolveUserPath(cwdArg ?? process.cwd());
   const cwd = assertConfiguredAllowedCwds([requestedCwd])[0] ?? requestedCwd;
   const explicitAllowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
-    parseAllowedCwdList(stringValue5(values, "allowed-cwd"))
+    parseAllowedCwdList(stringValue6(values, "allowed-cwd"))
   ) : [];
   const allowedCwds = Array.from(/* @__PURE__ */ new Set([cwd, ...explicitAllowedCwds]));
-  const requestedCodexBin = stringValue5(values, "codex-bin") ?? "codex";
-  const customCodeServerBin = stringValue5(values, "code-server-bin");
+  const requestedCodexBin = stringValue6(values, "codex-bin") ?? "codex";
+  const customCodeServerBin = stringValue6(values, "code-server-bin");
   const initialDependencyStatus = await deps.buildDependencyStatus({
     cwd,
     codexBin: requestedCodexBin,
@@ -56850,9 +57977,9 @@ async function parseStartRunnerArgs(args, deps = {
   });
   assertStartDependencies(initialDependencyStatus);
   const codexBin = initialDependencyStatus.codex.command;
-  const explicitToken = stringValue5(values, "token");
-  const authFilePath = stringValue5(values, "auth-file");
-  const callbackHost = stringValue5(values, "oauth-callback-host");
+  const explicitToken = stringValue6(values, "token");
+  const authFilePath = stringValue6(values, "auth-file");
+  const callbackHost = stringValue6(values, "oauth-callback-host");
   const reportRejectedCachedToken = () => {
     process.stderr.write(
       "Cached Linzumi local runner auth was rejected; starting OAuth.\n"
@@ -56905,13 +58032,13 @@ async function parseStartRunnerArgs(args, deps = {
     workspaceSlug: target.workspaceSlug,
     cwd,
     codexBin,
-    codexUrl: stringValue5(values, "codex-url"),
+    codexUrl: stringValue6(values, "codex-url"),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
-    logFile: stringValue5(values, "log-file"),
+    logFile: stringValue6(values, "log-file"),
     allowedCwds,
     allowedForwardPorts: parseAllowedPortList(
-      stringValue5(values, "forward-port")
+      stringValue6(values, "forward-port")
     ),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
@@ -56922,12 +58049,12 @@ async function parseStartRunnerArgs(args, deps = {
     channelSession: {
       workspaceSlug: target.workspaceSlug,
       channelSlug: target.channelSlug,
-      kandanThreadId: stringValue5(values, "linzumi-thread-id"),
-      listenUser: stringValue5(values, "listen-user") ?? defaultListenUserFromToken(targetToken),
-      model: stringValue5(values, "model"),
-      reasoningEffort: stringValue5(values, "reasoning-effort"),
-      sandbox: stringValue5(values, "sandbox"),
-      approvalPolicy: stringValue5(values, "approval-policy"),
+      kandanThreadId: stringValue6(values, "linzumi-thread-id"),
+      listenUser: stringValue6(values, "listen-user") ?? defaultListenUserFromToken(targetToken),
+      model: stringValue6(values, "model"),
+      reasoningEffort: stringValue6(values, "reasoning-effort"),
+      sandbox: stringValue6(values, "sandbox"),
+      approvalPolicy: stringValue6(values, "approval-policy"),
       allowPortForwardingByDefault: true,
       streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
     }
@@ -56952,32 +58079,32 @@ async function parseAgentRunnerArgs(args, deps = {
       "linzumi commander accepts either <folder> or --cwd, not both"
     );
   }
-  const tokenFilePath = stringValue5(values, "agent-token-file") ?? defaultAgentTokenFilePath();
+  const tokenFilePath = stringValue6(values, "agent-token-file") ?? defaultAgentTokenFilePath();
   const tokenFile = readStoredAgentTokenFile(tokenFilePath, deps.readTextFile);
   const channelSlug = tokenFile.channelId;
   rejectWorkspaceCommanderThreadFlags(values, channelSlug);
   const channelSession = channelSlug === void 0 ? void 0 : {
     workspaceSlug: tokenFile.workspaceId,
     channelSlug,
-    kandanThreadId: stringValue5(values, "linzumi-thread-id"),
-    listenUser: stringValue5(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername),
-    model: stringValue5(values, "model"),
-    reasoningEffort: stringValue5(values, "reasoning-effort"),
-    sandbox: stringValue5(values, "sandbox"),
-    approvalPolicy: stringValue5(values, "approval-policy"),
+    kandanThreadId: stringValue6(values, "linzumi-thread-id"),
+    listenUser: stringValue6(values, "listen-user") ?? requiredStoredOwnerUsername(tokenFile.ownerUsername),
+    model: stringValue6(values, "model"),
+    reasoningEffort: stringValue6(values, "reasoning-effort"),
+    sandbox: stringValue6(values, "sandbox"),
+    approvalPolicy: stringValue6(values, "approval-policy"),
     allowPortForwardingByDefault: true,
     streamFlushMs: positiveIntegerValue2(values, "stream-flush-ms")
   };
   const kandanUrl = kandanUrlValue(values) ?? agentApiUrlToKandanUrl(tokenFile.apiUrl);
-  const requestedCwdValue = cwdArg ?? stringValue5(values, "cwd");
+  const requestedCwdValue = cwdArg ?? stringValue6(values, "cwd");
   const requestedCwd = resolveUserPath(requestedCwdValue ?? process.cwd());
   const configuredAllowedCwds2 = requestedCwdValue === void 0 && !values.has("allowed-cwd") ? readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl) : { allowedCwds: [], missingAllowedCwds: [] };
   const allowedCwds = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
-    parseAllowedCwdList(stringValue5(values, "allowed-cwd"))
+    parseAllowedCwdList(stringValue6(values, "allowed-cwd"))
   ) : requestedCwdValue === void 0 ? configuredAllowedCwds2.allowedCwds.length > 0 ? [...configuredAllowedCwds2.allowedCwds] : assertConfiguredAllowedCwds([requestedCwd]) : assertConfiguredAllowedCwds([requestedCwd]);
   const cwd = allowedCwds[0] ?? requestedCwd;
-  const requestedCodexBin = stringValue5(values, "codex-bin") ?? "codex";
-  const customCodeServerBin = stringValue5(values, "code-server-bin");
+  const requestedCodexBin = stringValue6(values, "codex-bin") ?? "codex";
+  const customCodeServerBin = stringValue6(values, "code-server-bin");
   const initialDependencyStatus = await deps.buildDependencyStatus({
     cwd,
     codexBin: requestedCodexBin,
@@ -57008,14 +58135,14 @@ async function parseAgentRunnerArgs(args, deps = {
     workspaceSlug: tokenFile.workspaceId,
     cwd,
     codexBin,
-    codexUrl: stringValue5(values, "codex-url"),
+    codexUrl: stringValue6(values, "codex-url"),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
-    logFile: stringValue5(values, "log-file"),
+    logFile: stringValue6(values, "log-file"),
     allowedCwds,
     missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(
-      stringValue5(values, "forward-port")
+      stringValue6(values, "forward-port")
     ),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
@@ -57128,16 +58255,16 @@ async function parseRunnerArgs(args, deps = {
     process.exit(0);
   }
   rejectConnectChannelFlags(values);
-  const workspaceSlug = stringValue5(values, "workspace");
+  const workspaceSlug = stringValue6(values, "workspace");
   const kandanUrl = kandanUrlValue(values) ?? defaultLinzumiWebSocketUrl;
-  const cwd = stringValue5(values, "cwd") ?? process.cwd();
+  const cwd = stringValue6(values, "cwd") ?? process.cwd();
   const cwdAllowedCwds = assertConfiguredAllowedCwds([cwd]);
   const localConfiguredAllowedCwds = values.has("allowed-cwd") ? { allowedCwds: [], missingAllowedCwds: [] } : readConfiguredAllowedCwdDetailsForLinzumiUrl(kandanUrl);
   const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
-    parseAllowedCwdList(stringValue5(values, "allowed-cwd"))
+    parseAllowedCwdList(stringValue6(values, "allowed-cwd"))
   ) : [...localConfiguredAllowedCwds.allowedCwds];
-  const requestedCodexBin = stringValue5(values, "codex-bin") ?? "codex";
-  const customCodeServerBin = stringValue5(values, "code-server-bin");
+  const requestedCodexBin = stringValue6(values, "codex-bin") ?? "codex";
+  const customCodeServerBin = stringValue6(values, "code-server-bin");
   const initialDependencyStatus = await deps.buildDependencyStatus({
     cwd,
     codexBin: requestedCodexBin,
@@ -57145,13 +58272,13 @@ async function parseRunnerArgs(args, deps = {
   });
   assertStartDependencies(initialDependencyStatus);
   const codexBin = initialDependencyStatus.codex.command;
-  const explicitToken = stringValue5(values, "token");
+  const explicitToken = stringValue6(values, "token");
   const token = await deps.resolveToken({
     kandanUrl,
     explicitToken,
     workspaceSlug,
-    authFilePath: stringValue5(values, "auth-file"),
-    callbackHost: stringValue5(values, "oauth-callback-host"),
+    authFilePath: stringValue6(values, "auth-file"),
+    callbackHost: stringValue6(values, "oauth-callback-host"),
     reportRejectedCachedToken: () => {
       process.stderr.write(
         "Cached Linzumi local runner auth was rejected; starting OAuth.\n"
@@ -57180,16 +58307,16 @@ async function parseRunnerArgs(args, deps = {
     ),
     cwd,
     codexBin,
-    codexUrl: stringValue5(values, "codex-url"),
+    codexUrl: stringValue6(values, "codex-url"),
     launchTui: values.get("launch-tui") === true,
     fast: values.get("fast") === true,
-    logFile: stringValue5(values, "log-file"),
+    logFile: stringValue6(values, "log-file"),
     allowedCwds: Array.from(
       /* @__PURE__ */ new Set([...cwdAllowedCwds, ...configuredAllowedCwds2])
     ),
     missingAllowedCwds: localConfiguredAllowedCwds.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(
-      stringValue5(values, "forward-port")
+      stringValue6(values, "forward-port")
     ),
     codeServerBin: editorRuntime.codeServerBin,
     editorRuntime: editorRuntime.runtime,
@@ -57203,16 +58330,16 @@ async function parseRunnerArgs(args, deps = {
 }
 function runnerRuntimeDefaultsFromValues(values) {
   return {
-    model: stringValue5(values, "model"),
-    reasoningEffort: stringValue5(values, "reasoning-effort"),
-    approvalPolicy: stringValue5(values, "approval-policy"),
-    sandbox: stringValue5(values, "sandbox"),
+    model: stringValue6(values, "model"),
+    reasoningEffort: stringValue6(values, "reasoning-effort"),
+    approvalPolicy: stringValue6(values, "approval-policy"),
+    sandbox: stringValue6(values, "sandbox"),
     allowPortForwardingByDefault: true
   };
 }
 function kandanUrlValue(values) {
-  const apiUrl = stringValue5(values, "api-url");
-  const linzumiUrl = stringValue5(values, "linzumi-url");
+  const apiUrl = stringValue6(values, "api-url");
+  const linzumiUrl = stringValue6(values, "linzumi-url");
   if (apiUrl !== void 0 && linzumiUrl !== void 0 && apiUrl !== linzumiUrl) {
     throw new Error("use only one of --api-url or --linzumi-url");
   }
@@ -57351,8 +58478,8 @@ function rejectConnectChannelFlags(values) {
   );
 }
 function parseOptionalChannelTarget(values) {
-  const channel = stringValue5(values, "channel");
-  const workspace = stringValue5(values, "workspace");
+  const channel = stringValue6(values, "channel");
+  const workspace = stringValue6(values, "workspace");
   if (channel === void 0) {
     if (workspace === void 0) {
       return void 0;
@@ -57386,9 +58513,9 @@ function withLocalMachineId(options) {
 function parseThreadCodexWorkerArgs(args) {
   const values = strictFlagValues2(args);
   const kandanUrl = kandanUrlValue(values) ?? defaultLinzumiWebSocketUrl;
-  const cwd = stringValue5(values, "cwd") ?? process.cwd();
+  const cwd = stringValue6(values, "cwd") ?? process.cwd();
   const configuredAllowedCwds2 = values.has("allowed-cwd") ? assertConfiguredAllowedCwds(
-    parseAllowedCwdList(stringValue5(values, "allowed-cwd"))
+    parseAllowedCwdList(stringValue6(values, "allowed-cwd"))
   ) : assertConfiguredAllowedCwds([cwd]);
   const kandanThreadId = requiredThreadRunnerKandanThreadId();
   const token = requiredThreadRunnerToken();
@@ -57398,17 +58525,17 @@ function parseThreadCodexWorkerArgs(args) {
     runnerId: `thread-codex-worker:${kandanThreadId}`,
     machineId: void 0,
     runnerLockConfigPath: void 0,
-    workspaceSlug: stringValue5(values, "workspace"),
+    workspaceSlug: stringValue6(values, "workspace"),
     cwd,
-    codexBin: stringValue5(values, "codex-bin") ?? "codex",
+    codexBin: stringValue6(values, "codex-bin") ?? "codex",
     codexUrl: void 0,
     launchTui: false,
     fast: values.get("fast") === true ? true : void 0,
-    logFile: stringValue5(values, "log-file"),
+    logFile: stringValue6(values, "log-file"),
     allowedCwds: configuredAllowedCwds2.allowedCwds,
     missingAllowedCwds: configuredAllowedCwds2.missingAllowedCwds,
     allowedForwardPorts: parseAllowedPortList(
-      stringValue5(values, "forward-port")
+      stringValue6(values, "forward-port")
     ),
     codeServerBin: void 0,
     editorRuntime: void 0,
@@ -57438,13 +58565,13 @@ function requiredThreadRunnerToken() {
   return token;
 }
 function required2(values, key) {
-  const value = stringValue5(values, key);
+  const value = stringValue6(values, key);
   if (value === void 0) {
     throw new Error(`missing --${key}`);
   }
   return value;
 }
-function stringValue5(values, key) {
+function stringValue6(values, key) {
   const value = values.get(key);
   if (typeof value === "string" && value.trim() !== "") {
     return value;
@@ -57452,7 +58579,7 @@ function stringValue5(values, key) {
   return void 0;
 }
 function positiveIntegerValue2(values, key) {
-  const value = stringValue5(values, key);
+  const value = stringValue6(values, key);
   if (value === void 0) {
     return void 0;
   }
@@ -57463,7 +58590,7 @@ function positiveIntegerValue2(values, key) {
   throw new Error(`--${key} must be a positive integer`);
 }
 function tcpPortValue(values, key) {
-  const value = stringValue5(values, key);
+  const value = stringValue6(values, key);
   if (value === void 0) {
     return void 0;
   }