@cargo-ai/cli 1.0.78 → 1.0.80

package/README.md

@@ -54,6 +54,18 @@ cargo-ai whoami
 cargo-ai logout
 ```
 
+### Book a demo
+
+`cargo-ai book-demo` opens the same Cal.com form as the website's **Talk to sales** button. A person still has to pick a time — the command does not create a booking. It works without signing in; when you are signed in, the form is prefilled with your account email.
+
+```bash
+cargo-ai book-demo
+cargo-ai book-demo --email you@company.com
+cargo-ai book-demo --no-open    # print the URL only
+```
+
+This is not the guided product tour. That is `cargo-ai start --continue demo`.
+
 ### Sign-in without a browser (`--email`)
 
 `cargo-ai login --email you@company.com` emails you a one-time code, then creates your account (on first use) and a workspace — no browser and no dashboard visit at any point. On a terminal the code is read back from a prompt. Where there is no terminal (sandboxes, agent shells) the first call sends the code and exits, so you can finish with:

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

@@ -0,0 +1,18 @@
+/**
+ * Stop Ask's boolean flags from eating the question.
+ *
+ * They are declared `--flag [true|false]` so `--flag false` works and the
+ * palette can offer the two values as a menu. Commander reads an optional-value
+ * option greedily, though: in `ask --print "summarise this"` the message
+ * becomes the flag's value and `parseBooleanOption` rejects it, so the
+ * documented form fails at parse time.
+ *
+ * Writing the value inline (`--print=true`) settles the option before Commander
+ * looks at the next token, so the message stays a positional argument. Only
+ * done when the next token is not a boolean, which leaves `--print false` and
+ * `--print=false` exactly as the caller typed them.
+ *
+ * Exported for tests; `index.ts` is the only production caller.
+ */
+export declare function pinAskBooleanFlags(argv: readonly string[]): string[];
+//# sourceMappingURL=argvFlags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"argvFlags.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/argvFlags.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAoCpE"}

package/build/commands/ask/argvFlags.js

@@ -0,0 +1,46 @@
+/** Ask's boolean flags, declared as `--flag [true|false]`. */
+const ASK_BOOLEAN_FLAGS = ["--print", "--continue"];
+/**
+ * Stop Ask's boolean flags from eating the question.
+ *
+ * They are declared `--flag [true|false]` so `--flag false` works and the
+ * palette can offer the two values as a menu. Commander reads an optional-value
+ * option greedily, though: in `ask --print "summarise this"` the message
+ * becomes the flag's value and `parseBooleanOption` rejects it, so the
+ * documented form fails at parse time.
+ *
+ * Writing the value inline (`--print=true`) settles the option before Commander
+ * looks at the next token, so the message stays a positional argument. Only
+ * done when the next token is not a boolean, which leaves `--print false` and
+ * `--print=false` exactly as the caller typed them.
+ *
+ * Exported for tests; `index.ts` is the only production caller.
+ */
+export function pinAskBooleanFlags(argv) {
+    const prefix = argv.slice(0, 2);
+    const rest = argv.slice(2);
+    if (rest[0] !== "ask") {
+        return [...argv];
+    }
+    const pinned = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const arg = rest[index];
+        if (arg === undefined) {
+            continue;
+        }
+        // Everything after `--` is a positional the caller quoted deliberately.
+        if (arg === "--") {
+            pinned.push(...rest.slice(index));
+            break;
+        }
+        if (ASK_BOOLEAN_FLAGS.includes(arg) === true) {
+            const next = rest[index + 1];
+            if (next !== "true" && next !== "false") {
+                pinned.push(`${arg}=true`);
+                continue;
+            }
+        }
+        pinned.push(arg);
+    }
+    return [...prefix, ...pinned];
+}

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

@@ -0,0 +1,2 @@
+export declare function pruneHarnessArtifacts(dir: string, now?: number): void;
+//# sourceMappingURL=artifacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/artifacts.ts"],"names":[],"mappings":"AAwBA,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,IAAI,CAGzE"}

package/build/commands/ask/artifacts.js

@@ -0,0 +1,100 @@
+import { readdirSync, rmdirSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Every local turn writes bridge state into the directory Ask runs from —
+ * `.agent-runs/<sessionId>/bridge` carries the event log and the start config,
+ * and the start config carries the proxy token — and nothing upstream ever
+ * removes it. Left alone, a working copy fills with dead sessions and keeps
+ * spent tokens on disk long after the chat that minted them.
+ *
+ * A run is kept while a chat could still reattach to it, and swept once it is
+ * older than that. `claude-code-<sessionId>` directories are the per-session
+ * work directories the harness derives, which local sessions leave empty; only
+ * an empty, aged-out one is removed, so anything a session actually put there
+ * — or is using now — survives.
+ *
+ * Best-effort throughout: a directory that is locked, half-written, or being
+ * used by another Ask process is skipped rather than allowed to take the
+ * session down with it.
+ */
+const RUN_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+const WORK_DIR_PREFIX = "claude-code-";
+export function pruneHarnessArtifacts(dir, now = Date.now()) {
+    removeStaleRuns(join(dir, ".agent-runs"), now);
+    removeEmptyWorkDirs(dir, now);
+}
+function removeStaleRuns(runsDir, now) {
+    let entries;
+    try {
+        entries = readdirSync(runsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const path = join(runsDir, entry);
+        try {
+            if (now - newestMtimeMs(path) < RUN_RETENTION_MS) {
+                continue;
+            }
+            rmSync(path, { recursive: true, force: true });
+        }
+        catch {
+            continue;
+        }
+    }
+    try {
+        rmdirSync(runsDir);
+    }
+    catch {
+        // Runs we kept are still in there, which is the ordinary case.
+    }
+}
+function removeEmptyWorkDirs(dir, now) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith(WORK_DIR_PREFIX) === false) {
+            continue;
+        }
+        const path = join(dir, entry);
+        try {
+            // An empty directory's mtime is when it was created, so age is what
+            // separates a dead session from one another Ask process is working in
+            // right now — that one is its agent's cwd and must survive.
+            if (now - statSync(path).mtimeMs < RUN_RETENTION_MS) {
+                continue;
+            }
+            rmdirSync(path);
+        }
+        catch {
+            // Not empty, or not ours to remove.
+            continue;
+        }
+    }
+}
+/**
+ * A run directory's own mtime only moves when entries are added or removed, so
+ * a session that streamed into an existing event log for an hour can still look
+ * untouched. The newest mtime underneath it is what says when the run was last
+ * alive.
+ */
+function newestMtimeMs(path) {
+    const stats = statSync(path);
+    if (stats.isDirectory() === false) {
+        return stats.mtimeMs;
+    }
+    let newest = stats.mtimeMs;
+    for (const entry of readdirSync(path)) {
+        const candidate = newestMtimeMs(join(path, entry));
+        if (candidate > newest) {
+            newest = candidate;
+        }
+    }
+    return newest;
+}

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

@@ -0,0 +1,13 @@
+type RepositoryLike = {
+    connectorUuid?: string;
+    repository?: string;
+} | null | undefined;
+/**
+ * A usable GitHub workspace: connector + owner/name. Matches
+ * parseHarnessBinding's required fields, without decrypting env.
+ *
+ * Exported for tests.
+ */
+export declare function isBoundRepository(repository: RepositoryLike): boolean;
+export {};
+//# sourceMappingURL=binding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/binding.ts"],"names":[],"mappings":"AAAA,KAAK,cAAc,GACf;IACE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACD,IAAI,GACJ,SAAS,CAAC;AAEd;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAgBrE"}

package/build/commands/ask/binding.js

@@ -0,0 +1,19 @@
+/**
+ * A usable GitHub workspace: connector + owner/name. Matches
+ * parseHarnessBinding's required fields, without decrypting env.
+ *
+ * Exported for tests.
+ */
+export function isBoundRepository(repository) {
+    if (repository === undefined || repository === null) {
+        return false;
+    }
+    if (repository.connectorUuid === undefined) {
+        return false;
+    }
+    if (repository.repository === undefined) {
+        return false;
+    }
+    const slashIndex = repository.repository.indexOf("/");
+    return slashIndex > 0 && slashIndex < repository.repository.length - 1;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * The Claude Agent SDK loads every filesystem settings source it can find when
+ * `settingSources` is omitted, and the harness bridge omits it. A local turn
+ * therefore inherits the user's `~/.claude` setup — hooks, plugins, and every
+ * globally configured MCP server — and Claude Code blocks on all of it before
+ * the model takes its first step. Because a turn relaunches Claude Code, that
+ * is paid per message, not per session: on one machine it was 14 seconds of a
+ * 22 second turn, most of it a SessionStart hook running a global npm install
+ * and a skills sync.
+ *
+ * Pointing Claude Code at a directory Ask owns keeps a turn's cost to what the
+ * turn needs. Project settings and CLAUDE.md resolve from the working
+ * directory rather than here, so anything the repo commits still applies.
+ *
+ * The directory persists between runs: Claude Code keeps its own state and
+ * session transcripts under it, and a fresh one each turn would pay first-run
+ * costs again.
+ *
+ * Set `CLAUDE_CONFIG_DIR` to share a config with the `claude` CLI instead —
+ * that reinstates the user's hooks and MCP servers, and their startup cost.
+ */
+export declare function askClaudeConfigDir(): string;
+//# sourceMappingURL=claudeConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeConfig.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/claudeConfig.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAY3C"}

package/build/commands/ask/claudeConfig.js

@@ -0,0 +1,33 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getConfigDir } from "@cargo-ai/cdk/cli";
+/**
+ * The Claude Agent SDK loads every filesystem settings source it can find when
+ * `settingSources` is omitted, and the harness bridge omits it. A local turn
+ * therefore inherits the user's `~/.claude` setup — hooks, plugins, and every
+ * globally configured MCP server — and Claude Code blocks on all of it before
+ * the model takes its first step. Because a turn relaunches Claude Code, that
+ * is paid per message, not per session: on one machine it was 14 seconds of a
+ * 22 second turn, most of it a SessionStart hook running a global npm install
+ * and a skills sync.
+ *
+ * Pointing Claude Code at a directory Ask owns keeps a turn's cost to what the
+ * turn needs. Project settings and CLAUDE.md resolve from the working
+ * directory rather than here, so anything the repo commits still applies.
+ *
+ * The directory persists between runs: Claude Code keeps its own state and
+ * session transcripts under it, and a fresh one each turn would pay first-run
+ * costs again.
+ *
+ * Set `CLAUDE_CONFIG_DIR` to share a config with the `claude` CLI instead —
+ * that reinstates the user's hooks and MCP servers, and their startup cost.
+ */
+export function askClaudeConfigDir() {
+    const configured = process.env["CLAUDE_CONFIG_DIR"];
+    if (configured !== undefined && configured !== "") {
+        return configured;
+    }
+    const dir = join(getConfigDir(), "ask-claude-config");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}

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

@@ -0,0 +1,48 @@
+/** Chat slash commands offered on Tab when the line is `/…`. */
+export declare const ASK_SLASH_COMMANDS: readonly ["/help", "/clear", "/new", "/agent", "/cancel", "/exit"];
+export type AskCompleter = (line: string) => [string[], string];
+/** What a `/…` token turned out to be. */
+export type SlashTokenKind = "command" | "path" | "unknown";
+/**
+ * Decide whether a `/…` token is a chat command, a filesystem path, or
+ * neither.
+ *
+ * The completer and the slash parser both need this answer, and they must
+ * agree: anything the completer offers has to be accepted when the user
+ * presses Enter on it. Written twice, the two drifted — `/tmp` completed as a
+ * path and was then answered with "is not a chat command".
+ *
+ * Shape settles most tokens, but a bare `/word` is ambiguous: `/tmp` and
+ * `/orchestration` are spelled the same. Only the filesystem separates them,
+ * so an unknown word is looked up — cheap, and reached only for a single
+ * bare word that no command matches.
+ */
+export declare function classifySlashToken(token: string): SlashTokenKind;
+/** Max rows shown in the live Ask suggestion menu. */
+export declare const ASK_COMPLETION_MENU_LIMIT = 8;
+/**
+ * Tab completer for the Ask prompt: slash commands when the line is `/…`,
+ * otherwise local path completion for a path-like last token.
+ */
+export declare function createAskCompleter(cwd: string): AskCompleter;
+/**
+ * Matches for the live suggestion menu (slash commands, else path hits).
+ * Empty when the line is plain prose.
+ */
+export declare function listCompletions(line: string, cwd: string): string[];
+/**
+ * Replace the completed span with `completion`: whole line for slash
+ * commands, last token for paths.
+ */
+export declare function applyCompletion(line: string, completion: string): string;
+/**
+ * `/hel` → `/help`. Only when the whole line is a single `/token` (no spaces)
+ * and it matches a chat command prefix. `/tmp` falls through to path completion.
+ */
+export declare function completeSlash(line: string): [string[], string] | undefined;
+/**
+ * Complete the last whitespace-separated token when it looks like a path.
+ * Exported for tests.
+ */
+export declare function completePath(line: string, cwd: string): [string[], string];
+//# sourceMappingURL=completer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"completer.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/completer.ts"],"names":[],"mappings":"AAYA,gEAAgE;AAChE,eAAO,MAAM,kBAAkB,oEAOrB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC;AAEhE,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAgBhE;AAED,sDAAsD;AACtD,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAU5D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CASnE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAYxE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,GAAG,SAAS,CAY1E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,CAwE1E"}

package/build/commands/ask/completer.js

@@ -0,0 +1,217 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
+/** Chat slash commands offered on Tab when the line is `/…`. */
+export const ASK_SLASH_COMMANDS = [
+    "/help",
+    "/clear",
+    "/new",
+    "/agent",
+    "/cancel",
+    "/exit",
+];
+/**
+ * Decide whether a `/…` token is a chat command, a filesystem path, or
+ * neither.
+ *
+ * The completer and the slash parser both need this answer, and they must
+ * agree: anything the completer offers has to be accepted when the user
+ * presses Enter on it. Written twice, the two drifted — `/tmp` completed as a
+ * path and was then answered with "is not a chat command".
+ *
+ * Shape settles most tokens, but a bare `/word` is ambiguous: `/tmp` and
+ * `/orchestration` are spelled the same. Only the filesystem separates them,
+ * so an unknown word is looked up — cheap, and reached only for a single
+ * bare word that no command matches.
+ */
+export function classifySlashToken(token) {
+    // A separator beyond the leading one is unambiguously a path.
+    if (token.slice(1).includes("/") === true) {
+        return "path";
+    }
+    // Still a command while it prefixes one (`/he` → `/help`).
+    if (ASK_SLASH_COMMANDS.some((command) => command.startsWith(token)) === true) {
+        return "command";
+    }
+    // A bare word is only a path if one exists — `/deploy-prod` is a typo worth
+    // a card, not prose to spend a turn on.
+    return existsSync(token) === true ? "path" : "unknown";
+}
+/** Max rows shown in the live Ask suggestion menu. */
+export const ASK_COMPLETION_MENU_LIMIT = 8;
+/**
+ * Tab completer for the Ask prompt: slash commands when the line is `/…`,
+ * otherwise local path completion for a path-like last token.
+ */
+export function createAskCompleter(cwd) {
+    return (line) => {
+        const slash = completeSlash(line);
+        if (slash !== undefined) {
+            return slash;
+        }
+        return completePath(line, cwd);
+    };
+}
+/**
+ * Matches for the live suggestion menu (slash commands, else path hits).
+ * Empty when the line is plain prose.
+ */
+export function listCompletions(line, cwd) {
+    const slash = completeSlash(line);
+    if (slash !== undefined) {
+        return slash[0];
+    }
+    const [hits] = completePath(line, cwd);
+    return hits;
+}
+/**
+ * Replace the completed span with `completion`: whole line for slash
+ * commands, last token for paths.
+ */
+export function applyCompletion(line, completion) {
+    if (completeSlash(line) !== undefined) {
+        return completion;
+    }
+    const token = lastToken(line);
+    if (token === undefined) {
+        return completion;
+    }
+    return `${line.slice(0, line.length - token.length)}${completion}`;
+}
+/**
+ * `/hel` → `/help`. Only when the whole line is a single `/token` (no spaces)
+ * and it matches a chat command prefix. `/tmp` falls through to path completion.
+ */
+export function completeSlash(line) {
+    if (/^\/[A-Za-z]*$/.test(line) === false) {
+        return undefined;
+    }
+    const hits = ASK_SLASH_COMMANDS.filter((command) => command.startsWith(line));
+    if (hits.length === 0) {
+        return undefined;
+    }
+    return [[...hits], line];
+}
+/**
+ * Complete the last whitespace-separated token when it looks like a path.
+ * Exported for tests.
+ */
+export function completePath(line, cwd) {
+    const token = lastToken(line);
+    if (token === undefined || isPathLike(token) === false) {
+        return [[], line];
+    }
+    const expanded = expandHome(token);
+    const absoluteBase = isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+    let dir;
+    let namePrefix;
+    // `.`, `..` and `~` name a directory to look inside, the same as a trailing
+    // separator. Splitting them with dirname/basename instead would complete
+    // siblings of the current, parent or home directory.
+    if (token.endsWith("/") ||
+        token.endsWith(sep) ||
+        token === "." ||
+        token === ".." ||
+        token === "~") {
+        dir = absoluteBase;
+        namePrefix = "";
+    }
+    else {
+        dir = dirname(absoluteBase);
+        namePrefix = basename(absoluteBase);
+    }
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [[], token];
+    }
+    const hits = [];
+    for (const entry of entries) {
+        if (entry.startsWith(namePrefix) === false) {
+            continue;
+        }
+        // Hide dotfiles until the name being typed starts with a dot. Listing a
+        // directory (`.`, `~`, a trailing slash) has an empty prefix, so those
+        // stay hidden there too.
+        if (entry.startsWith(".") === true &&
+            namePrefix.startsWith(".") === false) {
+            continue;
+        }
+        const absoluteHit = join(dir, entry);
+        let display = collapseHome(toDisplayPath(absoluteHit, cwd, token));
+        try {
+            if (statSync(absoluteHit).isDirectory() === true) {
+                display = display.endsWith("/") ? display : `${display}/`;
+            }
+        }
+        catch {
+            // Skip unreadable entries.
+            continue;
+        }
+        hits.push(display);
+    }
+    hits.sort((a, b) => a.localeCompare(b));
+    return [hits, token];
+}
+function lastToken(line) {
+    const match = /(?:^|\s)(\S+)$/.exec(line);
+    if (match === null) {
+        return undefined;
+    }
+    return match[1];
+}
+function isPathLike(token) {
+    if (token.startsWith("./") === true ||
+        token.startsWith("../") === true ||
+        token.startsWith("~/") === true ||
+        token === "~" ||
+        token === "." ||
+        token === "..") {
+        return true;
+    }
+    if (token.startsWith("/") === true) {
+        return classifySlashToken(token) !== "command";
+    }
+    return token.includes("/");
+}
+function expandHome(token) {
+    if (token === "~") {
+        return homedir();
+    }
+    if (token.startsWith("~/") === true) {
+        return join(homedir(), token.slice(2));
+    }
+    return token;
+}
+function collapseHome(path) {
+    const home = homedir();
+    if (path === home) {
+        return "~";
+    }
+    if (path.startsWith(`${home}/`) === true) {
+        return `~/${path.slice(home.length + 1)}`;
+    }
+    return path;
+}
+/**
+ * Prefer a relative form when the typed token was relative; keep absolute /
+ * home forms when the user started that way.
+ */
+function toDisplayPath(absolute, cwd, typedToken) {
+    if (typedToken.startsWith("~/") === true || typedToken === "~") {
+        return absolute;
+    }
+    if (isAbsolute(typedToken) === true) {
+        return absolute;
+    }
+    const rel = relative(cwd, absolute);
+    const display = rel === "" ? "." : rel;
+    if (typedToken.startsWith("./") === true &&
+        display.startsWith(".") === false &&
+        isAbsolute(display) === false) {
+        return `./${display}`;
+    }
+    return display;
+}

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

@@ -0,0 +1,32 @@
+import type { Api } from "../../api.js";
+/**
+ * The earlier turns of a chat, rendered for a Claude Code session that has
+ * never seen them.
+ *
+ * Local Ask starts a fresh harness session on every CLI run — the harness can
+ * only resume Claude Code by rerunning it, and a rerun cancels whatever tool
+ * approval is in flight, which Claude Code then records as the user refusing
+ * the tool. Continuity therefore comes from the chat history the API already
+ * has, replayed into the first prompt.
+ *
+ * Best effort: a chat whose history cannot be read is answered without it
+ * rather than not at all.
+ */
+export declare function loadChatHistoryPreamble(input: {
+    api: Api;
+    chatUuid: string;
+}): Promise<string | undefined>;
+type HistoryMessage = {
+    type: string;
+    status?: string;
+    parts: Array<{
+        type: string;
+    }>;
+};
+/**
+ * Exported for tests. Takes the API's messages oldest-first and returns the
+ * preamble, or `undefined` when there is nothing worth replaying.
+ */
+export declare function renderHistoryPreamble(messages: readonly HistoryMessage[]): string | undefined;
+export {};
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AA0BxC;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE;IACnD,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAU9B;AAED,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAClC,MAAM,GAAG,SAAS,CA6CpB"}