@cargo-ai/cli 1.0.86 → 1.0.88

package/build/commands/ask/localHarness.js

@@ -14,8 +14,16 @@ import { ensureHarnessPnpmOnPath } from "./pnpmShim.js";
  * from Claude Code's own transcript. `CARGO_ASK_TIMING=1` writes the phase
  * boundaries — and the harness's own diagnostics — to stderr. Unset, every
  * call below is a no-op and nothing is added to the stream.
+ *
+ * `CARGO_ASK_TIMING=parts` adds the whole of each stream part next to its
+ * type. Verbose, and the only way to see what the bridge actually sends: the
+ * part names alone say a tool call arrived, not that its result came back
+ * empty or that the field a reader is looking for is spelled differently here
+ * than in the bridge that emitted it.
  */
-const ASK_TIMING_ENABLED = process.env["CARGO_ASK_TIMING"] === "1";
+const ASK_TIMING_LEVEL = process.env["CARGO_ASK_TIMING"];
+const ASK_TIMING_ENABLED = ASK_TIMING_LEVEL === "1" || ASK_TIMING_LEVEL === "parts";
+const ASK_TIMING_DUMPS_PARTS = ASK_TIMING_LEVEL === "parts";
 function createPhaseLog(label) {
     if (ASK_TIMING_ENABLED === false) {
         return () => undefined;
@@ -54,12 +62,24 @@ async function* timeParts(parts, phase) {
             : "unknown";
         // Text arrives one delta per token, which would bury everything else.
         if (type.startsWith("text-delta") === false) {
-            phase(`part ${String(seen)}: ${type}`);
+            phase(ASK_TIMING_DUMPS_PARTS === true
+                ? `part ${String(seen)}: ${type} ${dumpPart(part)}`
+                : `part ${String(seen)}: ${type}`);
         }
         yield part;
     }
     phase(`stream ended after ${String(seen)} parts`);
 }
+/** One stream part, flattened onto its log line. Truncated: some are huge. */
+function dumpPart(part) {
+    try {
+        const json = JSON.stringify(part, (_key, value) => value instanceof Error ? `Error(${value.message})` : value);
+        return json === undefined ? "" : json.slice(0, 900);
+    }
+    catch {
+        return "<unserializable>";
+    }
+}
 const LOCAL_WORKING_COPY_INSTRUCTIONS = `You are working in the user's local working copy, not a sandbox. Prefer plan over deploy.
 
 The user confirms each Bash, Write, Edit and NotebookEdit call, and can only answer one at a time. Ask for a single one of those per step and wait for its result before asking for the next; two in one step leaves the second waiting on a confirmation it will never be offered. Reads (Read, Glob, Grep) and the Cargo \`mcp__cargo__*\` tools need no confirmation — batch those freely.
@@ -395,6 +415,11 @@ export async function createLocalHarness(input) {
                     handlers: options,
                     accumulator,
                     unanswered,
+                    // Interrupt Claude Code through the turn's abort signal so the
+                    // bridge stops cleanly. Without this the host walks away from the
+                    // stream and teardown looks like "bridge closed before the turn
+                    // finished" rather than an intentional stop.
+                    onStall: options === undefined ? undefined : options.onStall,
                 });
             }
             catch (error) {
@@ -520,11 +545,14 @@ export async function runPromptTurn(input) {
     const stallTimeoutMs = input.stallTimeoutMs === undefined
         ? TURN_STALL_TIMEOUT_MS
         : input.stallTimeoutMs;
+    const toolStallTimeoutMs = input.toolStallTimeoutMs === undefined
+        ? TURN_TOOL_STALL_TIMEOUT_MS
+        : input.toolStallTimeoutMs;
     const assistantChunks = accumulator.chunks;
     const toolCalls = new Map();
     const turnState = {
         toolRanSinceText: false,
-        inFlightToolCallIds: new Set(),
+        announced: [],
     };
     let stream = await input.driver.start();
     let round = 0;
@@ -537,6 +565,8 @@ export async function runPromptTurn(input) {
             usage: accumulator.usage,
             turnState,
             stallTimeoutMs,
+            toolStallTimeoutMs,
+            onStall: input.onStall,
         });
         if (approvals.length === 0) {
             break;
@@ -549,7 +579,6 @@ export async function runPromptTurn(input) {
             throw new Error(`Local Claude Code asked for tool approval ${String(MAX_APPROVAL_ROUNDS)} times in one turn without finishing. Stopping the turn.`);
         }
         const continuations = [];
-        const approvedToolCallIds = [];
         for (const approval of approvals) {
             // Refused before the user is asked: not their call to make, and a
             // prompt for it could not say what it was granting.
@@ -561,8 +590,13 @@ export async function runPromptTurn(input) {
                     : onApproval === undefined
                         ? false
                         : await onApproval(approval);
-            if (approved === true) {
-                approvedToolCallIds.push(approval.toolCallId);
+            // Recorded against the call so the retraction pass below knows it is
+            // settled: an approved one is running and must be left alone, a refused
+            // one is certainly not and needs no reprieve to find out. Absent when
+            // its result already arrived, which takes it off the list.
+            const announced = turnState.announced.find((call) => call.toolCallId === approval.toolCallId);
+            if (announced !== undefined) {
+                announced.status = approved === true ? "approved" : "refused";
             }
             // Answered, so the drain on a later turn must not deny it again.
             if (input.unanswered !== undefined) {
@@ -588,15 +622,7 @@ export async function runPromptTurn(input) {
                 },
             });
         }
-        // Only the tools just approved are actually going to run. The harness
-        // surfaces one approval per stream, so a sibling the model announced in
-        // the same stream was never asked about and will never report a result —
-        // left in the set it would tell the stall watchdog a tool is in flight
-        // for the rest of the turn, turning a silent stream into a hang.
-        turnState.inFlightToolCallIds.clear();
-        for (const toolCallId of approvedToolCallIds) {
-            turnState.inFlightToolCallIds.add(toolCallId);
-        }
+        retractAbandonedCalls(turnState.announced, handlers.onActivity);
         stream = await input.driver.continueWithApprovals(continuations);
     }
     const streamed = assistantChunks.join("");
@@ -612,14 +638,94 @@ export async function runPromptTurn(input) {
     }
     return fallback;
 }
+/**
+ * Retract the calls the caller was told about and will never hear the end of,
+ * at the boundary where the answers to this round's approvals are known.
+ *
+ * Left on screen instead, an abandoned call outlives the work: no result is
+ * coming, so no `end` event is either, and the caller keeps showing a tool
+ * that stopped existing.
+ *
+ * `"approved"` is kept, and `"running"` is the one case that cannot be judged
+ * yet — the reason this is not a plain sweep. It is either the sibling whose
+ * approval request the harness lost (it surfaces one per stream) or a tool
+ * Claude Code ran without asking, whose result has simply not arrived. Both
+ * look identical here, so it gets one more stream to prove itself: a live one
+ * reports its result and leaves this list on its own.
+ *
+ * Everything else is certain and retracted — `"streaming"` never finished
+ * arriving, `"refused"` was told no, and `"abandoning"` already had its
+ * stream and stayed silent. Refusals matter especially: a tool
+ * `isAlwaysDenied` refuses never reaches `onApproval`, so this is the caller's
+ * only notice.
+ *
+ * The reprieve is for the caller's benefit only — `"abandoning"` is not an
+ * executing status, so the stall watchdog keeps its short deadline throughout
+ * it. Extending the reprieve to the watchdog would deadlock the very hang it
+ * exists to prevent: a dropped sibling would hold the timer off, the stream
+ * would stay silent, and the next boundary, the thing that resolves the
+ * ambiguity, would never arrive.
+ */
+function retractAbandonedCalls(announced, onActivity) {
+    for (const call of [...announced]) {
+        if (call.status === "approved") {
+            continue;
+        }
+        if (call.status === "running") {
+            call.status = "abandoning";
+            continue;
+        }
+        announced.splice(announced.indexOf(call), 1);
+        if (onActivity !== undefined) {
+            onActivity({
+                kind: "dropped",
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+            });
+        }
+    }
+}
 /**
  * How long a turn may produce nothing at all while no tool is running.
  *
  * Generous on purpose: this is a deadlock detector, not a latency budget. The
  * clock only runs when nothing is in flight, so the wait is over a turn that
  * is neither working nor talking.
+ *
+ * `CARGO_ASK_STALL_TIMEOUT_MS` shortens it for the end-to-end tests, which
+ * would otherwise have to sit out the real deadline to prove a hang is caught.
  */
-const TURN_STALL_TIMEOUT_MS = 120_000;
+const TURN_STALL_TIMEOUT_MS = readTimeoutEnv("CARGO_ASK_STALL_TIMEOUT_MS", 120_000);
+/**
+ * The same deadline, for a turn that has a tool executing.
+ *
+ * A tool at work is silent by design — a test run says nothing for as long as
+ * it takes — so this cannot be the deadline above. But it cannot be *no*
+ * deadline either, which is what it used to be: a tool the user approved and
+ * that never reported back left the turn waiting forever, spinner and all,
+ * with nothing to do but kill the terminal. That is the shape of every "it got
+ * stuck on the tool" report.
+ *
+ * Twelve minutes, from Claude Code's own ten-minute ceiling on a Bash tool.
+ * That is the bound for the common case, not for every case: the ceiling is
+ * configurable, and it does not apply to an MCP tool at all. A `mcp__cargo__*`
+ * call that genuinely runs longer than this is cut off with its work lost, so
+ * `CARGO_ASK_TOOL_STALL_TIMEOUT_MS` raises it for a workspace that does that
+ * routinely. The trade is deliberate: a deadline that covers every conceivable
+ * tool is indistinguishable from the hang it replaced.
+ *
+ * Recoverable either way — the session is replaced and the chat, its history
+ * and the working copy all survive.
+ */
+const TURN_TOOL_STALL_TIMEOUT_MS = readTimeoutEnv("CARGO_ASK_TOOL_STALL_TIMEOUT_MS", 12 * 60_000);
+function readTimeoutEnv(name, fallbackMs) {
+    const raw = process.env[name];
+    if (raw === undefined) {
+        return fallbackMs;
+    }
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallbackMs;
+}
 /**
  * How long teardown may take before the session is abandoned. Short, because
  * the caller is usually someone who just pressed Ctrl-C.
@@ -644,6 +750,29 @@ export class HarnessTurnStuck extends Error {
         this.name = "HarnessTurnStuck";
     }
 }
+/**
+ * The turn produced nothing for `TURN_STALL_TIMEOUT_MS` while no tool was in
+ * flight. Common causes: a step that asked to run several confirmable tools at
+ * once (the harness only surfaces one approval), or the Claude Code bridge
+ * going silent. Recoverable — replace the session and ask again.
+ */
+export class HarnessTurnStalled extends Error {
+    constructor(timeoutMs, whileToolRunning = false) {
+        const seconds = String(Math.round(timeoutMs / 1000));
+        super(whileToolRunning === true
+            ? `A tool has been running for ${seconds}s without reporting anything back, which is longer than Claude Code lets any tool run. Treating it as never coming back rather than waiting on it.`
+            : `Local Claude Code went quiet for ${seconds}s with no tool running. Often this is a step that asked to run several confirmable tools at once (only the first can be answered), or the coding session itself stalled.`);
+        this.name = "HarnessTurnStalled";
+    }
+}
+/**
+ * The Claude Code bridge dropped mid-turn. Same recovery as a stall: the
+ * process behind the session is gone, so the next question needs a new one.
+ */
+export function isBridgeClosedError(error) {
+    return (error instanceof Error &&
+        error.message.includes("bridge closed before the turn finished") === true);
+}
 /**
  * Fail a turn that has gone silent with no tool running, instead of hanging.
  *
@@ -654,11 +783,15 @@ export class HarnessTurnStuck extends Error {
  * `LOCAL_WORKING_COPY_INSTRUCTIONS` asks for one confirmable tool per step to
  * avoid it; this is the backstop for when the model does it anyway.
  *
- * The timer is armed only while no tool is in flight — a ten-minute test run
- * is silent too, and must not be cut off.
+ * Two deadlines rather than one, because a tool at work is silent by design
+ * and a ten-minute test run must not be cut off: `timeoutMs` for a stream with
+ * nothing executing, and the far longer `toolTimeoutMs` while a tool is. What
+ * there is never again is *no* deadline — a tool that never reports back used
+ * to leave the turn on the spinner forever.
  */
-async function* withStallTimeout(stream, timeoutMs, isToolInFlight) {
-    if (Number.isFinite(timeoutMs) === false) {
+async function* withStallTimeout(stream, timeoutMs, toolTimeoutMs, isToolInFlight, onStall) {
+    if (Number.isFinite(timeoutMs) === false &&
+        Number.isFinite(toolTimeoutMs) === false) {
         for await (const part of stream) {
             yield part;
         }
@@ -667,9 +800,11 @@ async function* withStallTimeout(stream, timeoutMs, isToolInFlight) {
     const iterator = stream[Symbol.asyncIterator]();
     for (;;) {
         const next = iterator.next();
-        const result = await (isToolInFlight() === true
+        const running = isToolInFlight();
+        const budgetMs = running === true ? toolTimeoutMs : timeoutMs;
+        const result = await (Number.isFinite(budgetMs) === false
             ? next
-            : rejectIfIdle(next, timeoutMs));
+            : rejectIfIdle(next, budgetMs, onStall, running));
         if (result.done === true) {
             return;
         }
@@ -699,14 +834,22 @@ export async function settleWithin(work, timeoutMs) {
         }
     }
 }
-async function rejectIfIdle(next, timeoutMs) {
+async function rejectIfIdle(next, timeoutMs, onStall, whileToolRunning) {
     let timer;
     try {
         return await Promise.race([
             next,
             new Promise((_resolve, reject) => {
                 timer = setTimeout(() => {
-                    reject(new Error(`Local Claude Code went quiet for ${String(Math.round(timeoutMs / 1000))}s with no tool running. A single step that asks to run several tools needing confirmation ends up here: only the first can be answered, and the rest leave the turn waiting. Ask again, or in smaller steps.`));
+                    // Reject first so Promise.race settles on HarnessTurnStalled, not
+                    // on an AbortError the interrupt below may race onto `next`.
+                    reject(new HarnessTurnStalled(timeoutMs, whileToolRunning));
+                    // Then stop the bridge so teardown is an intentional abort, not a
+                    // mysterious "bridge closed before the turn finished" after we
+                    // have already walked away from the stream.
+                    if (onStall !== undefined) {
+                        onStall();
+                    }
                 }, timeoutMs);
             }),
         ]);
@@ -759,19 +902,23 @@ export function isAutoApproved(toolName) {
     return AUTO_APPROVED_TOOL_NAMES.has(toolName);
 }
 /**
- * `Agent` spawns a subagent to run a task of its own. It does reach the
- * approval prompt — the bridge defaults an unlisted tool to `edit`, which
- * `allow-reads` asks about — but approving it is a different kind of decision
- * from approving a `Bash`: the subagent runs its own tools, can be asked for
- * with `mode: "bypassPermissions"`, and whether its calls come back here for
- * individual approval is not something we control or currently know.
+ * `Agent` spawns a subagent to run a task of its own, and approving one is a
+ * different kind of decision from approving a `Bash`: the subagent runs its
+ * own tools, can be asked for with `mode: "bypassPermissions"`, and whether
+ * its calls come back here for individual approval is not something we control
+ * or currently know.
  *
- * Until that is established, refuse it. A prompt that cannot describe what it
- * is granting is worse than not offering the capability, and nothing in the
- * adapter settings or the harness's `inactiveTools` can withhold this tool at
- * source — the approval is the only lever there is.
+ * The refusal that actually stops it is in `claudeConfig.ts`, as a deny rule
+ * in Claude Code's own settings — this never fired, because the approval
+ * request it waits for is never sent. The bridge writes `ask` rules only for
+ * the tools in its `NATIVE_TOOL_KINDS` map, the subagent tools are not in it,
+ * and so `allow-reads` left them running unattended.
+ *
+ * Kept as the second line: a user who points `CLAUDE_CONFIG_DIR` at their own
+ * Claude Code config gets no deny rule written for them, and a future bridge
+ * that does surface the approval should find an answer waiting.
  */
-const DENIED_TOOL_NAMES = new Set(["Agent"]);
+const DENIED_TOOL_NAMES = new Set(["Agent", "Task"]);
 const DENIED_TOOL_REASON = "Spawning a subagent is not available in this session. Do the work in this turn instead, asking for each tool you need.";
 /** Exported for tests. */
 export function isAlwaysDenied(toolName) {
@@ -794,7 +941,7 @@ async function consumeTurn(input) {
     const approvals = [];
     const { handlers } = input;
     const pendingFiles = new Map();
-    const parts = withStallTimeout(input.stream.fullStream, input.stallTimeoutMs, () => input.turnState.inFlightToolCallIds.size > 0);
+    const parts = withStallTimeout(input.stream.fullStream, input.stallTimeoutMs, input.toolStallTimeoutMs, () => input.turnState.announced.some((call) => call.status === "running" || call.status === "approved"), input.onStall);
     for await (const rawPart of parts) {
         if (typeof rawPart !== "object" || rawPart === null) {
             continue;
@@ -808,6 +955,43 @@ async function consumeTurn(input) {
                     ? error
                     : "Local Claude Code turn failed.");
         }
+        // Claude Code streams the tool name before the full call is assembled.
+        // Surface that early so the spinner is not stuck on "Asking…" while the
+        // input is still arriving — and so a later `tool-call` can fill in the
+        // summary without looking like a second tool.
+        if (part["type"] === "tool-input-start") {
+            const toolCallId = part["id"];
+            const toolName = part["toolName"];
+            if (typeof toolCallId === "string" && typeof toolName === "string") {
+                if (input.toolCalls.has(toolCallId) === false) {
+                    input.toolCalls.set(toolCallId, {
+                        toolName,
+                        input: undefined,
+                    });
+                    input.turnState.toolRanSinceText = true;
+                    // Announced, because the spinner is about to show this name and is
+                    // owed a retraction if the call never happens — but `"streaming"`,
+                    // not executing. The tool is not running yet, its input is still
+                    // being generated, and the deltas that carry it are output the
+                    // watchdog is entitled to expect; standing it down here would turn a
+                    // bridge that dies mid-input into a hang.
+                    input.turnState.announced.push({
+                        toolCallId,
+                        toolName,
+                        status: "streaming",
+                    });
+                    if (handlers.onActivity !== undefined) {
+                        handlers.onActivity({
+                            kind: "start",
+                            toolCallId,
+                            toolName,
+                            summary: "",
+                        });
+                    }
+                }
+            }
+            continue;
+        }
         if (part["type"] === "tool-call") {
             const toolCallId = part["toolCallId"];
             const toolName = part["toolName"];
@@ -817,10 +1001,26 @@ async function consumeTurn(input) {
                     input: part["input"],
                 });
                 input.turnState.toolRanSinceText = true;
-                input.turnState.inFlightToolCallIds.add(toolCallId);
+                // The full call is assembled, so something is executing it — that is
+                // what stands the stall watchdog down, and it deliberately waits until
+                // here rather than firing at `tool-input-start`.
+                const announced = input.turnState.announced.find((call) => call.toolCallId === toolCallId);
+                if (announced === undefined) {
+                    input.turnState.announced.push({
+                        toolCallId,
+                        toolName,
+                        status: "running",
+                    });
+                }
+                else {
+                    announced.status = "running";
+                }
+                // Re-emitted when `tool-input-start` already announced the name, so
+                // the spinner can pick up the input summary once it is known.
                 if (handlers.onActivity !== undefined) {
                     handlers.onActivity({
                         kind: "start",
+                        toolCallId,
                         toolName,
                         summary: summarizeToolInput(part["input"]),
                     });
@@ -842,18 +1042,28 @@ async function consumeTurn(input) {
                 ? input.toolCalls.get(toolCallId)
                 : undefined;
             const isError = part["type"] === "tool-error";
-            if (handlers.onActivity !== undefined) {
+            // A preliminary result is progress from a tool that is still running,
+            // so it must not clear the spinner or tell the stall watchdog the tool
+            // is done.
+            const preliminary = part["preliminary"] === true;
+            if (preliminary === false &&
+                typeof toolCallId === "string" &&
+                handlers.onActivity !== undefined) {
                 handlers.onActivity({
                     kind: "end",
+                    toolCallId,
                     toolName: recorded === undefined ? "tool" : recorded.toolName,
                     isError,
                 });
             }
-            if (typeof toolCallId === "string") {
-                // A preliminary result is progress from a tool that is still running,
-                // so it must not tell the stall watchdog the tool is done.
-                if (part["preliminary"] !== true) {
-                    input.turnState.inFlightToolCallIds.delete(toolCallId);
+            if (typeof toolCallId === "string" && preliminary === false) {
+                // Off the list on the way out. The `end` above is the caller's
+                // retraction, so a later approval round must not announce a second
+                // one — and leaving under its own steam is how a tool that ran unasked
+                // proves it was alive rather than abandoned.
+                const at = input.turnState.announced.findIndex((call) => call.toolCallId === toolCallId);
+                if (at !== -1) {
+                    input.turnState.announced.splice(at, 1);
                 }
                 const touched = pendingFiles.get(toolCallId);
                 pendingFiles.delete(toolCallId);
@@ -943,19 +1153,35 @@ function readCount(value) {
         ? value
         : 0;
 }
-function readClaudeCodeCostUsd(part) {
-    const harnessMetadata = part["harnessMetadata"];
-    if (typeof harnessMetadata !== "object" || harnessMetadata === null) {
-        return undefined;
-    }
-    const claudeCode = harnessMetadata["claude-code"];
-    if (typeof claudeCode !== "object" || claudeCode === null) {
-        return undefined;
+/**
+ * What Claude Code says the turn cost, off the `finish` part.
+ *
+ * Two keys, because the value is renamed on its way here: the bridge emits
+ * `harnessMetadata`, and `HarnessAgent` republishes the same object as
+ * `providerMetadata` on the parts this code actually reads. Looking only for
+ * the bridge's name found nothing, so every local turn was ingested at a cost
+ * of zero and priced into no credits at all.
+ *
+ * Exported for tests.
+ */
+export function readClaudeCodeCostUsd(part) {
+    for (const key of ["providerMetadata", "harnessMetadata"]) {
+        const metadata = part[key];
+        if (typeof metadata !== "object" || metadata === null) {
+            continue;
+        }
+        const claudeCode = metadata["claude-code"];
+        if (typeof claudeCode !== "object" || claudeCode === null) {
+            continue;
+        }
+        const costUsd = claudeCode["costUsd"];
+        if (typeof costUsd === "number" &&
+            Number.isFinite(costUsd) &&
+            costUsd > 0) {
+            return costUsd;
+        }
     }
-    const costUsd = claudeCode["costUsd"];
-    return typeof costUsd === "number" && Number.isFinite(costUsd) && costUsd > 0
-        ? costUsd
-        : undefined;
+    return undefined;
 }
 /**
  * The AI SDK part nests the whole `toolCall`; the harness bridge part carries

package/build/commands/ask/prompt.d.ts

@@ -16,5 +16,11 @@ export declare class AskInterrupted extends Error {
  * Enter submits (accepting the highlighted suggestion when the menu is open).
  * Empty Enter leaves. Tab inserts the highlight without submitting.
  */
-export declare function readAskLine(input: NodeJS.ReadableStream, cwd: string): Promise<string | undefined>;
+export declare function readAskLine(input: NodeJS.ReadableStream, cwd: string, 
+/**
+ * What the user had already typed while the last turn was running. The line
+ * opens with it in place and the cursor after it, so a question started
+ * mid-reply is continued rather than retyped.
+ */
+initialLine?: string): Promise<string | undefined>;
 //# sourceMappingURL=prompt.d.ts.map

package/build/commands/ask/prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/prompt.ts"],"names":[],"mappings":";AAiBA;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,KAAK;;CAKxC;AASD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,CAAC,cAAc,EAC5B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiQ7B"}
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/prompt.ts"],"names":[],"mappings":";AAiBA;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,KAAK;;CAKxC;AASD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,CAAC,cAAc,EAC5B,GAAG,EAAE,MAAM;AACX;;;;GAIG;AACH,WAAW,SAAK,GACf,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiQ7B"}

package/build/commands/ask/prompt.js

@@ -25,10 +25,16 @@ function isTTYStream(stream) {
  * Enter submits (accepting the highlighted suggestion when the menu is open).
  * Empty Enter leaves. Tab inserts the highlight without submitting.
  */
-export async function readAskLine(input, cwd) {
+export async function readAskLine(input, cwd, 
+/**
+ * What the user had already typed while the last turn was running. The line
+ * opens with it in place and the cursor after it, so a question started
+ * mid-reply is continued rather than retyped.
+ */
+initialLine = "") {
     return new Promise((resolvePromise, rejectPromise) => {
-        let line = "";
-        let cursor = 0;
+        let line = initialLine;
+        let cursor = initialLine.length;
         let selected = 0;
         let painted = false;
         let finished = false;

package/build/commands/ask/session.d.ts

@@ -68,6 +68,13 @@ type ChatTurnClaim = {
  */
 export declare function claimChatTurn(api: Api, chatUuid: string, ownerId: string): Promise<ChatTurnClaim>;
 export declare function doesChatExist(api: Api, chatUuid: string): Promise<boolean>;
+/**
+ * Greedy wrap on spaces. A word longer than the width keeps its own line
+ * rather than being cut mid-token.
+ *
+ * Exported for tests.
+ */
+export declare function wrapLine(text: string, width: number): string[];
 /**
  * A path inside the session directory reads better relative to it; anything
  * outside stays absolute so it is obvious the turn left the project.
@@ -78,7 +85,7 @@ export declare function displayPath(path: string, dir: string): string;
 /**
  * Same tree grammar as the palette:
  *   ◇  <your message>
- *   🧱  reply…
+ *   ■  reply…
  *   ◆
  * Empty Enter or /exit leaves to the parent palette.
  */

package/build/commands/ask/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/session.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AA0BxC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAoB1D;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAKT;AAiBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,SAAS,GAAG,WAAW,CAErE;AA8ED;;;;;;;;;GASG;AACH;;;;GAIG;AACH,KAAK,aAAa,GACd;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,GACtB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/C;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,CAAC,CAkBxB;AAyCD,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAsSD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAkGD;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,CA0b7B;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE;IACvC,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CA8HhB"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/session.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAmCxC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAkC1D;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAKT;AAiBD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,SAAS,GAAG,WAAW,CAErE;AA8ED;;;;;;;;;GASG;AACH;;;;GAIG;AACH,KAAK,aAAa,GACd;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,GACtB;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GACnB;IAAE,OAAO,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/C;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,CAAC,CAkBxB;AAyCD,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAeD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAe9D;AAicD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ7D;AA2ID;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,CAoqB7B;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE;IACvC,GAAG,EAAE,GAAG,CAAC;IACT,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,GAAG,OAAO,CAAC,IAAI,CAAC,CA8HhB"}