@nowcrew/daemon 0.6.12 → 0.6.13

package/README.md

@@ -371,9 +371,10 @@ CREW_RUNTIME_SAFE=1
 CREW_EXECUTION_MAX_PROMPT_BYTES=256000
 CREW_EXECUTION_MAX_TIMEOUT_MS=10800000
 CREW_EXECUTION_MAX_EVENT_BYTES=64000
-CREW_MAX_PARALLEL=4
+CREW_MAX_PARALLEL=10
+CREW_SCHEDULED_MAX_PARALLEL=4
 CREW_EXECUTION_MAX_QUEUED_PER_AGENT=32
-CREW_EXECUTION_MAX_PARALLEL_TOTAL=4
+CREW_EXECUTION_MAX_PARALLEL_TOTAL=10
 CREW_EXECUTION_MAX_QUEUED_TOTAL=128
 CREW_EXECUTION_MAX_STARTING_TOTAL=1
 CREW_EXECUTION_MAX_STARTING_PER_RUNTIME=1
@@ -381,7 +382,9 @@ CREW_EXECUTION_START_GAP_MS=3000
 CREW_EXECUTION_STARTUP_TIMEOUT_MS=120000
 ```
 
-`MAX_PARALLEL_TOTAL` is the machine-wide process cap shared by protocol-v1 and legacy work.
+`CREW_MAX_PARALLEL` limits normal executions per Agent. `CREW_SCHEDULED_MAX_PARALLEL` separately
+limits scheduled executions per Agent. `MAX_PARALLEL_TOTAL` is the machine-wide process cap shared by
+protocol-v1 and legacy work.
 Runtime startup is a separate FIFO gate: by default only one Claude, Codex, or Kimi process may be
 initializing at a time, and launches are spaced by three seconds. A process leaves the startup gate
 only after its runtime-specific ready event; startup timeout cancels the owned process tree.

package/dist/config.js

@@ -10,9 +10,10 @@ export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxPromptBytes: 256_000,
     maxTimeoutMs: 3 * 60 * 60_000,
     maxEventBytes: 64_000,
-    maxParallelPerAgent: 4,
+    maxParallelPerAgent: 10,
+    maxParallelScheduledPerAgent: 4,
     maxQueuedPerAgent: 32,
-    maxParallelTotal: 4,
+    maxParallelTotal: 10,
     maxQueuedTotal: 128,
     maxStartingTotal: 1,
     maxStartingPerRuntime: 1,
@@ -68,6 +69,7 @@ export function loadConfig(env = process.env) {
         maxTimeoutMs: integerEnvAtMost(env, "CREW_EXECUTION_MAX_TIMEOUT_MS", DEFAULT_EXECUTION_LIMITS.maxTimeoutMs, MAX_EXECUTION_TIMEOUT_MS),
         maxEventBytes: integerEnvAtLeast(env, "CREW_EXECUTION_MAX_EVENT_BYTES", DEFAULT_EXECUTION_LIMITS.maxEventBytes, MIN_EXECUTION_EVENT_BYTES),
         maxParallelPerAgent: positiveIntegerEnv(env, "CREW_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelPerAgent),
+        maxParallelScheduledPerAgent: positiveIntegerEnv(env, "CREW_SCHEDULED_MAX_PARALLEL", DEFAULT_EXECUTION_LIMITS.maxParallelScheduledPerAgent),
         maxQueuedPerAgent: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_PER_AGENT", DEFAULT_EXECUTION_LIMITS.maxQueuedPerAgent),
         maxParallelTotal: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_PARALLEL_TOTAL", DEFAULT_EXECUTION_LIMITS.maxParallelTotal),
         maxQueuedTotal: positiveIntegerEnv(env, "CREW_EXECUTION_MAX_QUEUED_TOTAL", DEFAULT_EXECUTION_LIMITS.maxQueuedTotal),

package/dist/execution-runner.js

@@ -231,7 +231,10 @@ function admission(spec, config, dependencies, at) {
         || dependencies.facts.queuedTotal < 0) {
         return { rejected: rejection(spec.executionId, "invalid_spec", "Invalid local resource facts", at) };
     }
-    const agentAtCapacity = dependencies.facts.activeForAgent >= config.executionLimits.maxParallelPerAgent;
+    const maxParallelForAgent = spec.context.scheduledRunId === undefined
+        ? config.executionLimits.maxParallelPerAgent
+        : config.executionLimits.maxParallelScheduledPerAgent;
+    const agentAtCapacity = dependencies.facts.activeForAgent >= maxParallelForAgent;
     const machineAtCapacity = dependencies.facts.activeTotal >= config.executionLimits.maxParallelTotal;
     const slotInvalid = dependencies.slot?.state === "ready"
         ? agentAtCapacity || machineAtCapacity

package/dist/host-execution-coordinator.js

@@ -4,7 +4,7 @@ import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { defaultProcessController } from "./execution-journal.js";
 import { createJournalLease, createJournalLeaseRegistry, JournalLockedError, } from "./execution-journal-lock.js";
-const HOST_EXECUTION_SLOT_COUNT = 4;
+const HOST_EXECUTION_SLOT_COUNT = 10;
 const HOST_STARTUP_GAP_MS = 3_000;
 const RETRY_MS = 50;
 export function defaultHostExecutionCoordinatorRoot(userHome = homedir()) {
@@ -215,8 +215,8 @@ export function createHostExecutionCoordinator(options = {}) {
 }
 export function hostCoordinatedSlotManager(local, host) {
     return {
-        reserve: (handle, kind) => {
-            const localReservation = local.reserve(handle, kind);
+        reserve: (handle, kind, executionClass) => {
+            const localReservation = local.reserve(handle, kind, executionClass);
             if (!localReservation.accepted)
                 return localReservation;
             const hostReservation = host.reserveExecution(localReservation.ready);

package/dist/memory-prune-diagnostics.js

@@ -372,6 +372,10 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
         outcome = "source_work_log_empty";
     else if (!facts.work_log_cleared)
         outcome = "work_log_not_cleared";
+    else if (!after.memory.exists)
+        outcome = "shared_memory_missing_after";
+    else if ((after.memory.size ?? 0) === 0)
+        outcome = "shared_memory_empty_after";
     else if (facts.lessons_changed && facts.shared_memory_has_lessons_reference) {
         outcome = "promoted_and_indexed";
     }
@@ -381,6 +385,8 @@ export function evaluateMemoryPrunePostcondition(before, after, execution) {
     }
     else if (facts.lessons_changed)
         outcome = "promoted_without_index_change";
+    else if (facts.shared_memory_changed)
+        outcome = "shared_memory_updated";
     else
         outcome = "no_files_changed";
     return { outcome, ...facts };

package/dist/remote/claude-bridge.js

@@ -0,0 +1,558 @@
+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();
+    }
+}