@nowcrew/daemon 0.6.13 → 0.6.15

package/dist/prompt.js

@@ -82,7 +82,7 @@ export function buildSystemPrompt(ctx) {
     // 消息、没有 task,这条规则字面上无法执行,省略(2026-07-13 复审 Minor 5)。
     const claimRule = scheduled
         ? ""
-        : "\n- **除定时任务创建与管理外,动手干活前必须先 `crew task claim`**;claim 失败就转做别的任务。";
+        : "\n- **除定时任务创建与管理和 memory_prune 外,动手干活前必须先 `crew task claim`**;claim 失败就转做别的任务。";
     // "一线程一 task 且必须带 --thread"与"进度/产出回本线程,严禁发到顶层"都建立在"本轮有一条
     // 触发消息、线程根即为该消息 id"这个前提上——scheduled run 没有触发消息、没有 thread 锚点,
     // 唯一输出路径就是频道顶层 `--send-draft`,与这两条正面矛盾且 --thread 参数根本填不出来,
@@ -114,14 +114,14 @@ export function buildSystemPrompt(ctx) {
         : "- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**";
     const actionRule = scheduled
         ? `- **判定规则**:直接执行本轮定时指令,执行前不需要 claim。${threadTaskRule}${progressRule}`
-        : `- **判定规则**:定时任务创建与管理直接按上节执行,无需 task claim;其它来信若需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。${threadTaskRule}${progressRule}`;
+        : `- **判定规则**:定时任务创建与管理和 memory_prune 无需 task claim,只遵守各自唤醒指令;其它来信若需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。${threadTaskRule}${progressRule}`;
     const taskAndScheduleCommands = alwaysReport
         ? `4. **\`crew task create --channel <id> --title "<标题>"\`** —— 仅为本轮发现的具体后续事项创建任务;本轮没有线程锚点,不要传 \`--thread\`。`
         : scheduled
             ? `5. **\`crew task create --channel <id> --title "<标题>"\`** —— 仅为本轮发现的具体后续事项创建任务;本轮没有线程锚点,不要传 \`--thread\`。`
             : `5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
 6. **\`crew task create --channel <id> --title "<标题>" --thread <当前线程根msgId>\`** —— 新建任务并**绑定到当前线程**。\`--thread\` 传你读到的那条**触发消息 id**(线程根),任务就和讨论同处一个线程。省略 \`--thread\` 会另起新线程,**几乎总是错的——务必带上**。
-7. **\`crew task claim <taskId>\`** —— 除定时任务创建与管理外,执行需要动作的工作前先认领任务。
+7. **\`crew task claim <taskId>\`** —— 除定时任务创建与管理和 memory_prune 外,执行需要动作的工作前先认领任务。
 8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
 9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
 10. **\`crew task assign <taskId> --to <handle>\`** —— 把任务指派/交接给另一个 agent(用于交接,见下)。
@@ -176,7 +176,7 @@ ${taskAndScheduleCommands}`;
 ## 协作礼仪
 - **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
 - **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
-- **除定时任务创建与管理外,claim 后再动手**:claim 失败立即停手,换一个任务。
+- **除定时任务创建与管理和 memory_prune 外,claim 后再动手**:claim 失败立即停手,换一个任务。
 - **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
 - **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。`;
     // 对人说话:约束的是"表达方式",不是"执行规则"——claim/thread/freshness 等操作协议照常执行,
@@ -234,8 +234,15 @@ ${taskAndScheduleCommands}`;
 
 ## 并行与记忆(CRITICAL — 防冲突 + 防上下文膨胀)
 你**可能同时在处理多个任务**(你自己的多个并行进程)。为避免互相覆盖、并保持上下文精简,严格遵守:
-- **只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
-- **普通任务进行中不要改 \`$CREW_HOME/MEMORY.md\` 或 notes/**(那是共享文件,多个并行运行同时写会冲突)。这些只读参考;任务 done/closed 后的专门收尾执行才按收尾指令写入功能明细和索引。
+- **普通任务默认只写两处**:① 本任务的隔离 cwd(代码/草稿);② 本任务的工作日志 **\`$CREW_TASK_LOG\`**(每任务一份,别人不会碰)。默认不要修改共享 \`$CREW_HOME/MEMORY.md\` 或 notes/;只有当前用户明确要求更新或记住长期记忆,或明确表达具体且跨后续任务持续生效的规则、偏好或约束时,才按下方条件写入相关共享文件。在工作日志里记:当前阶段 / 下一步 / 卡在谁 / 关键结论(每条尽量 ≤3 行)。
+- **当前请求明确要求更新或记住长期记忆,明确表达需要跨后续任务持续生效的具体规则、偏好或约束,或当前消息是对本线程紧邻记忆方案的无歧义确认时**,可以按最小范围直接写共享记忆。例如“以后所有测试报告统一按五部分写”属于明确长期意图,即使没有使用“记忆”一词。先读取相关索引和 note,语义已存在时不重复追加,不要把 Agent 自己判断值得记住视为用户授权。
+- 本节的直接更新共享记忆和相关 task 流转仅适用于用户消息触发的普通交互执行。memory_prune 和 scheduled 执行只遵守各自唤醒指令,不得依据本节认领、创建、重开或推进 task。
+- 普通交互执行将写共享记忆时,使用当前线程唯一的普通 task:已有非终态 task 时先按归属规则确保当前 Agent 成功认领;当前线程没有 task 时先创建并认领一个普通 task;已有 task 为 done/closed 时不得由 Agent 重开,done 报告当前轻量方案无法安全复用终态 task,closed 保持人工终态。遇到终态或归属问题时报告冲突且不得创建第二个 task 或新的任务类型。完成写入后,只有任务本身的全部工作已完成时才推进终态以触发 prune。
+- 提出共享记忆修改方案并等待用户确认时,该 task 仍有剩余工作,保持 in_review 或其它非终态;收到无歧义确认后再执行写入,并仅在全部工作完成后推进终态。
+- 普通执行直接更新后，仍然保留任务结束后的专门收尾执行,不因已经写过而跳过 prune。
+- 新建 note 必须说明现有分类为何不适用；MEMORY.md 默认只更新 Knowledge Index，不得默认修改 Role、Core Goals 或 Active Context；只有用户明确要求或任务本身就是档案/状态维护时例外。
+- 仅对本次或当前任务生效的要求不持久化。未明确要求、记忆意图含糊或仅由 Agent 自己判断值得记住时,不直接写共享记忆,也不把含糊内容写成长期记忆候选。例如“以后注意一下”等缺少具体内容或适用范围的表达仍属于含糊意图。含糊表达本身不作为长期记忆候选,但不得因此跳过整个 task 的 memory_prune;任务按正常状态流程完成。收尾只能处理该任务其它符合现有收尾规则的稳定内容,不允许让收尾代替用户补充记忆授权。
+- 若用户明确要求本次不要修改共享记忆,同样不写共享记忆或长期记忆候选。任务尚未完成时,把该禁止要求作为运行状态写入 $CREW_TASK_LOG;该运行状态不是长期记忆候选,后续执行必须保留该状态。若用户之后在同一任务中明确撤销禁止,移除该运行状态并按最新明确授权处理。完成 task 前检查该状态:Agent 可自行改状态时,使用 crew task update <taskId> --status done --skip-memory-prune。CLI 返回状态由 Server 管理时沿用上述 Server 管理任务的安全回退:不重试、不绕过权限;收尾会读取该运行状态并禁止共享记忆写入,但本路径不提供机器级 skip 保证。不要只在回复里声明不修改。
 - **跨任务协调看实时清单**:用 \`crew task list --mine\` 查你当前所有任务及其状态(谁在排队、谁在评审)。例:你一次只能测一个页面时,据此判断"正在测 #1、#2 排队",在 #2 的工作日志里标注"等 #1 完成"。
 - 需要更多背景时再 \`Read $CREW_HOME/notes/<topic>.md\`;不要一次把所有笔记读进上下文。
 
@@ -261,7 +268,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),按“常驻索引 + 功能明细 + 当前工作”分层:
 1. **MEMORY.md = 常驻索引 + 角色**:系统每次已把它(截断索引版)注入本提示词末尾。索引条目包含 \`file/type/scope/summary/triggers/priority/updated\`,其中 file 是相对于 \`$CREW_HOME\` 的路径(例如 \`notes/testing.md\`),先用这些字段判断当前问题是否相关;通常不必再读整份 MEMORY.md。
-2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。**普通任务进行中只读不写**(多个并行运行同时写会冲突);任务结束后的专门收尾执行按收尾指令写入。
+2. **notes/<topic>.md = 功能明细**:按用户偏好、项目规则、测试、调试、Git、事故复盘等主题拆分。优先读取与当前任务匹配的文件;\`notes/lessons.md\` 只保留未分类经验和历史兼容内容,不是所有新经验的默认目的地。普通任务默认只读不写,但当前用户明确要求时可以按最小范围更新;任务结束后的专门收尾执行仍按收尾指令复核。
    - 对旧版 MEMORY.md,如果条目没有完整结构化字段但明确指向 \`notes/<file>.md\`,把它视为 legacy 索引;仍需结合条目标题/链接和当前请求判断相关性,不要因为缺少 summary/triggers 就假定正文已注入。
 3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。
 
@@ -269,7 +276,7 @@ ${interactiveTaskRules}${freshnessRule}${externalReplyRule}${collaborationEtique
 - 当前请求命中 MEMORY.md 某条目的 \`summary\` 或 \`triggers\`,或用户明确询问历史经验/偏好时,在最终回答或执行动作前用 \`Read $CREW_HOME/<file>\` 读取对应明细;不要再次拼接 \`notes/\`。
 - 未命中时不要为了“保险”读取全部 notes;只读取能直接影响当前任务的文件。MEMORY.md 注入的是索引,不会自动让 note 正文可用。
 
-**沉淀与瘦身由系统触发,不要平时做**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时按功能分类把可复用经验提炼进合适的 \`notes/<topic>.md\`,更新 MEMORY.md 索引。收尾只有三种清理结果:有内容且明细与索引全部写入成功后清空 work-log;无可留存内容时直接清空;任一记忆写入失败则保留 work-log、停止并报告失败,不得继续清空。不要默认全部写入 \`notes/lessons.md\`。平时别动 MEMORY.md/notes,既防并行冲突,也防 MEMORY.md 膨胀。
+**沉淀与瘦身由系统触发,不要平时自行扩展范围**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时按功能分类把可复用经验提炼进合适的 \`notes/<topic>.md\`,更新 MEMORY.md 索引。普通执行已经按用户明确要求写入时,收尾先检查、后修改,只在明确缺漏时做最小必要修正,不得重复追加或只为优化措辞而改写。最终结论必须且只能归类为:无变化、已修正、冲突、失败;无变化或已修正时必须满足对应后置条件并清空 work-log,冲突或失败时保留 work-log,任一记忆写入失败则保留 work-log。不要默认全部写入 \`notes/lessons.md\`。默认不要改 MEMORY.md/notes,但不能覆盖当前用户明确授权的最小范围更新。
 
 **为什么(CRITICAL)**:上下文会被周期压缩;你的恢复力来自——注入的 MEMORY.md 索引(始终精简)+ 本任务 work-log + 按需读相关 notes,而**不是**把一切堆进 MEMORY.md 或一次性加载所有明细。
 ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memory}` : ""}${ctx.workLog ? `\n## [注入] 本任务 work-log(续上进度;更新写到 $CREW_TASK_LOG)\n${ctx.workLog}` : ""}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",

package/dist/remote/claude-bridge.js

@@ -1,558 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createInterface } from "node:readline";
-import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { WebSocket } from "ws";
-import { z } from "zod";
-import { toConsoleLines } from "../console.js";
-import { ChannelToGatewaySchema, GatewayToChannelSchema, MAX_CLAUDE_INPUT_QUEUE_BYTES, MAX_CLAUDE_INPUT_QUEUE_ITEMS, MAX_REMOTE_PROMPT_BYTES, MAX_REMOTE_WEBSOCKET_BUFFER_BYTES, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
-import { resolveClaudeWrapperSession } from "./wrapper.js";
-const MAX_CLAUDE_INPUT_DEDUP_ENTRIES = 1_000;
-export function claudeInputQueueStatus(outstandingItems, outstandingBytes, text) {
-    const byteLength = Buffer.byteLength(text, "utf8");
-    if (byteLength > MAX_REMOTE_PROMPT_BYTES)
-        return "prompt_too_large";
-    if (outstandingItems >= MAX_CLAUDE_INPUT_QUEUE_ITEMS
-        || outstandingBytes + byteLength > MAX_CLAUDE_INPUT_QUEUE_BYTES)
-        return "queue_full";
-    return "accepted";
-}
-export function shouldReconnectClaudeChannel(closeCode) {
-    return closeCode !== 4001;
-}
-class InputStream {
-    values = [];
-    waiters = [];
-    stopped = false;
-    push(value) {
-        if (this.stopped)
-            return;
-        const waiter = this.waiters.shift();
-        if (waiter)
-            waiter({ value, done: false });
-        else
-            this.values.push(value);
-    }
-    close() {
-        this.stopped = true;
-        for (const waiter of this.waiters.splice(0))
-            waiter({ value: undefined, done: true });
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                const value = this.values.shift();
-                if (value)
-                    return Promise.resolve({ value, done: false });
-                if (this.stopped)
-                    return Promise.resolve({ value: undefined, done: true });
-                return new Promise((resolve) => this.waiters.push(resolve));
-            },
-        };
-    }
-}
-const AskQuestionInputSchema = z.object({
-    questions: z.array(z.object({
-        question: z.string().min(1),
-        header: z.string().default("Question"),
-        options: z.array(z.object({
-            label: z.string(),
-            description: z.string().default(""),
-        }).passthrough()).default([]),
-    }).passthrough()).min(1).max(4),
-}).passthrough();
-function takeValue(args, index, option) {
-    const value = args[index + 1];
-    if (!value || value.startsWith("-"))
-        throw new Error(`${option} requires a value`);
-    return value;
-}
-function splitTools(value) {
-    return value.split(/[ ,]+/).map((part) => part.trim()).filter(Boolean);
-}
-export function parseClaudeBridgeArgs(userArgs) {
-    const resolved = resolveClaudeWrapperSession(userArgs);
-    const options = {};
-    const prompts = [];
-    let title;
-    const args = resolved.args;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        const inline = (name) => arg.startsWith(`${name}=`) ? arg.slice(name.length + 1) : null;
-        if (["--session-id", "--resume", "-r"].includes(arg)) {
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("--session-id=") || arg.startsWith("--resume="))
-            continue;
-        if (arg === "--model" || arg === "--effort" || arg === "--permission-mode" || arg === "--name" || arg === "-n"
-            || arg === "--add-dir" || arg === "--allowedTools" || arg === "--allowed-tools"
-            || arg === "--disallowedTools" || arg === "--disallowed-tools" || arg === "--settings") {
-            const value = takeValue(args, index, arg);
-            index += 1;
-            if (arg === "--model")
-                options.model = value;
-            else if (arg === "--effort")
-                options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(value);
-            else if (arg === "--permission-mode")
-                options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(value);
-            else if (arg === "--name" || arg === "-n")
-                title = value;
-            else if (arg === "--add-dir")
-                (options.additionalDirectories ??= []).push(value);
-            else if (arg === "--allowedTools" || arg === "--allowed-tools")
-                options.allowedTools = splitTools(value);
-            else if (arg === "--disallowedTools" || arg === "--disallowed-tools")
-                options.disallowedTools = splitTools(value);
-            else
-                options.settings = value;
-            continue;
-        }
-        const model = inline("--model");
-        const effort = inline("--effort");
-        const permission = inline("--permission-mode");
-        const name = inline("--name");
-        if (model !== null)
-            options.model = model;
-        else if (effort !== null)
-            options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(effort);
-        else if (permission !== null)
-            options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(permission);
-        else if (name !== null)
-            title = name;
-        else if (arg === "--dangerously-skip-permissions") {
-            options.permissionMode = "bypassPermissions";
-            options.allowDangerouslySkipPermissions = true;
-        }
-        else if (arg.startsWith("-")) {
-            throw new Error(`Claude mobile bridge does not support ${arg}`);
-        }
-        else
-            prompts.push(arg);
-    }
-    const hasResume = userArgs.some((value) => value === "--resume" || value === "-r" || value.startsWith("--resume="));
-    return {
-        sessionId: resolved.sessionId,
-        resume: hasResume,
-        ...(title === undefined ? {} : { title }),
-        ...(prompts.length === 0 ? {} : { initialPrompt: prompts.join(" ") }),
-        options,
-    };
-}
-function userMessage(sessionId, text, uuid, timestamp) {
-    return {
-        type: "user",
-        message: { role: "user", content: text },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-        uuid,
-        timestamp,
-    };
-}
-function preview(input) {
-    const command = typeof input.command === "string" ? input.command : null;
-    const path = typeof input.file_path === "string" ? input.file_path : null;
-    return (command ?? path ?? JSON.stringify(input)).slice(0, 16_000);
-}
-function printMessage(message) {
-    let printedText = false;
-    for (const line of toConsoleLines(message)) {
-        if (line.stream === "result" || !line.text.trim())
-            continue;
-        if (line.stream === "text")
-            printedText = true;
-        const prefix = line.stream === "thinking" ? "Thinking: "
-            : line.stream === "tool" ? "Tool: "
-                : line.stream === "tool_result" ? "Result: "
-                    : line.stream === "error" ? "Error: " : "";
-        process.stdout.write(`\n${prefix}${line.text}\n`);
-    }
-    return printedText;
-}
-export async function runClaudeBridge(userArgs, context) {
-    const parsed = parseClaudeBridgeArgs(userArgs);
-    const generation = randomUUID();
-    const inputStream = new InputStream();
-    const inputs = [];
-    const interactions = new Map();
-    const acceptedRemoteInputs = new Set();
-    const terminalInteractions = [];
-    let terminalHandler = null;
-    let active = null;
-    let outstandingInputBytes = 0;
-    let stopped = false;
-    let cleaned = false;
-    let superseded = false;
-    let channelReady = false;
-    let hasRegisteredOnce = false;
-    let socket = null;
-    let reconnectTimer;
-    let assistantPrinted = false;
-    let conversation = null;
-    let terminal = null;
-    const url = new URL("/ws/channel", context.gatewayUrl);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    const send = (value) => {
-        if (socket?.readyState !== WebSocket.OPEN)
-            return false;
-        const frame = ChannelToGatewaySchema.parse(value);
-        if (frame.type !== "channel.register" && !channelReady)
-            return false;
-        const serialized = JSON.stringify(frame);
-        if (socket.bufferedAmount + Buffer.byteLength(serialized, "utf8") > MAX_REMOTE_WEBSOCKET_BUFFER_BYTES) {
-            socket.close(1013, "outbound buffer limit");
-            return false;
-        }
-        try {
-            socket.send(serialized);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    const register = () => send({
-        type: "channel.register",
-        protocolVersion: REMOTE_PROTOCOL_VERSION,
-        sessionId: parsed.sessionId,
-        cwd: context.cwd,
-        pid: process.pid,
-        generation,
-        ...(parsed.title === undefined ? {} : { title: parsed.title }),
-    });
-    const sendActiveLocalUserMessage = () => {
-        if (!active || active.requestId !== null)
-            return;
-        send({
-            type: "bridge.user_message",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            messageId: active.messageId,
-            text: active.text,
-            createdAt: active.createdAt,
-        });
-    };
-    const finishInteraction = (requestId, value, local) => {
-        const interaction = interactions.get(requestId);
-        if (!interaction)
-            return false;
-        interactions.delete(requestId);
-        const index = terminalInteractions.indexOf(requestId);
-        if (index >= 0)
-            terminalInteractions.splice(index, 1);
-        terminalHandler = null;
-        interaction.resolve(value);
-        if (local)
-            send({
-                type: "bridge.resolved",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.sessionId,
-                requestId,
-            });
-        return true;
-    };
-    const stop = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        stopped = true;
-        channelReady = false;
-        if (reconnectTimer)
-            clearTimeout(reconnectTimer);
-        inputStream.close();
-        conversation?.close();
-        terminal?.close();
-        socket?.close();
-        for (const id of [...interactions.keys()])
-            finishInteraction(id, { decision: "deny" }, true);
-    };
-    const acknowledgeDelivery = (deliveryId, status) => {
-        send({
-            type: "channel.delivery_ack",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            generation,
-            deliveryId,
-            status,
-        });
-    };
-    const connectGateway = () => new Promise((resolve, reject) => {
-        const next = new WebSocket(url, { headers: { authorization: `Bearer ${context.token}` } });
-        socket = next;
-        channelReady = false;
-        let settled = false;
-        let registrationTimer;
-        next.once("open", () => {
-            if (!register()) {
-                next.close(1013, "registration delivery failed");
-                return;
-            }
-            registrationTimer = setTimeout(() => next.close(1008, "registration timeout"), 2_000);
-        });
-        next.on("message", (raw) => {
-            let decoded;
-            try {
-                decoded = JSON.parse(raw.toString());
-            }
-            catch {
-                return;
-            }
-            const frame = GatewayToChannelSchema.safeParse(decoded);
-            if (!frame.success)
-                return;
-            if (frame.data.type === "channel.registered") {
-                if (frame.data.sessionId !== parsed.sessionId || frame.data.generation !== generation) {
-                    next.close(1008, "registration mismatch");
-                    return;
-                }
-                if (registrationTimer)
-                    clearTimeout(registrationTimer);
-                channelReady = true;
-                hasRegisteredOnce = true;
-                if (active) {
-                    sendActiveLocalUserMessage();
-                    send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
-                }
-                for (const interaction of interactions.values())
-                    send(interaction.requestFrame);
-                if (!settled) {
-                    settled = true;
-                    resolve();
-                }
-                return;
-            }
-            if (!channelReady)
-                return;
-            if (frame.data.type === "channel.prompt") {
-                if (acceptedRemoteInputs.has(frame.data.requestId)) {
-                    acknowledgeDelivery(frame.data.deliveryId, "accepted");
-                    return;
-                }
-                const status = enqueue({ text: frame.data.text, requestId: frame.data.requestId });
-                if (status === "accepted") {
-                    acceptedRemoteInputs.add(frame.data.requestId);
-                    while (acceptedRemoteInputs.size > MAX_CLAUDE_INPUT_DEDUP_ENTRIES) {
-                        const oldest = acceptedRemoteInputs.values().next().value;
-                        if (!oldest)
-                            break;
-                        acceptedRemoteInputs.delete(oldest);
-                    }
-                }
-                acknowledgeDelivery(frame.data.deliveryId, status === "accepted" ? "accepted" : "queue_full");
-            }
-            else if (frame.data.type === "bridge.approval_response") {
-                const accepted = finishInteraction(frame.data.requestId, { decision: frame.data.decision }, false);
-                acknowledgeDelivery(frame.data.deliveryId, accepted ? "accepted" : "not_pending");
-            }
-            else if (frame.data.type === "bridge.question_response") {
-                const accepted = finishInteraction(frame.data.requestId, { answers: frame.data.answers }, false);
-                acknowledgeDelivery(frame.data.deliveryId, accepted ? "accepted" : "not_pending");
-            }
-            else if (frame.data.type === "channel.permission_response") {
-                acknowledgeDelivery(frame.data.deliveryId, "not_pending");
-            }
-        });
-        next.once("error", (error) => {
-            if (!settled) {
-                settled = true;
-                reject(error);
-            }
-        });
-        next.on("close", (code) => {
-            if (registrationTimer)
-                clearTimeout(registrationTimer);
-            const wasCurrent = socket === next;
-            if (wasCurrent) {
-                socket = null;
-                channelReady = false;
-            }
-            if (code === 4001) {
-                superseded = true;
-                process.stderr.write("NowCrew remote: this Claude session was replaced by a newer bridge.\n");
-                stop();
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("Claude remote bridge was superseded"));
-                }
-                return;
-            }
-            if (!settled) {
-                settled = true;
-                reject(new Error(`Claude remote gateway closed before registration (${code})`));
-            }
-            if (wasCurrent && hasRegisteredOnce && !stopped && shouldReconnectClaudeChannel(code)) {
-                reconnectTimer = setTimeout(() => { void connectGateway().catch(() => { }); }, 1_000);
-            }
-        });
-    });
-    const sendNext = () => {
-        if (active || inputs.length === 0 || stopped)
-            return;
-        active = inputs.shift();
-        assistantPrinted = false;
-        inputStream.push(userMessage(parsed.sessionId, active.text, active.messageId, active.createdAt));
-        sendActiveLocalUserMessage();
-        send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
-    };
-    function enqueue(value) {
-        const status = claudeInputQueueStatus(inputs.length + (active ? 1 : 0), outstandingInputBytes, value.text);
-        if (status !== "accepted")
-            return status;
-        const queued = {
-            ...value,
-            byteLength: Buffer.byteLength(value.text, "utf8"),
-            messageId: (value.requestId ?? randomUUID()),
-            createdAt: new Date().toISOString(),
-        };
-        outstandingInputBytes += queued.byteLength;
-        inputs.push(queued);
-        sendNext();
-        return "accepted";
-    }
-    const waitForInteraction = (interaction, render, handleLine) => {
-        const promise = new Promise((resolve) => {
-            interactions.set(interaction.id, { ...interaction, resolve });
-        });
-        terminalInteractions.push(interaction.id);
-        render();
-        terminalHandler = (line) => {
-            const result = handleLine(line);
-            if (result)
-                finishInteraction(interaction.id, result, true);
-        };
-        return promise;
-    };
-    const canUseTool = async (toolName, input, { signal }) => {
-        const requestId = randomUUID();
-        if (toolName === "AskUserQuestion") {
-            const parsedQuestions = AskQuestionInputSchema.safeParse(input);
-            if (!parsedQuestions.success)
-                return { behavior: "deny", message: "Unsupported question format" };
-            const questions = parsedQuestions.data.questions.map((question, index) => ({
-                id: `q${index}`,
-                header: question.header,
-                question: question.question,
-                isSecret: false,
-                options: question.options,
-            }));
-            const requestFrame = {
-                type: "bridge.question",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.sessionId,
-                requestId,
-                questions,
-            };
-            const waiting = waitForInteraction({ id: requestId, kind: "question", questions, requestFrame }, () => {
-                process.stdout.write("\nInput needed:\n");
-                for (const [index, question] of questions.entries()) {
-                    process.stdout.write(`${index + 1}. ${question.header}: ${question.question}\n`);
-                    for (const option of question.options)
-                        process.stdout.write(`   - ${option.label}: ${option.description}\n`);
-                }
-                process.stdout.write("Answer: ");
-            }, (line) => {
-                const values = line.split(";").map((value) => value.trim());
-                return { answers: Object.fromEntries(questions.map((question, index) => [question.id, [values[index] ?? ""]])) };
-            });
-            send(requestFrame);
-            signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
-            const result = await waiting;
-            if (!result.answers)
-                return { behavior: "deny", message: "User input cancelled" };
-            const answers = Object.fromEntries(questions.map((question) => [
-                question.question,
-                result.answers?.[question.id]?.join(", ") ?? "",
-            ]));
-            return { behavior: "allow", updatedInput: { ...input, answers } };
-        }
-        const requestFrame = {
-            type: "bridge.approval",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            requestId,
-            tool: toolName,
-            preview: preview(input),
-        };
-        const waiting = waitForInteraction({ id: requestId, kind: "approval", requestFrame }, () => process.stdout.write(`\nApproval required: ${toolName}\n${preview(input)}\nAllow? `), (line) => /^(y|yes|allow)$/i.test(line.trim()) ? { decision: "allow" }
-            : /^(n|no|deny)$/i.test(line.trim()) ? { decision: "deny" } : null);
-        send(requestFrame);
-        signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
-        const result = await waiting;
-        return result.decision === "allow"
-            ? { behavior: "allow", updatedInput: input }
-            : { behavior: "deny", message: "User denied this action" };
-    };
-    await connectGateway();
-    if (stopped)
-        return 1;
-    const activeConversation = query({
-        prompt: inputStream,
-        options: {
-            cwd: context.cwd,
-            canUseTool,
-            settingSources: ["user", "project", "local"],
-            includePartialMessages: false,
-            ...(parsed.resume ? { resume: parsed.sessionId } : { sessionId: parsed.sessionId }),
-            ...parsed.options,
-            ...(process.env.NOWCREW_CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.NOWCREW_CLAUDE_BIN } : {}),
-        },
-    });
-    conversation = activeConversation;
-    terminal = createInterface({ input: process.stdin, output: process.stdout });
-    terminal.setPrompt("› ");
-    terminal.on("line", (line) => {
-        if (terminalHandler && terminalInteractions.length > 0)
-            terminalHandler(line);
-        else if (line.trim()) {
-            const status = enqueue({ text: line.trim(), requestId: null });
-            if (status !== "accepted")
-                process.stderr.write(`NowCrew remote: input rejected (${status}).\n`);
-        }
-        terminal.prompt();
-    });
-    terminal.on("close", stop);
-    process.stdout.write(`Claude mobile session ${parsed.sessionId}\n`);
-    terminal.prompt();
-    if (parsed.initialPrompt) {
-        const status = enqueue({ text: parsed.initialPrompt, requestId: null });
-        if (status !== "accepted")
-            process.stderr.write(`NowCrew remote: initial input rejected (${status}).\n`);
-    }
-    process.once("SIGINT", stop);
-    process.once("SIGTERM", stop);
-    try {
-        for await (const message of activeConversation) {
-            if (message.type === "assistant")
-                assistantPrinted = printMessage(message) || assistantPrinted;
-            else
-                printMessage(message);
-            if (message.type !== "result")
-                continue;
-            const result = message.subtype === "success" && "result" in message && typeof message.result === "string"
-                ? message.result.trim()
-                : "";
-            if (!assistantPrinted && result)
-                process.stdout.write(`\n${result}\n`);
-            const completedInput = active;
-            if (completedInput)
-                send({
-                    type: "channel.reply",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    sessionId: parsed.sessionId,
-                    requestId: completedInput.messageId,
-                    text: result,
-                });
-            if (completedInput)
-                outstandingInputBytes = Math.max(0, outstandingInputBytes - completedInput.byteLength);
-            active = null;
-            send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: false });
-            terminal.prompt();
-            sendNext();
-        }
-        return superseded ? 1 : stopped ? 0 : 1;
-    }
-    finally {
-        process.off("SIGINT", stop);
-        process.off("SIGTERM", stop);
-        stop();
-    }
-}