@linzumi/cli 0.0.63-beta → 0.0.64-beta

package/README.md

@@ -62,7 +62,7 @@ Install the CLI or run it with `npx`:
 ```bash
 npm install -g @linzumi/cli@latest
 npx -y @linzumi/cli@latest signup
-npx -y @linzumi/cli@0.0.63-beta --version
+npx -y @linzumi/cli@0.0.64-beta --version
 linzumi --version
 ```
 

package/dist/index.js

@@ -18214,6 +18214,35 @@ function codexFileChangeDeltaFromNotification(params) {
     patchText
   };
 }
+function codexCompletedFileChangeFromNotification(params) {
+  const item = objectValue(params.item) ?? objectValue(params.payload) ?? params;
+  const status = stringValue(item.status);
+  const turnId = stringValue(params.turnId) ?? stringValue(params.turn_id) ?? stringValue(objectValue(params.turn)?.id) ?? stringValue(item.turnId) ?? stringValue(item.turn_id) ?? stringValue(objectValue(item.turn)?.id);
+  if (codexItemTypeIsFileChange(item) && (status === void 0 || status === "completed")) {
+    const changes = normalizeFileChangeEntries(arrayValue(item.changes) ?? []);
+    const patchText2 = nonBlankStringValue(item.patchText) ?? nonBlankStringValue(item.patch) ?? patchTextFromFileChangeEntries(changes);
+    if (patchText2 === void 0) {
+      return void 0;
+    }
+    return {
+      itemKey: stringValue(item.id) ?? "file-change",
+      turnId,
+      patchText: patchText2
+    };
+  }
+  if (stringValue(item.type) !== "custom_tool_call" || stringValue(item.name) !== "apply_patch" || status !== void 0 && status !== "completed") {
+    return void 0;
+  }
+  const patchText = applyPatchTextFromValue(item.input) ?? applyPatchTextFromValue(item.arguments);
+  if (patchText === void 0) {
+    return void 0;
+  }
+  return {
+    itemKey: stringValue(item.call_id) ?? stringValue(item.id) ?? "file-change",
+    turnId,
+    patchText
+  };
+}
 function codexFileChangeStructuredMessage(itemKey, patchText, streamState, status) {
   return {
     kind: "codex_file_change",
@@ -18413,20 +18442,20 @@ function commandMessageForFunctionCall(item, output, index) {
 function messageForCustomToolCall(item, output, index) {
   const name = stringValue(item.name) ?? "custom_tool_call";
   const itemKey = stringValue(item.call_id) ?? stringValue(item.id) ?? `item-${index}`;
-  const input = nonBlankStringValue(item.input) ?? nonBlankStringValue(item.arguments) ?? "";
   if (name === "apply_patch") {
+    const patchText = applyPatchTextFromValue(item.input) ?? applyPatchTextFromValue(item.arguments) ?? "";
     return [
       {
         itemKey,
-        body: input,
+        body: patchText,
         structured: {
           kind: "codex_file_change",
           item_id: itemKey,
           transcript_unit_id: `codex_file_change:${itemKey}`,
           stream_state: "completed",
           status: output === void 0 ? "started" : "completed",
-          patch_text: input,
-          changes: fileChangesFromPatch(input)
+          patch_text: patchText,
+          changes: fileChangesFromPatch(patchText)
         }
       }
     ];
@@ -18477,43 +18506,120 @@ function toolOutputText(item) {
   }
   return nonBlankStringValue(item.output) ?? nonBlankStringValue(item.result) ?? nonBlankStringValue(item.content) ?? "";
 }
-function fileChangesFromPatch(patchText) {
-  return patchText.split("\n").flatMap((line) => {
-    const updatePrefix = "*** Update File: ";
-    const addPrefix = "*** Add File: ";
-    const deletePrefix = "*** Delete File: ";
-    if (line.startsWith(updatePrefix)) {
-      return [
-        {
-          path: line.slice(updatePrefix.length).trim(),
-          diff: "",
-          kind: "update",
-          move_path: ""
-        }
-      ];
-    }
-    if (line.startsWith(addPrefix)) {
-      return [
-        {
-          path: line.slice(addPrefix.length).trim(),
-          diff: "",
-          kind: "add",
-          move_path: ""
-        }
-      ];
+function patchTextFromFileChangeEntries(changes) {
+  if (changes.length === 0) {
+    return void 0;
+  }
+  const body = changes.flatMap((change) => {
+    const path2 = stringValue(change.path);
+    if (path2 === void 0 || path2.trim() === "") {
+      return [];
     }
-    if (line.startsWith(deletePrefix)) {
-      return [
-        {
-          path: line.slice(deletePrefix.length).trim(),
-          diff: "",
-          kind: "delete",
-          move_path: ""
+    const kind = stringValue(change.kind);
+    const header = kind === "add" ? `*** Add File: ${path2}` : kind === "delete" ? `*** Delete File: ${path2}` : `*** Update File: ${path2}`;
+    const diff = nonBlankStringValue(change.diff);
+    return diff === void 0 ? [header] : [header, diff];
+  }).join("\n");
+  return body === "" ? void 0 : `*** Begin Patch
+${body}
+*** End Patch
+`;
+}
+function fileChangesFromPatch(patchText) {
+  const finalState = patchText.split("\n").reduce(
+    (state, line) => {
+      const header = patchHeaderForLine(line);
+      if (header !== void 0) {
+        return {
+          changes: appendParsedPatchChange(state.changes, state.current),
+          current: {
+            path: header.path,
+            kind: header.kind,
+            movePath: "",
+            diffLines: []
+          }
+        };
+      }
+      if (line.startsWith("*** Move to: ")) {
+        const movePath = line.slice("*** Move to: ".length).trim();
+        return {
+          ...state,
+          current: state.current === void 0 ? void 0 : { ...state.current, movePath }
+        };
+      }
+      if (line === "*** Begin Patch" || line === "*** End Patch" || line.startsWith("*** ")) {
+        return state;
+      }
+      return {
+        ...state,
+        current: state.current === void 0 ? void 0 : {
+          ...state.current,
+          diffLines: [...state.current.diffLines, line]
         }
-      ];
-    }
-    return [];
-  });
+      };
+    },
+    { changes: [], current: void 0 }
+  );
+  return appendParsedPatchChange(finalState.changes, finalState.current).map(
+    (change) => ({
+      path: change.path,
+      diff: trimDiffLines(change.diffLines),
+      kind: change.kind,
+      move_path: change.movePath
+    })
+  );
+}
+function patchHeaderForLine(line) {
+  const updatePrefix = "*** Update File: ";
+  const addPrefix = "*** Add File: ";
+  const deletePrefix = "*** Delete File: ";
+  if (line.startsWith(updatePrefix)) {
+    return {
+      path: line.slice(updatePrefix.length).trim(),
+      kind: "update"
+    };
+  }
+  if (line.startsWith(addPrefix)) {
+    return {
+      path: line.slice(addPrefix.length).trim(),
+      kind: "add"
+    };
+  }
+  if (line.startsWith(deletePrefix)) {
+    return {
+      path: line.slice(deletePrefix.length).trim(),
+      kind: "delete"
+    };
+  }
+  return void 0;
+}
+function appendParsedPatchChange(changes, change) {
+  if (change === void 0 || change.path.trim() === "") {
+    return [...changes];
+  }
+  return [...changes, change];
+}
+function trimDiffLines(lines) {
+  const firstContentIndex = lines.findIndex((line) => line.trim() !== "");
+  if (firstContentIndex < 0) {
+    return "";
+  }
+  const lastContentIndexFromEnd = [...lines].reverse().findIndex((line) => line.trim() !== "");
+  const end = lastContentIndexFromEnd < 0 ? lines.length : lines.length - lastContentIndexFromEnd;
+  return lines.slice(firstContentIndex, end).join("\n");
+}
+function codexItemTypeIsFileChange(item) {
+  const itemType = stringValue(item.type);
+  return itemType === "fileChange" || itemType === "file_change";
+}
+function applyPatchTextFromValue(value) {
+  const text2 = nonBlankStringValue(value);
+  if (text2 !== void 0) {
+    const parsed = parseJsonObjectOrUndefined(text2);
+    return nonBlankStringValue(parsed?.patch) ?? nonBlankStringValue(parsed?.input) ?? nonBlankStringValue(parsed?.text) ?? text2;
+  }
+  const object = objectValue(value);
+  return nonBlankStringValue(object?.patch) ?? nonBlankStringValue(object?.input) ?? nonBlankStringValue(object?.text);
 }
 function webSearchQueriesForItem(item) {
   const action = objectValue(item.action);
@@ -19192,7 +19298,13 @@ import { basename as basename2 } from "node:path";
 var defaultIntervalMs = 2e3;
 var defaultDebounceMs = 750;
 function startPortForwardWatcher(options) {
-  const rootPid = options.rootPid ?? process.pid;
+  if (options.rootPid === void 0) {
+    throw new Error("port_forward_watcher_root_pid_missing");
+  }
+  if (!Number.isInteger(options.rootPid) || options.rootPid <= 0) {
+    throw new Error("port_forward_watcher_root_pid_invalid");
+  }
+  const rootPid = options.rootPid;
   const intervalMs = options.intervalMs ?? defaultIntervalMs;
   const debounceMs = options.debounceMs ?? defaultDebounceMs;
   const lostDebounceMs = options.lostDebounceMs ?? intervalMs * 2 + debounceMs;
@@ -19314,7 +19426,7 @@ function stableForwardCandidates(previousObservedByPort, candidates, nowMs, debo
   return { nextObservedByPort, stableCandidates };
 }
 function sameForwardCandidate(left, right) {
-  return left.port === right.port && left.pid === right.pid && left.command === right.command && left.cwd === right.cwd;
+  return left.port === right.port && left.pid === right.pid;
 }
 function descendantPidSet(rows, rootPid) {
   const childrenByParent = /* @__PURE__ */ new Map();
@@ -19480,16 +19592,6 @@ function reviewPortForwardCandidate(options) {
   if (!options.threadBound) {
     return { type: "skip", reason: "thread_not_bound" };
   }
-  if (options.suppressedPorts?.has(options.candidate.port) === true) {
-    return { type: "skip", reason: "suppressed_port" };
-  }
-  if (isInternalCodexProcess(options.candidate)) {
-    return { type: "skip", reason: "internal_codex_process" };
-  }
-  const dismissedTarget = options.dismissedTargets?.get(options.candidate.port);
-  if (dismissedTarget !== void 0 && sameDismissedPortForwardTarget(dismissedTarget, options.candidate)) {
-    return { type: "skip", reason: "recently_dismissed" };
-  }
   if (options.approvedPorts.has(options.candidate.port)) {
     const approvedTarget = options.approvedTargets.get(options.candidate.port);
     if (approvedTarget === void 0) {
@@ -19568,12 +19670,6 @@ function revocationCapabilities(capabilities, port) {
     revokedPorts: [port]
   };
 }
-function sameDismissedPortForwardTarget(left, right) {
-  return left.port === right.port && left.command === right.command && left.cwd === right.cwd;
-}
-function isInternalCodexProcess(candidate) {
-  return commandLabel(candidate.command) === "codex";
-}
 
 // src/processNameCatalog.ts
 var processCatalogEntries = [
@@ -20259,20 +20355,21 @@ async function attachChannelSession(args) {
     handleCodexNotification: (method, params) => {
       const turnId = codexNotificationTurnId(params);
       const threadId = codexNotificationThreadId(params);
-      if (codexNotificationBelongsToSession(state, threadId, turnId)) {
+      const routedTurnId = turnId ?? codexNotificationActiveTurnFallback(method, state, params);
+      if (codexNotificationBelongsToSession(state, threadId, routedTurnId)) {
         const processingReason = processingReasonForCodexNotification(
           method,
           params
         );
-        if (turnId !== void 0 && processingReason !== void 0) {
+        if (routedTurnId !== void 0 && processingReason !== void 0) {
           void refreshActiveProcessingState(
             args,
             state,
-            turnId,
+            routedTurnId,
             processingReason
           ).catch((error) => {
             args.log("kandan.message_state_refresh_failed", {
-              turn_id: turnId,
+              turn_id: routedTurnId,
               reason: processingReason,
               message: error instanceof Error ? error.message : String(error)
             });
@@ -20341,6 +20438,7 @@ async function attachChannelSession(args) {
             break;
           case "item/completed":
             enqueueWebSearchProgress(args, state, params, payloadContext);
+            enqueueCompletedFileChange(args, state, params, payloadContext);
             if (turnId !== void 0) {
               const promise = mirrorLocalTuiInputFromNotification(
                 args,
@@ -20358,6 +20456,9 @@ async function attachChannelSession(args) {
               }).finally(() => forgetPendingTuiInputMirror(state, turnId));
             }
             break;
+          case "response_item":
+            enqueueCompletedFileChange(args, state, params, payloadContext);
+            break;
         }
       }
     },
@@ -20448,6 +20549,7 @@ function initialChannelSessionState(cursor, rootSeq, kandanThreadId, codexThread
     webSearchProgressOutputs: createBoundedCache(maxForwardedTurnIds),
     pendingApprovalRequests: /* @__PURE__ */ new Map(),
     approvalPromptChain: Promise.resolve(),
+    approvedThreadInteractionRequesters: /* @__PURE__ */ new Set(),
     pendingPortForwardRequests: /* @__PURE__ */ new Map(),
     portForwardPreviousProcessingStates: /* @__PURE__ */ new Map(),
     queuedPortForwardCandidates: /* @__PURE__ */ new Map(),
@@ -20497,6 +20599,12 @@ function startPortForwardWatchIfEnabled(args, state, payloadContext) {
     return;
   }
   const { start: configuredStart, ...watchOptions } = args.options.portForwardWatcher ?? {};
+  if (configuredStart === void 0 && watchOptions.rootPid === void 0) {
+    args.log("port_forward.watch_skipped", {
+      reason: "worker_pid_missing"
+    });
+    return;
+  }
   const start = configuredStart ?? startPortForwardWatcher;
   for (const port of args.options.initialForwardPorts ?? []) {
     state.approvedForwardPorts.add(port);
@@ -20572,6 +20680,9 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
       control
     );
   }
+  if (control.type === "update_thread_interaction_access") {
+    return updateThreadInteractionAccess(args, state, control);
+  }
   if (control.type !== "interrupt_queued_messages") {
     return void 0;
   }
@@ -20639,6 +20750,76 @@ async function handleChannelSessionControl(args, state, payloadContext, control)
     interruptedQueuedMessages: interrupted.ok ? interrupted.selectedCount : 0
   };
 }
+async function updateThreadInteractionAccess(args, state, control) {
+  const requesterKeys = threadInteractionRequesterKeys(control);
+  if (state.kandanThreadId !== control.threadId) {
+    args.log("thread_interaction.access_update_ignored", {
+      thread_id: control.threadId,
+      expected_thread_id: state.kandanThreadId ?? null,
+      requester_slug: control.requesterSlug ?? null,
+      requester_user_id: control.requesterUserId ?? null,
+      reason: "different_thread"
+    });
+    return {
+      instanceId: args.instanceId,
+      ok: false,
+      error: "different_thread"
+    };
+  }
+  if (requesterKeys.length === 0) {
+    args.log("thread_interaction.access_update_ignored", {
+      thread_id: control.threadId,
+      requester_slug: control.requesterSlug ?? null,
+      requester_user_id: control.requesterUserId ?? null,
+      reason: "missing_requester"
+    });
+    return {
+      instanceId: args.instanceId,
+      ok: false,
+      error: "missing_requester"
+    };
+  }
+  for (const requesterKey of requesterKeys) {
+    if (control.grant) {
+      state.approvedThreadInteractionRequesters.add(requesterKey);
+    } else {
+      state.approvedThreadInteractionRequesters.delete(requesterKey);
+    }
+  }
+  args.log("thread_interaction.access_updated", {
+    thread_id: control.threadId,
+    requester_slug: control.requesterSlug ?? null,
+    requester_user_id: control.requesterUserId ?? null,
+    grant: control.grant
+  });
+  return {
+    instanceId: args.instanceId,
+    ok: true,
+    grant: control.grant
+  };
+}
+function threadInteractionRequesterKeys(args) {
+  if (args.threadId === void 0) {
+    return [];
+  }
+  const keys = [];
+  if (args.requesterUserId !== void 0) {
+    keys.push(`${args.threadId}:user:${args.requesterUserId}`);
+  }
+  if (args.requesterSlug !== void 0 && args.requesterSlug.trim() !== "") {
+    keys.push(`${args.threadId}:slug:${args.requesterSlug}`);
+  }
+  return keys;
+}
+function threadInteractionSenderAllowed(state, event) {
+  return threadInteractionRequesterKeys({
+    threadId: event.threadId,
+    requesterUserId: event.actorUserId,
+    requesterSlug: event.actorSlug
+  }).some(
+    (requesterKey) => state.approvedThreadInteractionRequesters.has(requesterKey)
+  );
+}
 async function updateSessionSettings(args, state, payloadContext, control) {
   if (state.codexThreadId !== control.threadId) {
     return void 0;
@@ -21337,13 +21518,16 @@ function parsePortForwardDecision(body) {
 }
 async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext, event) {
   const session = args.options.channelSession;
-  if (event.type !== "thread.message" || event.threadId === void 0 || event.body.trim() === "" && event.attachments.length === 0) {
-    args.log("kandan.message_ignored", {
-      seq: event.seq,
-      actor_slug: event.actorSlug ?? null,
-      actor_user_id: event.actorUserId ?? null,
-      reason: "not_thread_message_or_empty"
-    });
+  if (event.type !== "thread.message") {
+    logIgnoredKandanMessage(args, event, "non_thread_message_event");
+    return;
+  }
+  if (event.threadId === void 0) {
+    logIgnoredKandanMessage(args, event, "missing_thread_id");
+    return;
+  }
+  if (event.body.trim() === "" && event.attachments.length === 0) {
+    logIgnoredKandanMessage(args, event, "empty_thread_message");
     return;
   }
   if (isCodexAuthoredEvent(event)) {
@@ -21355,7 +21539,7 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
     });
     return;
   }
-  if (!senderAllowed(session.listenUser, event, runnerIdentity)) {
+  if (!senderAllowed(session.listenUser, event, runnerIdentity) && !threadInteractionSenderAllowed(state, event)) {
     args.log("kandan.message_ignored", {
       seq: event.seq,
       actor_slug: event.actorSlug ?? null,
@@ -21466,6 +21650,19 @@ async function handleKandanChatEvent(args, state, runnerIdentity, payloadContext
   await publishKandanMessageState(args, event, { status: "queued" });
   await drainKandanMessageQueue(args, state, payloadContext);
 }
+function logIgnoredKandanMessage(args, event, reason) {
+  args.log("kandan.message_ignored", {
+    seq: event.seq,
+    type: event.type,
+    thread_id: event.threadId ?? null,
+    actor_slug: event.actorSlug ?? null,
+    actor_user_id: event.actorUserId ?? null,
+    body_length: event.body.length,
+    attachment_count: event.attachments.length,
+    local_runner_event_type: event.localRunnerEventType ?? null,
+    reason
+  });
+}
 function kandanMessageClaimKey(args, threadId, seq) {
   const session = args.options.channelSession;
   return [
@@ -22079,6 +22276,7 @@ function completedOutputProjectionsForTurn(state, turnId, messages) {
     }),
     ...cachedOutputs.map((output) => output.sortOrder)
   ]);
+  const fallbackSnapshotPositions = fallbackSnapshotOutputPositions(snapshotOutputs);
   const orderedSnapshotOutputs = snapshotOutputs.map((output) => {
     switch (output.match.kind) {
       case "none":
@@ -22086,7 +22284,7 @@ function completedOutputProjectionsForTurn(state, turnId, messages) {
           ...output,
           sortOrder: fallbackSnapshotOutputOrder(
             fallbackSortOrderBase,
-            output.snapshotIndex
+            fallbackSnapshotPosition(fallbackSnapshotPositions, output)
           )
         };
       case "assistant":
@@ -22288,8 +22486,44 @@ function compareCompletedOutputProjection(left, right) {
 function fallbackSnapshotOutputBase(sortOrders) {
   return sortOrders.reduce((max, sortOrder) => Math.max(max, sortOrder), 0) + 1;
 }
-function fallbackSnapshotOutputOrder(base, snapshotIndex) {
-  return base + snapshotIndex;
+function fallbackSnapshotOutputOrder(base, fallbackPosition) {
+  return base + fallbackPosition;
+}
+function fallbackSnapshotOutputPositions(outputs) {
+  const unmatched = outputs.filter((output) => output.match.kind === "none");
+  const firstAssistantIndex = unmatched.findIndex(
+    (output) => stringValue(output.message.structured.kind) === "codex_assistant_message"
+  );
+  if (firstAssistantIndex < 0) {
+    return snapshotOutputPositionMap(unmatched);
+  }
+  const beforeFirstAssistant = unmatched.slice(0, firstAssistantIndex);
+  const afterFirstAssistant = unmatched.slice(firstAssistantIndex);
+  const fileChangesAfterAssistant = afterFirstAssistant.filter(
+    (output) => stringValue(output.message.structured.kind) === "codex_file_change"
+  );
+  const remainingAfterAssistant = afterFirstAssistant.filter(
+    (output) => stringValue(output.message.structured.kind) !== "codex_file_change"
+  );
+  return snapshotOutputPositionMap([
+    ...beforeFirstAssistant,
+    ...fileChangesAfterAssistant,
+    ...remainingAfterAssistant
+  ]);
+}
+function snapshotOutputPositionMap(outputs) {
+  return new Map(
+    outputs.map((output, position) => [output.snapshotIndex, position])
+  );
+}
+function fallbackSnapshotPosition(positions, output) {
+  const position = positions.get(output.snapshotIndex);
+  if (position === void 0) {
+    throw new Error(
+      `Missing fallback completed-output position for snapshot index ${output.snapshotIndex}`
+    );
+  }
+  return position;
 }
 function structuredOutputMatchKey(kind, itemKey) {
   return `${kind}:${itemKey}`;
@@ -22527,6 +22761,27 @@ function enqueueFileChangeCompletion(args, state, turnId) {
     });
   });
 }
+function enqueueCompletedFileChange(args, state, params, payloadContext) {
+  const delta = codexCompletedFileChangeFromNotification(params);
+  if (delta === void 0) {
+    return;
+  }
+  flushStreamDeltaQueue(
+    state.fileChangeQueue,
+    fileChangeQueueRuntime(args, state, payloadContext)
+  );
+  const previous = state.fileChangeQueue.chain;
+  const next = previous.catch(() => void 0).then(
+    () => forwardCompletedFileChangePayload(args, state, delta, payloadContext)
+  );
+  state.fileChangeQueue.chain = next.catch((error) => {
+    args.log("codex.completed_file_change_forward_failed", {
+      turn_id: delta.turnId ?? null,
+      item_key: delta.itemKey,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  });
+}
 async function forwardReasoningDeltaPayload(args, state, delta, payloadContext) {
   if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     return;
@@ -22794,6 +23049,87 @@ async function forwardFileChangeDeltaPayload(args, state, delta, payloadContext)
     patch_length: patchText.length
   });
 }
+async function forwardCompletedFileChangePayload(args, state, delta, payloadContext) {
+  if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
+    return;
+  }
+  const turnId = delta.turnId ?? activeTurnId(state.turn);
+  if (turnId === void 0 || turnIsFinalizingOrForwarded(state, turnId)) {
+    return;
+  }
+  const sourceMessageSeq = sourceMessageSeqForTurn(state, turnId);
+  if (sourceMessageSeq === void 0) {
+    args.log("codex.completed_file_change_without_source_message", {
+      turn_id: turnId,
+      item_key: delta.itemKey
+    });
+    return;
+  }
+  const structured = codexFileChangeStructuredMessage(
+    delta.itemKey,
+    delta.patchText,
+    "completed",
+    "completed"
+  );
+  const existing = findStreamingFileChangeOutput(state, delta.itemKey);
+  if (existing === void 0) {
+    const session = args.options.channelSession;
+    const reply = await pushOk2(
+      args.kandan,
+      args.topic,
+      "session:post_thread_message",
+      {
+        workspace: session.workspaceSlug,
+        channel: session.channelSlug,
+        thread_id: state.kandanThreadId,
+        body: delta.patchText,
+        payload: {
+          ...localRunnerPayload(
+            args.options,
+            args.instanceId,
+            "codex_output",
+            state.codexThreadId,
+            payloadContext,
+            sourceMessageSeq
+          ),
+          ...state.rootSeq === void 0 ? {} : { reply_to_seq: state.rootSeq },
+          structured
+        },
+        client_message_id: streamingClientMessageId(args.instanceId, {
+          itemKey: `file-change:${delta.itemKey}`,
+          turnId
+        })
+      }
+    );
+    const seq = integerValue(reply.seq);
+    if (seq !== void 0) {
+      rememberStreamingFileChangeOutput(state, {
+        itemKey: delta.itemKey,
+        turnId,
+        seq,
+        patchText: delta.patchText
+      });
+    }
+  } else {
+    await editCodexStructuredOutput(
+      args,
+      state,
+      existing.seq,
+      delta.patchText,
+      structured
+    );
+    rememberStreamingFileChangeOutput(state, {
+      ...existing,
+      turnId: existing.turnId ?? turnId,
+      patchText: delta.patchText
+    });
+  }
+  args.log("kandan.codex_file_change_forwarded", {
+    item_key: delta.itemKey,
+    turn_id: turnId,
+    patch_length: delta.patchText.length
+  });
+}
 async function forwardTerminalInput(args, state, params, payloadContext) {
   if (state.kandanThreadId === void 0 || state.codexThreadId === void 0) {
     return;
@@ -23342,6 +23678,12 @@ function codexNotificationBelongsToSession(state, threadId, turnId) {
   }
   return activeTurnId(state.turn) === turnId || isLocalTuiTurn(state, turnId);
 }
+function codexNotificationActiveTurnFallback(method, state, params) {
+  if (method !== "response_item" || codexCompletedFileChangeFromNotification(params) === void 0) {
+    return void 0;
+  }
+  return activeTurnId(state.turn);
+}
 function rememberLocalTuiTurnIfNeeded(args, state, threadId, turnId) {
   if (args.options.launchTui !== true || state.codexThreadId !== threadId || state.turn.status !== "idle") {
     return;
@@ -24598,6 +24940,9 @@ function defaultCliAuditLogFile() {
   const override = process.env.LINZUMI_CLI_AUDIT_LOG?.trim();
   return override === void 0 || override === "" ? join3(homedir2(), ".linzumi", "logs", "command-events.jsonl") : override;
 }
+function defaultRunnerLogFile() {
+  return join3(homedir2(), ".linzumi", "logs", "runner-events.jsonl");
+}
 function redactForCliLog(value) {
   return redactObject(value);
 }
@@ -28295,7 +28640,7 @@ function realpathOrResolved(pathValue) {
 }
 
 // src/version.ts
-var linzumiCliVersion = "0.0.63-beta";
+var linzumiCliVersion = "0.0.64-beta";
 var linzumiCliVersionText = `linzumi ${linzumiCliVersion}`;
 
 // src/runnerLock.ts
@@ -28565,7 +28910,7 @@ function formatRunnerConsoleEvent(event, payload) {
         "This process is exiting."
       ].join("\n");
     case "kandan.message_ignored":
-      return `Incoming message from ${sender(payload)}: ignored for reason ${text(payload.reason)}`;
+      return ignoredMessage(payload);
     case "kandan.message_queued":
       return `Incoming message from ${sender(payload)}: queued seq=${text(payload.seq)} depth=${text(payload.queue_depth)}`;
     case "kandan.chat_event_failed":
@@ -28613,6 +28958,22 @@ function optionalLine(label, value) {
   const normalized = stringValue2(value) ?? numberValue(value)?.toString();
   return normalized === void 0 ? void 0 : `${label}: ${normalized}`;
 }
+function optionalField(label, value) {
+  const normalized = stringValue2(value) ?? numberValue(value)?.toString();
+  return normalized === void 0 ? void 0 : `${label}=${normalized}`;
+}
+function ignoredMessage(payload) {
+  return [
+    `Incoming message from ${sender(payload)}: ignored`,
+    optionalField("seq", payload.seq),
+    `reason=${text(payload.reason)}`,
+    optionalField("type", payload.type),
+    optionalField("thread", payload.thread_id),
+    optionalField("body_chars", payload.body_length),
+    optionalField("attachments", payload.attachment_count),
+    optionalField("local_event", payload.local_runner_event_type)
+  ].filter((part) => part !== void 0).join(" ");
+}
 function replacementLines(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -29945,9 +30306,16 @@ async function openLocalCodexRunner(options, log, cleanup, close) {
     if (claudeCodeForwardSessions.has(args.sessionId)) {
       return;
     }
+    if (options.portForwardWatcher === void 0) {
+      log("port_forward.claude_code_watch_skipped", {
+        reason: "worker_pid_missing",
+        claude_session_id: args.sessionId
+      });
+      return;
+    }
     const session = {
       ...args,
-      watcher: (options.portForwardWatcher ?? startPortForwardWatcher)({
+      watcher: options.portForwardWatcher({
         onCandidate: (candidate) => publishClaudeCodeForwardPortPrompt(session, candidate),
         onCandidateLost: (candidate) => expireLostClaudeCodeForwardCandidate(session, candidate),
         onError: (error) => {
@@ -30779,7 +31147,8 @@ function controlThreadId(control) {
     case "forward_http_request":
     case "forward_tcp_open":
     case "forward_tcp_send":
-    case "forward_tcp_close": {
+    case "forward_tcp_close":
+    case "update_thread_interaction_access": {
       const threadId = stringValue(control.threadId)?.trim();
       return threadId === void 0 || threadId === "" ? void 0 : threadId;
     }
@@ -30788,6 +31157,23 @@ function controlThreadId(control) {
   }
 }
 async function resolveSessionControl(channelSession, dynamicChannelSessions, control) {
+  const targetThreadId = controlThreadId(control);
+  if (targetThreadId !== void 0) {
+    const targetDynamicSession = dynamicChannelSessions.get(targetThreadId);
+    const targetSessions = [
+      ...channelSession?.currentKandanThreadId() === targetThreadId ? [channelSession] : [],
+      ...targetDynamicSession !== void 0 && targetDynamicSession !== channelSession ? [targetDynamicSession] : []
+    ].filter(
+      (session) => session !== void 0
+    );
+    for (const session of targetSessions) {
+      const handled = await session.handleControl(control);
+      if (handled !== void 0) {
+        return handled;
+      }
+    }
+    return void 0;
+  }
   const primaryHandled = await (channelSession?.handleControl(control) ?? Promise.resolve(void 0));
   if (primaryHandled !== void 0) {
     return primaryHandled;
@@ -30850,7 +31236,7 @@ function replacementRunnerSummaries(value) {
 }
 function makeRunnerLogger(options) {
   return createRunnerLogger(
-    options.logFile ?? join10(options.cwd, ".linzumi-runner.log"),
+    options.logFile ?? defaultRunnerLogFile(),
     options.launchTui ? void 0 : reportRunnerConsoleEvent
   );
 }
@@ -31641,6 +32027,7 @@ async function applyControl(codex, kandan, topic, instanceId, options, agentProv
     case "stop_instance":
     case "kill_instance":
     case "resolve_port_forward_request":
+    case "update_thread_interaction_access":
     case "update_session_settings":
     case "set_port_forward_enabled":
     case "forward_http_request":
@@ -54361,7 +54748,7 @@ Codex:
                               Auto-approve detected port-forward candidates for started sessions
   --stream-flush-ms <ms>      Batch live Codex deltas before Linzumi persistence, default 150
   --fast                      Mark this runner as low-latency/fast in the availability message
-  --log-file <path>           JSONL event log path, default <cwd>/.linzumi-runner.log
+  --log-file <path>           JSONL event log path, default ~/.linzumi/logs/runner-events.jsonl
   --allowed-cwd <paths>       Extra comma-separated roots where Linzumi may start local Codex sessions
   --forward-port <ports>      Comma-separated local TCP ports Linzumi may expose as authenticated previews
   --code-server-bin <path>    Custom development code-server executable. The default editor runtime is downloaded from Linzumi.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linzumi/cli",
-  "version": "0.0.63-beta",
+  "version": "0.0.64-beta",
   "description": "Linzumi CLI — point a Codex agent at the real code on your laptop, with your team watching and steering from shared threads.",
   "type": "module",
   "bin": {