@gigaflow/gmux 0.15.0

package/dist/adapters/jsonl.js

@@ -0,0 +1,92 @@
+/**
+ * Streaming JSONL reader shared by adapters.
+ *
+ * Sessions run to hundreds of megabytes in aggregate, so we stream line by line
+ * and never hold a whole file as one string. Malformed lines are skipped rather
+ * than thrown: a truncated final line is normal for a session that is still open.
+ */
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+export async function* readJsonl(filePath) {
+    const stream = createReadStream(filePath, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+        for await (const line of lines) {
+            if (line.trim() === "")
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue; // Truncated or corrupt line; a live session's tail often is.
+            }
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                yield parsed;
+            }
+        }
+    }
+    finally {
+        lines.close();
+        stream.close();
+    }
+}
+/** Keep only the last `n` items pushed. Used for message tails. */
+export class RingBuffer {
+    capacity;
+    items = [];
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    push(item) {
+        this.items.push(item);
+        if (this.items.length > this.capacity)
+            this.items.shift();
+    }
+    toArray() {
+        return [...this.items];
+    }
+    get last() {
+        return this.items[this.items.length - 1];
+    }
+}
+/**
+ * Keep an evenly-spaced sample of an unbounded stream, in bounded memory.
+ *
+ * `RingBuffer` above answers "how did this end?". This answers "what shape was
+ * it?" — and crucially it never drops the FIRST item, which is the developer's
+ * original ask. A summarizer that never sees that writes the same thing the
+ * stale harness title already says.
+ *
+ * Every `stride`-th item is a candidate; when the buffer fills we drop every
+ * other one and double the stride. Stride is therefore always a power of two,
+ * and the retained set lands between `ceil((capacity + 1) / 2)` and `capacity`
+ * — evenly spaced, not exactly `capacity` long. A few waypoints is all the
+ * prompt needs.
+ */
+export class DecimatingSampler {
+    capacity;
+    items = [];
+    stride = 1;
+    seen = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        if (capacity < 1)
+            throw new RangeError(`DecimatingSampler needs capacity >= 1, got ${capacity}`);
+    }
+    push(item) {
+        const index = this.seen;
+        this.seen += 1;
+        if (index % this.stride !== 0)
+            return;
+        this.items.push(item);
+        if (this.items.length > this.capacity) {
+            this.items = this.items.filter((_, i) => i % 2 === 0);
+            this.stride *= 2;
+        }
+    }
+    toArray() {
+        return [...this.items];
+    }
+}
+//# sourceMappingURL=jsonl.js.map

package/dist/adapters/jsonl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.js","sourceRoot":"","sources":["../../src/adapters/jsonl.ts"],"names":[],"mappings":"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"}

package/dist/adapters/registry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The adapter registry.
+ *
+ * Adding a harness means adding one file and one line here. If you are that
+ * contributor, read docs/adding-a-harness.md — it is short.
+ */
+import type { HarnessAdapter } from "./types.js";
+export declare function allAdapters(): HarnessAdapter[];
+/** Adapters whose harness actually stores sessions on this machine. */
+export declare function availableAdapters(): Promise<HarnessAdapter[]>;
+export declare function adapterById(id: string): HarnessAdapter | undefined;

package/dist/adapters/registry.js

@@ -0,0 +1,21 @@
+/**
+ * The adapter registry.
+ *
+ * Adding a harness means adding one file and one line here. If you are that
+ * contributor, read docs/adding-a-harness.md — it is short.
+ */
+import { ClaudeCodeAdapter } from "./claude-code.js";
+import { CodexAdapter } from "./codex.js";
+export function allAdapters() {
+    return [new ClaudeCodeAdapter(), new CodexAdapter()];
+}
+/** Adapters whose harness actually stores sessions on this machine. */
+export async function availableAdapters() {
+    const adapters = allAdapters();
+    const available = await Promise.all(adapters.map((a) => a.isAvailable()));
+    return adapters.filter((_, i) => available[i] === true);
+}
+export function adapterById(id) {
+    return allAdapters().find((a) => a.id === id);
+}
+//# sourceMappingURL=registry.js.map

package/dist/adapters/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/adapters/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,MAAM,UAAU,WAAW;IACzB,OAAO,CAAC,IAAI,iBAAiB,EAAE,EAAE,IAAI,YAAY,EAAE,CAAC,CAAC;AACvD,CAAC;AAED,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,MAAM,QAAQ,GAAG,WAAW,EAAE,CAAC;IAC/B,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC1E,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,EAAU;IACpC,OAAO,WAAW,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAChD,CAAC"}

package/dist/adapters/types.d.ts

@@ -0,0 +1,43 @@
+import type { SessionRecord, SessionRef, HarnessId } from "../core/types.js";
+/**
+ * The one seam that makes gmux harness-agnostic.
+ *
+ * To support a new agent harness, implement this interface in a single file
+ * under `src/adapters/` and register it in `registry.ts`. Nothing else in the
+ * codebase changes. See docs/adding-a-harness.md.
+ */
+export interface HarnessAdapter {
+    /** Stable id, e.g. "claude-code". Appears in `--json` and in `--harness`. */
+    readonly id: HarnessId;
+    /** Name shown to humans, e.g. "Claude Code". */
+    readonly displayName: string;
+    /**
+     * Distinctive `pane_current_command` names that mean "this harness". Used only
+     * to *prefer* a harness when resolving a pane; matching is a hint, never a
+     * gate, because a node-based harness often shows as "node". List only names
+     * that unambiguously identify this harness — omit "node".
+     */
+    readonly processNames: readonly string[];
+    /** The binary `gmux run` launches for this harness, e.g. "claude" or "codex". */
+    readonly launchCommand: string;
+    /**
+     * True when this harness stores sessions on this machine. Adapters whose
+     * harness isn't installed are skipped silently rather than erroring.
+     */
+    isAvailable(): Promise<boolean>;
+    /** Every session file this harness has written. Cheap: stats only, no parsing. */
+    listSessions(): Promise<SessionRef[]>;
+    /** Parse one session file into hard facts. No model calls, no network. */
+    parseSession(ref: SessionRef): Promise<SessionRecord>;
+    /**
+     * The command that drops the user back into this session.
+     * Returned as argv rather than a string so nothing has to be shell-escaped.
+     */
+    resumeCommand(record: SessionRecord): ResumeCommand;
+}
+export interface ResumeCommand {
+    command: string;
+    args: string[];
+    /** Directory to run it in — normally the session's original cwd. */
+    cwd: string;
+}

package/dist/adapters/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/adapters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/adapters/types.ts"],"names":[],"mappings":""}

package/dist/cli/border-client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The daemon-driven border painter: given a `WorkspaceSnapshot`, writes every
+ * pane's `@gm_label` from the model, zero sensing. `gmux daemon run` calls this
+ * on every model "change" event; `snapshotLabel` (tmux-label.ts) does the
+ * actual glyph/text formatting.
+ */
+import type { WorkspaceSnapshot } from "../core/gmux-types.js";
+export declare function paintFromSnapshot(snapshot: WorkspaceSnapshot, setLabel: (paneId: string, text: string) => Promise<void>): Promise<void>;

package/dist/cli/border-client.js

@@ -0,0 +1,11 @@
+/**
+ * The daemon-driven border painter: given a `WorkspaceSnapshot`, writes every
+ * pane's `@gm_label` from the model, zero sensing. `gmux daemon run` calls this
+ * on every model "change" event; `snapshotLabel` (tmux-label.ts) does the
+ * actual glyph/text formatting.
+ */
+import { snapshotLabel } from "./tmux-label.js";
+export async function paintFromSnapshot(snapshot, setLabel) {
+    await Promise.all(snapshot.panes.map((e) => setLabel(e.identity.paneId, snapshotLabel(e))));
+}
+//# sourceMappingURL=border-client.js.map

package/dist/cli/border-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"border-client.js","sourceRoot":"","sources":["../../src/cli/border-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,QAA2B,EAC3B,QAAyD;IAEzD,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9F,CAAC"}

package/dist/cli/commands/__ask-cancel.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `gmux __ask-cancel` — what esc does mid-answer.
+ *
+ * **It kills the process GROUP, and that is the whole point of this command.**
+ * Measured, and it is where the prototype actually broke: `kill -TERM <worker>`
+ * leaves the provider ORPHANED AND ALIVE — still running, still billing, still
+ * writing into a transcript nobody is reading — while the picker cheerfully
+ * flips back to browse mode. `kill -TERM -- -<worker>` reaps the tree, which is
+ * why the worker is spawned `detached` and is therefore its own group leader.
+ *
+ * **The canceller writes the `aborted` record, not the worker.** A worker wedged
+ * badly enough to need a SIGKILL is a worker that cannot write anything, and a
+ * pane stuck on "answering" forever is a worse failure than the one we started
+ * with. Whoever knows the kill happened owns the record.
+ */
+import type { Command } from "commander";
+/** The hidden command fzf's `esc` binding runs in ask mode. */
+export declare const ASK_CANCEL_COMMAND = "__ask-cancel";
+export interface AskCancelOptions {
+    transcript: string;
+    port?: string;
+    now?: Date;
+    /** Injected in tests, so no test signals a real process group. */
+    kill?: (pid: number, signal: NodeJS.Signals) => void;
+    graceMs?: number;
+}
+export type AskCancelStatus = "cancelled" | "idle";
+/**
+ * Stop whatever turn is in flight, if any.
+ *
+ * Never throws. esc is also how you leave ask mode, so a cancel with nothing to
+ * cancel is the ordinary case and must be silent and cheap.
+ */
+export declare function cancelAskTurn(options: AskCancelOptions): Promise<AskCancelStatus>;
+export declare function registerAskCancel(program: Command): void;

package/dist/cli/commands/__ask-cancel.js

@@ -0,0 +1,91 @@
+/**
+ * `gmux __ask-cancel` — what esc does mid-answer.
+ *
+ * **It kills the process GROUP, and that is the whole point of this command.**
+ * Measured, and it is where the prototype actually broke: `kill -TERM <worker>`
+ * leaves the provider ORPHANED AND ALIVE — still running, still billing, still
+ * writing into a transcript nobody is reading — while the picker cheerfully
+ * flips back to browse mode. `kill -TERM -- -<worker>` reaps the tree, which is
+ * why the worker is spawned `detached` and is therefore its own group leader.
+ *
+ * **The canceller writes the `aborted` record, not the worker.** A worker wedged
+ * badly enough to need a SIGKILL is a worker that cannot write anything, and a
+ * pane stuck on "answering" forever is a worse failure than the one we started
+ * with. Whoever knows the kill happened owns the record.
+ */
+import { ASK_KILL_GRACE_MS, appendAskEvent, closeAskTranscript, inFlightSeq, openAskTranscript, readAskLock, readAskTranscript, releaseAskLock, } from "../../services/ask-transcript.js";
+import { isLockStale } from "../../services/auto-summarize.js";
+import { refreshNotifier } from "./__ask-refresh.js";
+/** The hidden command fzf's `esc` binding runs in ask mode. */
+export const ASK_CANCEL_COMMAND = "__ask-cancel";
+function groupKill(pid, signal) {
+    // Negative pid: the group, not the process. The worker is a group leader
+    // because it was spawned detached; a plain pid here would orphan the provider.
+    process.kill(-pid, signal);
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Stop whatever turn is in flight, if any.
+ *
+ * Never throws. esc is also how you leave ask mode, so a cancel with nothing to
+ * cancel is the ordinary case and must be silent and cheap.
+ */
+export async function cancelAskTurn(options) {
+    const notify = refreshNotifier(options.port);
+    const now = options.now ?? new Date();
+    const kill = options.kill ?? groupKill;
+    const lock = await readAskLock(options.transcript);
+    // A stale lock's pid is either dead or recycled into some innocent process —
+    // liveness ANDed with age is what stops us signalling a stranger.
+    const live = lock !== null && lock.pid > 0 && !isLockStale(lock, now);
+    if (live && lock) {
+        try {
+            kill(lock.pid, "SIGTERM");
+            await sleep(options.graceMs ?? ASK_KILL_GRACE_MS);
+            if (alive(lock.pid))
+                kill(lock.pid, "SIGKILL");
+        }
+        catch {
+            // ESRCH: it finished on its own between our read and our signal. The
+            // `aborted` record below is still the honest thing to write — the user
+            // pressed esc, and a race must not resurrect the answer in the pane.
+        }
+    }
+    const { events } = await readAskTranscript(options.transcript);
+    const seq = inFlightSeq(events);
+    if (seq === null) {
+        await releaseAskLock(options.transcript);
+        notify();
+        return "idle";
+    }
+    const fd = openAskTranscript(options.transcript);
+    try {
+        appendAskEvent(fd, { t: "aborted", seq, at: now.toISOString() });
+    }
+    finally {
+        closeAskTranscript(fd);
+    }
+    await releaseAskLock(options.transcript);
+    notify();
+    return "cancelled";
+}
+export function registerAskCancel(program) {
+    program
+        .command(ASK_CANCEL_COMMAND, { hidden: true })
+        .description("internal: cancel the in-flight answer (run by the picker's esc binding)")
+        .requiredOption("--transcript <path>", "the picker's chat transcript")
+        .option("--port <port>", "fzf's listen port, for the repaint")
+        .action(async (options) => {
+        await cancelAskTurn(options);
+    });
+}
+//# sourceMappingURL=__ask-cancel.js.map

package/dist/cli/commands/__ask-cancel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__ask-cancel.js","sourceRoot":"","sources":["../../../src/cli/commands/__ask-cancel.ts"],"names":[],"mappings":"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"}

package/dist/cli/commands/__ask-refresh.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Telling fzf to repaint — the whole of what the ask commands know about fzf.
+ *
+ * `POST /` with the body `refresh-preview` to `$FZF_PORT`, authenticated with
+ * `$FZF_API_KEY`. Plain `fetch` (global in Node 20), not `curl`: an undeclared
+ * dependency for one HTTP request.
+ *
+ * **Failure is swallowed, and that is not laziness.** fzf may have exited while
+ * the answer was in flight, and a POST to a closed port must not take a worker
+ * down before it has finished writing the transcript.
+ *
+ * **The key comes from the environment and goes nowhere else.** fzf exports it
+ * to its children, `__ask-send` passes it to the worker by inheritance, and it
+ * must never appear in an argv, a binding string or the transcript's `meta`
+ * record — argv is world-readable (`ps -ww -o args=`), another process's
+ * environment is not. The port takes the opposite route, on the argv, precisely
+ * because it is not a secret.
+ *
+ * Honest about what this buys: the key raises the bar against a different-user
+ * or non-local attacker, and it is what stops an unauthenticated POST executing
+ * commands as us. It does NOT stop a same-uid local attacker, who can read fzf's
+ * environment. The only boundary there is a unix socket, whose fzf floor
+ * (0.66.0) is out of reach. Known and accepted.
+ */
+/** A refresh POST as data, so the policy is testable without a socket. */
+export interface RefreshRequest {
+    url: string;
+    method: "POST";
+    headers: Record<string, string>;
+    body: "refresh-preview";
+}
+export declare function refreshRequest(port: number, apiKey: string): RefreshRequest;
+/**
+ * The notifier for this process, or a no-op.
+ *
+ * No port or no key means no POST at all: there is no unauthenticated path here
+ * to accidentally take. A missing port is also the normal case for `gmux __ask-*`
+ * driven straight from a shell, where there is no pane to repaint.
+ */
+export declare function refreshNotifier(port: string | undefined, env?: NodeJS.ProcessEnv): () => void;

package/dist/cli/commands/__ask-refresh.js

@@ -0,0 +1,54 @@
+/**
+ * Telling fzf to repaint — the whole of what the ask commands know about fzf.
+ *
+ * `POST /` with the body `refresh-preview` to `$FZF_PORT`, authenticated with
+ * `$FZF_API_KEY`. Plain `fetch` (global in Node 20), not `curl`: an undeclared
+ * dependency for one HTTP request.
+ *
+ * **Failure is swallowed, and that is not laziness.** fzf may have exited while
+ * the answer was in flight, and a POST to a closed port must not take a worker
+ * down before it has finished writing the transcript.
+ *
+ * **The key comes from the environment and goes nowhere else.** fzf exports it
+ * to its children, `__ask-send` passes it to the worker by inheritance, and it
+ * must never appear in an argv, a binding string or the transcript's `meta`
+ * record — argv is world-readable (`ps -ww -o args=`), another process's
+ * environment is not. The port takes the opposite route, on the argv, precisely
+ * because it is not a secret.
+ *
+ * Honest about what this buys: the key raises the bar against a different-user
+ * or non-local attacker, and it is what stops an unauthenticated POST executing
+ * commands as us. It does NOT stop a same-uid local attacker, who can read fzf's
+ * environment. The only boundary there is a unix socket, whose fzf floor
+ * (0.66.0) is out of reach. Known and accepted.
+ */
+export function refreshRequest(port, apiKey) {
+    return {
+        url: `http://127.0.0.1:${port}`,
+        method: "POST",
+        headers: { "x-api-key": apiKey },
+        body: "refresh-preview",
+    };
+}
+/**
+ * The notifier for this process, or a no-op.
+ *
+ * No port or no key means no POST at all: there is no unauthenticated path here
+ * to accidentally take. A missing port is also the normal case for `gmux __ask-*`
+ * driven straight from a shell, where there is no pane to repaint.
+ */
+export function refreshNotifier(port, env = process.env) {
+    const parsed = Number.parseInt(port ?? "", 10);
+    const apiKey = env["FZF_API_KEY"];
+    if (!Number.isFinite(parsed) || parsed <= 0 || !apiKey)
+        return () => { };
+    const request = refreshRequest(parsed, apiKey);
+    return () => {
+        void fetch(request.url, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+        }).catch(() => { });
+    };
+}
+//# sourceMappingURL=__ask-refresh.js.map

package/dist/cli/commands/__ask-refresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__ask-refresh.js","sourceRoot":"","sources":["../../../src/cli/commands/__ask-refresh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAUH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,MAAc;IACzD,OAAO;QACL,GAAG,EAAE,oBAAoB,IAAI,EAAE;QAC/B,MAAM,EAAE,MAAM;QACd,OAAO,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE;QAChC,IAAI,EAAE,iBAAiB;KACxB,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,IAAwB,EAAE,MAAyB,OAAO,CAAC,GAAG;IAC5F,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/C,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,CAAC;IAClC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM;QAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;IAExE,MAAM,OAAO,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,OAAO,GAAG,EAAE;QACV,KAAK,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE;YACtB,MAAM,EAAE,OAAO,CAAC,MAAM;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,IAAI,EAAE,OAAO,CAAC,IAAI;SACnB,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC"}

package/dist/cli/commands/__ask-run.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `gmux __ask-run` — the detached worker that answers one question.
+ *
+ * It is spawned by `__ask-send`, holds the lock its sender took, writes into the
+ * transcript and exits. Its stdio is `ignore`d and fzf owns the terminal, so it
+ * says nothing to anyone: the transcript is its only output, errors included.
+ *
+ * **It rebuilds the conversation from the file.** `gmux ask`'s REPL kept its turns
+ * in a closure; a fan of one-shot workers has no closure to keep them in. That
+ * difference is the whole design, and none of it reaches `buildAskPrompt`, which
+ * still takes a plain `AskTurn[]`.
+ *
+ * **The heartbeat is why the pane is not a frozen rectangle.** The provider
+ * buffers — one write at the end, ~9–20s later — so without a timer nothing
+ * repaints for the length of the think and the picker looks wedged. The worker
+ * only makes the pane re-render; the pane does its own `thinking… Ns`
+ * arithmetic, so the transcript never holds a number that is stale the instant
+ * it is written.
+ */
+import type { Command } from "commander";
+import { type LsOptions } from "./ls.js";
+/** The hidden command `__ask-send` forks. Not a thing a person runs. */
+export declare const ASK_RUN_COMMAND = "__ask-run";
+export interface AskRunOptions extends LsOptions {
+    transcript: string;
+    seq: string;
+    port?: string;
+    /** Injected in tests. Defaults to the fzf POST, or to nothing without a port. */
+    notify?: () => void;
+    /** Injected in tests. In production this is aborted by SIGTERM. */
+    signal?: AbortSignal;
+}
+export type AskRunStatus = "answered" | "aborted" | "no-question" | "no-provider";
+/**
+ * Answer the question at `seq`.
+ *
+ * Never throws: a worker that dies loudly dies into `/dev/null`. Whatever
+ * happens, the turn ends in the transcript with an `end` or an `error` — except
+ * on cancellation, where the record is the canceller's to write, so that a
+ * wedged worker cannot leave the pane stuck on "answering".
+ */
+export declare function runAskTurn(options: AskRunOptions): Promise<AskRunStatus>;
+export declare function registerAskRun(program: Command): void;

package/dist/cli/commands/__ask-run.js

@@ -0,0 +1,126 @@
+/**
+ * `gmux __ask-run` — the detached worker that answers one question.
+ *
+ * It is spawned by `__ask-send`, holds the lock its sender took, writes into the
+ * transcript and exits. Its stdio is `ignore`d and fzf owns the terminal, so it
+ * says nothing to anyone: the transcript is its only output, errors included.
+ *
+ * **It rebuilds the conversation from the file.** `gmux ask`'s REPL kept its turns
+ * in a closure; a fan of one-shot workers has no closure to keep them in. That
+ * difference is the whole design, and none of it reaches `buildAskPrompt`, which
+ * still takes a plain `AskTurn[]`.
+ *
+ * **The heartbeat is why the pane is not a frozen rectangle.** The provider
+ * buffers — one write at the end, ~9–20s later — so without a timer nothing
+ * repaints for the length of the think and the picker looks wedged. The worker
+ * only makes the pane re-render; the pane does its own `thinking… Ns`
+ * arithmetic, so the transcript never holds a number that is stale the instant
+ * it is written.
+ */
+import { NoProviderError } from "../../core/errors.js";
+import { ASK_SESSION_LIMIT, buildAskContext, buildAskPrompt } from "../../services/ask.js";
+import { ASK_HEARTBEAT_MS, appendAskEvent, closeAskTranscript, foldCompletedTurns, openAskTranscript, readAskTranscript, releaseAskLock, streamAnswer, } from "../../services/ask-transcript.js";
+import { readConfig, resolveAskCommand } from "../../services/config.js";
+import { loadViews } from "../../services/views.js";
+import { refreshNotifier } from "./__ask-refresh.js";
+import { toFilters } from "./ls.js";
+/** The hidden command `__ask-send` forks. Not a thing a person runs. */
+export const ASK_RUN_COMMAND = "__ask-run";
+/**
+ * Answer the question at `seq`.
+ *
+ * Never throws: a worker that dies loudly dies into `/dev/null`. Whatever
+ * happens, the turn ends in the transcript with an `end` or an `error` — except
+ * on cancellation, where the record is the canceller's to write, so that a
+ * wedged worker cannot leave the pane stuck on "answering".
+ */
+export async function runAskTurn(options) {
+    const seq = Number.parseInt(options.seq, 10);
+    const notify = options.notify ?? refreshNotifier(options.port);
+    const { events } = await readAskTranscript(options.transcript);
+    const question = events.find((event) => event.t === "question" && event.seq === seq);
+    const settled = events.some((event) => (event.t === "end" || event.t === "aborted" || event.t === "error") && event.seq === seq);
+    if (!question || question.t !== "question" || settled) {
+        // Nothing to answer: a stale respawn, or a turn that was cancelled before we
+        // started. Drop the lock so the next enter is not locked out by a ghost.
+        await releaseAskLock(options.transcript);
+        return "no-question";
+    }
+    const argv = resolveAskCommand(await readConfig());
+    const fd = openAskTranscript(options.transcript);
+    const controller = new AbortController();
+    const signal = options.signal ?? controller.signal;
+    // Cancellation arrives as a signal to our process GROUP: `__ask-cancel` kills
+    // the group because killing us alone would orphan the provider, which would
+    // keep running, keep billing and keep nobody informed. Aborting propagates
+    // that down to `runProviderCommand`'s child.
+    const onSignal = () => controller.abort();
+    process.on("SIGTERM", onSignal);
+    process.on("SIGINT", onSignal);
+    // The only timer in the design, and it lives exactly as long as the request.
+    const heartbeat = setInterval(notify, ASK_HEARTBEAT_MS);
+    try {
+        if (!argv) {
+            const failed = new NoProviderError("`gmux ask`");
+            appendAskEvent(fd, {
+                t: "error",
+                seq,
+                at: new Date().toISOString(),
+                message: failed.fix ? `${failed.message}\n${failed.fix}` : failed.message,
+            });
+            notify();
+            return "no-provider";
+        }
+        const limit = Number(options.limit) || ASK_SESSION_LIMIT;
+        const views = await loadViews(toFilters(options, ASK_SESSION_LIMIT));
+        const context = buildAskContext(views, question.focus, limit);
+        // Completed turns only. The question we are about to answer has no `end`
+        // record, so it cannot replay itself into its own prompt.
+        const turns = foldCompletedTurns(events);
+        await streamAnswer({
+            // The provider argv is exactly what bare `gmux ask` uses, `-p` and all —
+            // which is what keeps this call's own session flagged automated, and so
+            // out of the picker that started it.
+            argv,
+            prompt: buildAskPrompt(context, turns, question.text),
+            transcriptFd: fd,
+            seq,
+            notify,
+            signal,
+        });
+        return signal.aborted ? "aborted" : "answered";
+    }
+    catch {
+        return "aborted";
+    }
+    finally {
+        clearInterval(heartbeat);
+        process.off("SIGTERM", onSignal);
+        process.off("SIGINT", onSignal);
+        closeAskTranscript(fd);
+        // On cancellation the lock is the canceller's to remove — it may already
+        // have handed the transcript to a newer turn, and releasing that turn's lock
+        // would let a third writer in.
+        if (!signal.aborted)
+            await releaseAskLock(options.transcript);
+    }
+}
+export function registerAskRun(program) {
+    program
+        .command(ASK_RUN_COMMAND, { hidden: true })
+        .description("internal: answer one question into a transcript (run detached by gmux itself)")
+        .requiredOption("--transcript <path>", "the picker's chat transcript")
+        .requiredOption("--seq <n>", "which question to answer")
+        .option("--port <port>", "fzf's listen port, for the repaint")
+        .option("--harness <id>", "only this harness")
+        .option("-p, --project <name>", "only sessions whose project matches")
+        .option("-b, --branch <name>", "only sessions whose git branch matches")
+        .option("-s, --since <when>", "only sessions newer than this")
+        .option("-n, --limit <count>", "how many recent sessions to consider")
+        .option("--include-sidechains", "include subagent transcripts")
+        .option("--include-automated", "include non-interactive runs")
+        .action(async (options) => {
+        await runAskTurn(options);
+    });
+}
+//# sourceMappingURL=__ask-run.js.map

package/dist/cli/commands/__ask-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"__ask-run.js","sourceRoot":"","sources":["../../../src/cli/commands/__ask-run.ts"],"names":[],"mappings":"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"}