@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/claude/session/store.d.ts

@@ -0,0 +1,17 @@
+import type { AgentEvent } from '../../../agent/events.js';
+import type { AgentSessionRef } from '../../../agent/refs.js';
+import type { AgentSession } from '../../../agent/session.js';
+import type { ClaudeSessionDeps, Run } from './types.js';
+export declare function createSessionStore(context: {
+    readonly deps: ClaudeSessionDeps;
+    readonly run: Run;
+    readonly persisted: boolean;
+    readonly currentSessionId: string;
+    readonly ownRef: AgentSessionRef;
+    emit(events: readonly AgentEvent[]): void;
+}): {
+    sessionStoreCapabilities: () => Pick<AgentSession["capabilities"], "fork" | "rewind">;
+    renameCapability: () => Pick<AgentSession["capabilities"], "rename">;
+    flushRename: () => void;
+};
+//# sourceMappingURL=store.d.ts.map

package/lib/types/backends/claude/session/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/store.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAK7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAExD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE;IAC1C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,IAAI,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,IAAI,CAAA;CAC1C;oCAuBsC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;4BAiE7D,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC;uBAVjD,IAAI;EA0B7B"}

package/lib/types/backends/claude/session/store.js

@@ -0,0 +1,122 @@
+import { t } from '../../../i18n.js';
+import { CLAUDE_BACKEND_ID } from '../contract.js';
+import { errorText } from '../narrow.js';
+import { rewindCutPoint } from '../replay.js';
+export function createSessionStore(context) {
+    const { deps, ownRef, emit } = context;
+    /** A `/rename` made before the CLI wrote the transcript (flushRename). */
+    let pendingTitle;
+    /** The live query's checkpoint restore (`enableFileCheckpointing`). */
+    const rewindFiles = async (anchor, dryRun) => {
+        const query = context.run.query;
+        if (typeof query.rewindFiles !== 'function')
+            throw new Error(t('claude-rewind-files-unavailable'));
+        const result = await query.rewindFiles(anchor, dryRun ? { dryRun: true } : undefined);
+        if (!result.canRewind)
+            throw new Error(result.error ?? t('claude-rewind-files-unavailable'));
+        return {
+            filesChanged: result.filesChanged ?? [],
+            ...(result.insertions === undefined ? {} : { insertions: result.insertions }),
+            ...(result.deletions === undefined ? {} : { deletions: result.deletions }),
+        };
+    };
+    /**
+     * `/fork` and the conversation rewind, both through the
+     * session store: a fork is a persisted copy under a new id (the live
+     * session is untouched); a conversation rewind forks up to the entry
+     * right before the picked user message, for the channel to open and adopt.
+     */
+    function sessionStoreCapabilities() {
+        const store = deps.store;
+        if (store === undefined)
+            return {};
+        const fork = async (options) => {
+            // Nothing to copy before the CLI wrote the transcript.
+            if (!context.persisted)
+                throw new Error(t('claude-fork-empty'));
+            const forked = await store.forkSession(context.currentSessionId, { dir: deps.cwd, ...options });
+            return { backendId: CLAUDE_BACKEND_ID, sessionId: forked.sessionId };
+        };
+        return {
+            fork: {
+                fork: (anchor, title) => fork({ ...(anchor === undefined ? {} : { upToMessageId: anchor }), ...(title === undefined ? {} : { title }) }),
+            },
+            rewind: {
+                preview: anchor => rewindFiles(anchor, true),
+                async rewind(anchor, mode) {
+                    let cut;
+                    if (mode !== 'files') {
+                        // Resolve the cut before touching any file: a conversation the
+                        // rewind cannot cut must not leave the files rewound alone.
+                        const chain = await store.getSessionMessages(context.currentSessionId, { dir: deps.cwd, includeSystemMessages: true });
+                        if (!chain.some(message => message.uuid === anchor))
+                            return { kind: 'refused', reason: t('claude-rewind-not-found') };
+                        cut = rewindCutPoint(chain, anchor);
+                        if (cut === undefined)
+                            return { kind: 'refused', reason: t('rewind-first-message') };
+                    }
+                    let files;
+                    if (mode !== 'conversation') {
+                        try {
+                            files = await rewindFiles(anchor, false);
+                        }
+                        catch (error) {
+                            return { kind: 'refused', reason: errorText(error) };
+                        }
+                    }
+                    if (cut === undefined)
+                        return { kind: 'rewound', session: ownRef, ...(files === undefined ? {} : { files }) };
+                    try {
+                        const session = await fork({ upToMessageId: cut });
+                        return { kind: 'rewound', session, ...(files === undefined ? {} : { files }) };
+                    }
+                    catch (error) {
+                        // The files are restored already: that outcome must not be lost
+                        // with the failed conversation half.
+                        if (files === undefined)
+                            throw error;
+                        return { kind: 'rewound', session: ownRef, files, conversationError: errorText(error) };
+                    }
+                },
+            },
+        };
+    }
+    /**
+     * `/rename`: `renameSession()` writes the title into the
+     * transcript (the browser and `claude --resume` read it), and the live
+     * session reports it at once. Before the CLI wrote the transcript there is
+     * no file to append to: the title is kept and written with the first
+     * persisted frame.
+     */
+    function flushRename() {
+        const title = pendingTitle;
+        const rename = deps.store?.renameSession;
+        if (title === undefined || rename === undefined || !context.persisted)
+            return;
+        pendingTitle = undefined;
+        void rename(context.currentSessionId, title, { dir: deps.cwd }).catch((error) => {
+            deps.host.debug(`claude: deferred rename failed (${errorText(error)})`);
+            emit([{ type: 'notice', level: 'warning', text: t('rename-failed', { err: errorText(error) }) }]);
+        });
+    }
+    function renameCapability() {
+        const rename = deps.store?.renameSession;
+        if (rename === undefined)
+            return {};
+        return {
+            rename: {
+                async rename(title) {
+                    const trimmed = title.trim();
+                    if (trimmed === '')
+                        throw new Error(t('rename-usage'));
+                    if (context.persisted)
+                        await rename(context.currentSessionId, trimmed, { dir: deps.cwd });
+                    else
+                        pendingTitle = trimmed;
+                    emit([{ type: 'session.title', title: trimmed, source: 'user' }]);
+                },
+            },
+        };
+    }
+    return { sessionStoreCapabilities, renameCapability, flushRename };
+}

package/lib/types/backends/claude/session/subagents.d.ts

@@ -0,0 +1,13 @@
+import type { AgentSession } from '../../../agent/session.js';
+import type { ClaudeAuthPlan } from '../auth.js';
+import type { ClaudeTranslator } from '../translate.js';
+import type { ClaudeSessionDeps, Run } from './types.js';
+export declare function sessionTaskCapabilities(context: {
+    readonly deps: ClaudeSessionDeps;
+    readonly translator: ClaudeTranslator;
+    readonly run: Run;
+    readonly disposing: boolean;
+    readonly currentSessionId: string;
+    readonly authPlan: ClaudeAuthPlan;
+}): Pick<AgentSession['capabilities'], 'subagents' | 'tasks'>;
+//# sourceMappingURL=subagents.d.ts.map

package/lib/types/backends/claude/session/subagents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/subagents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAMxD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAC/C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;IAChC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;IACrC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAA;CAClC,GAAG,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAiE5D"}

package/lib/types/backends/claude/session/subagents.js

@@ -0,0 +1,77 @@
+import { t } from '../../../i18n.js';
+import { replayClaudeSubagentLane } from '../replay.js';
+import { readTaskOutputTail, taskOutputRoots } from '../task-output.js';
+/** The subagent transcript's newest page (messages); older windows of the
+ *  same size load on demand. */
+const SUBAGENT_TRANSCRIPT_PAGE = 400;
+export function sessionTaskCapabilities(context) {
+    const { deps, translator } = context;
+    /** Stop a task (subagent or job) by the id the channel knows it by. */
+    const stopTask = async (id) => {
+        const taskId = translator.taskIdOf(id);
+        const query = context.run.query;
+        if (taskId === undefined || typeof query.stopTask !== 'function' || context.disposing)
+            return false;
+        await query.stopTask(taskId);
+        return true;
+    };
+    /**
+     * The child transcript source: the subagent's own messages, read from the store and replayed through the
+     *  same translator the live lane uses. Absent when this session has no
+     *  store read API (tests, a store-less open); a read that fails rejects
+     *  and the transcript view says unavailable — an unreadable transcript is
+     *  never presented as an empty one.
+     */
+    function subagentHistory() {
+        const read = deps.store?.getSubagentMessages;
+        if (read === undefined)
+            return {};
+        return {
+            async history(agentId, window) {
+                const laneOf = (messages, hasOlder, skippedFromStart) => {
+                    const lane = replayClaudeSubagentLane(agentId, messages, { cwd: deps.cwd, debug: message => deps.host.debug(message) });
+                    return { events: lane.events, parentAgentId: lane.parentAgentId, uuids: lane.uuids, hasOlder, skippedFromStart };
+                };
+                if (window !== undefined) {
+                    // An older slice: [skipFromStart - count, skipFromStart) of the disk
+                    // transcript (the SDK paginates by offset from the start). An empty
+                    // window reads nothing and leaves the cursor where it was.
+                    const skip = Math.max(0, window.skipFromStart);
+                    const count = Math.max(0, Math.min(window.count, skip));
+                    if (count === 0)
+                        return laneOf([], skip > 0, skip);
+                    const slice = await read(context.currentSessionId, agentId, { dir: deps.cwd, offset: skip - count, limit: count });
+                    return laneOf(slice, skip - count > 0, skip - slice.length);
+                }
+                // The newest page: one full read (bounded below), the tail kept.
+                const all = await read(context.currentSessionId, agentId, { dir: deps.cwd });
+                if (all.length <= SUBAGENT_TRANSCRIPT_PAGE)
+                    return laneOf(all, false, 0);
+                return laneOf(all.slice(all.length - SUBAGENT_TRANSCRIPT_PAGE), true, all.length - SUBAGENT_TRANSCRIPT_PAGE);
+            },
+        };
+    }
+    return {
+        // A subagent or background job is stopped by its task id (`stopTask`;
+        // the CLI reports the stop as its notification).
+        subagents: {
+            interrupt: agentId => stopTask(agentId),
+            ...subagentHistory(),
+            messaging: 'parent-mediated',
+        },
+        tasks: {
+            stop: taskId => stopTask(taskId),
+            readOutput: taskId => {
+                const file = translator.outputFileOf(taskId);
+                if (file === undefined)
+                    return Promise.reject(new Error(t('claude-task-output-unknown', { id: taskId })));
+                try {
+                    return Promise.resolve(readTaskOutputTail(file, taskId, taskOutputRoots(context.authPlan.env)));
+                }
+                catch (error) {
+                    return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            },
+        },
+    };
+}

package/lib/types/backends/claude/session/types.d.ts

@@ -0,0 +1,89 @@
+/** Dependencies and live query handles for a Claude session. */
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import type { ClaudeAuthPlan } from '../auth.js';
+import type { StartPermissionMode } from '../options.js';
+import type { ClaudeExecutable } from '../process.js';
+import type { ClaudePrefs } from '../prefs.js';
+import type { ClaudeChannels } from '../channels.js';
+import type { ClaudeChannelTokens } from '../../shared/channel-tokens.js';
+import type { ClaudeReplay } from '../replay.js';
+import type { ClaudeSdkModule, ClaudeSessionStoreSdk } from '../sdk.js';
+import type { FlagSettingsFile } from '../flag-settings.js';
+import type { createInbox } from './input.js';
+/** Timer seam (tests inject a manual clock). */
+export interface ClaudeClock {
+    setTimeout(callback: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export interface ClaudeSessionDeps {
+    readonly sdk: Pick<ClaudeSdkModule, 'query'>;
+    /** The session-store API behind `/fork` and the conversation rewind
+     *  (absent = neither capability). */
+    readonly store?: Pick<ClaudeSessionStoreSdk, 'getSessionMessages' | 'forkSession'> & Partial<Pick<ClaudeSessionStoreSdk, 'renameSession' | 'getSubagentMessages'>>;
+    readonly cwd: string;
+    readonly sessionId: string;
+    /**
+     * Resume this persisted session instead of creating one:
+     * its replayed transcript is the session's `history()`, the first run
+     * passes `resume` (never `sessionId`), and live numbering continues where
+     * the replay ended.
+     */
+    readonly resume?: ClaudeReplay;
+    readonly start: StartPermissionMode;
+    readonly executable: ClaudeExecutable;
+    /** The child environment when no credential plan is given (tests). */
+    readonly env: Record<string, string>;
+    /** The credential the session spawns with and how to renew it after an
+     *  authentication failure (auth.ts). */
+    readonly auth?: {
+        readonly plan: ClaudeAuthPlan;
+        /** A fresh plan; `rejected` is the token the CLI just refused (renew it
+         *  only if the store still holds that one), absent for `/login`. */
+        renew(renewal: {
+            readonly rejected?: string;
+        }): Promise<ClaudeAuthPlan>;
+        /** The user-facing sentence for a failed renewal (no error details). */
+        failureNotice?(error: unknown): string;
+    };
+    /** The user's persisted `/model` and `/effort` choices (memory if absent). */
+    readonly prefs?: ClaudePrefs;
+    /** The relay channel profiles (channels.json; the file store if absent). */
+    readonly channels?: ClaudeChannels;
+    /** The channel-token credential seam (shared/channel-tokens.ts; the file store
+     *  under the DSH home if absent). Token material only ever moves between
+     *  this seam and the spawn pipeline's env. */
+    readonly channelTokens?: ClaudeChannelTokens;
+    /** A start model / effort when nothing is persisted (none = the CLI's). */
+    readonly model?: string;
+    readonly effort?: string;
+    readonly host: {
+        debug(message: string): void;
+        /** One child stderr line (deduplicated into notices by the host). */
+        stderr?(line: string): void;
+    };
+    /** The installed SDK version (diagnostics). */
+    readonly sdkVersion?: string;
+    /** Notices to show once the channel subscribes (start-time findings). */
+    readonly startNotices?: readonly string[];
+    readonly clock?: ClaudeClock;
+    /** How long a cancel may go unconfirmed before the turn is force-closed. */
+    readonly forceSettleMs?: number;
+    /** Bound on `initializationResult()` (a CLI that never answers). */
+    readonly initTimeoutMs?: number;
+    /** Bound on waiting for the consumer loop after `close()`. */
+    readonly closeTimeoutMs?: number;
+    /** Bound on a `/login` reconnect waiting for the running turn (120 s). */
+    readonly reconnectDeferMs?: number;
+}
+/** One live `query()`: its stdin and its controller. A reconnect
+ *  (credential renewal) replaces the run; the session, its id and the
+ *  translator state stay. */
+export interface Run {
+    readonly inbox: ReturnType<typeof createInbox<SDKUserMessage>>;
+    readonly abortController: AbortController;
+    readonly query: ReturnType<ClaudeSessionDeps['sdk']['query']>;
+    /** The flag-settings file this run's CLI reads (flag-settings.ts). */
+    readonly flagSettings?: FlagSettingsFile;
+    consumer: Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/backends/claude/session/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/backends/claude/session/types.ts"],"names":[],"mappings":"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"}

package/lib/types/backends/claude/session/types.js

@@ -0,0 +1 @@
+export {};

package/lib/types/backends/claude/session.d.ts

@@ -0,0 +1,4 @@
+/** Open a Claude session and expose its injectable dependencies. */
+export { openClaudeSession } from './session/lifecycle.js';
+export type { ClaudeClock, ClaudeSessionDeps } from './session/types.js';
+//# sourceMappingURL=session.d.ts.map

package/lib/types/backends/claude/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/session.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA"}

package/lib/types/backends/claude/session.js

@@ -0,0 +1,2 @@
+/** Open a Claude session and expose its injectable dependencies. */
+export { openClaudeSession } from './session/lifecycle.js';

package/lib/types/backends/claude/side-query.d.ts

@@ -0,0 +1,34 @@
+import type { ClaudeSdkModule } from './sdk.js';
+/** One side answer: the text, or why there is none (null + no error =
+ *  the caller aborted). */
+export interface SideQueryOutcome {
+    readonly answer: string | null;
+    readonly error?: string;
+}
+export interface ClaudeSideQueryDeps {
+    readonly sdk: Pick<ClaudeSdkModule, 'query'>;
+    readonly cwd: string;
+    /** The session the side query forks (it changes after a reset). */
+    sessionId(): string;
+    /** The CLI has written the session's transcript (a fork needs one). */
+    persisted(): boolean;
+    /** The model the session runs ('' = not known yet: the CLI's default). */
+    model(): string;
+    /** The session's spawn environment and route pin, as of now. */
+    spawn(): {
+        readonly env: Record<string, string>;
+        readonly settings?: {
+            readonly env: Readonly<Record<string, string>>;
+        };
+        readonly executable: string | undefined;
+    };
+    debug(message: string): void;
+}
+export declare function createClaudeSideQuery(deps: ClaudeSideQueryDeps): {
+    ask(prompt: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly onText?: (delta: string) => void;
+    }): Promise<SideQueryOutcome>;
+};
+export type ClaudeSideQuery = ReturnType<typeof createClaudeSideQuery>;
+//# sourceMappingURL=side-query.d.ts.map

package/lib/types/backends/claude/side-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"side-query.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/side-query.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG/C;2BAC2B;AAC3B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAA;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,SAAS,IAAI,MAAM,CAAA;IACnB,uEAAuE;IACvE,SAAS,IAAI,OAAO,CAAA;IACpB,0EAA0E;IAC1E,KAAK,IAAI,MAAM,CAAA;IACf,gEAAgE;IAChE,KAAK,IAAI;QAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAAE,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;SAAE,CAAC;QAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;IAClK,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAC7B;AAOD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB;gBAEzC,MAAM,YAAW;QAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;KAAE,GAAQ,OAAO,CAAC,gBAAgB,CAAC;EAsFnJ;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/lib/types/backends/claude/side-query.js

@@ -0,0 +1,116 @@
+import { t } from '../../i18n.js';
+import { writeFlagSettingsFile } from './flag-settings.js';
+import { buildSideQueryOptions } from './options.js';
+import { errorText, rec, str } from './narrow.js';
+/** The one prompt of a side query, as a closed single-message stream. */
+async function* singlePrompt(text) {
+    yield { type: 'user', message: { role: 'user', content: text }, parent_tool_use_id: null };
+}
+export function createClaudeSideQuery(deps) {
+    return {
+        async ask(prompt, options = {}) {
+            const { signal, onText } = options;
+            if (signal?.aborted)
+                return { answer: null };
+            if (!deps.persisted())
+                return { answer: null, error: t('claude-side-query-empty') };
+            const abortController = new AbortController();
+            const onAbort = () => { abortController.abort(); };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const spawn = deps.spawn();
+            const model = deps.model();
+            // The flag layer goes by file, out of argv (flag-settings.ts).
+            let flagSettings;
+            let query;
+            try {
+                flagSettings = spawn.settings === undefined ? undefined : writeFlagSettingsFile(spawn.settings);
+                query = deps.sdk.query({
+                    prompt: singlePrompt(prompt),
+                    options: buildSideQueryOptions({
+                        cwd: deps.cwd,
+                        resume: deps.sessionId(),
+                        env: spawn.env,
+                        ...(flagSettings === undefined ? {} : { settingsFile: flagSettings.path }),
+                        executable: spawn.executable,
+                        abortController,
+                        stderr: line => { deps.debug(`[claude-side-stderr] ${line.trimEnd()}`); },
+                        ...(model === '' ? {} : { model }),
+                    }),
+                });
+            }
+            catch (error) {
+                signal?.removeEventListener('abort', onAbort);
+                flagSettings?.dispose();
+                throw error;
+            }
+            let streamed = '';
+            let settled = '';
+            let failure;
+            let incomplete;
+            try {
+                for await (const raw of query) {
+                    if (signal?.aborted)
+                        break;
+                    const message = rec(raw);
+                    if (message?.type === 'stream_event') {
+                        const event = rec(message.event);
+                        const delta = rec(event?.delta);
+                        if (event?.type === 'content_block_delta' && delta?.type === 'text_delta') {
+                            const text = str(delta.text) ?? '';
+                            if (text !== '') {
+                                streamed += text;
+                                onText?.(text);
+                            }
+                        }
+                        continue;
+                    }
+                    if (message?.type === 'assistant') {
+                        for (const block of Array.isArray(rec(message.message)?.content) ? rec(message.message).content : []) {
+                            const value = rec(block);
+                            if (value?.type === 'text')
+                                settled += str(value.text) ?? '';
+                        }
+                        continue;
+                    }
+                    if (message?.type === 'result') {
+                        const errors = Array.isArray(message.errors) ? message.errors.filter((line) => typeof line === 'string' && !line.startsWith('[ede_diagnostic]')) : [];
+                        const reason = str(message.result) ?? (errors.join('\n') || str(message.subtype) || 'error');
+                        // An error result fails; a non-success close (the turn bound)
+                        // fails only when it left no answer.
+                        if (message.is_error === true)
+                            failure = reason;
+                        else if (message.subtype !== 'success')
+                            incomplete = reason;
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                if (!signal?.aborted)
+                    failure = errorText(error);
+            }
+            finally {
+                signal?.removeEventListener('abort', onAbort);
+                try {
+                    query.close();
+                }
+                catch (error) {
+                    deps.debug(`claude: side query close failed (${errorText(error)})`);
+                }
+                abortController.abort();
+                flagSettings?.dispose();
+            }
+            if (signal?.aborted)
+                return { answer: null };
+            // A gateway that does not stream still settles the whole text.
+            if (streamed === '' && settled !== '')
+                onText?.(settled);
+            const answer = (streamed !== '' ? streamed : settled).trim();
+            if (failure !== undefined)
+                return { answer: null, error: failure };
+            if (answer === '')
+                return { answer: null, error: incomplete ?? t('claude-side-query-no-answer') };
+            return { answer };
+        },
+    };
+}

package/lib/types/backends/claude/task-output.d.ts

@@ -0,0 +1,13 @@
+/** The tail read per call (the card shows 3 lines, the panel 30). */
+export declare const TASK_OUTPUT_TAIL_BYTES: number;
+/** Where the CLI may keep task output (each resolved, symlinks included). */
+export declare function taskOutputRoots(env?: Readonly<Record<string, string | undefined>>): string[];
+/**
+ * Validate a reported output path for one task; returns the resolved path
+ * or throws a user-facing error (never opening anything that fails).
+ */
+export declare function resolveTaskOutputPath(reported: string, taskId: string, roots: readonly string[]): string;
+/** The last {@link TASK_OUTPUT_TAIL_BYTES} of a task's output (a partial
+ *  first line dropped when the read starts mid-file). */
+export declare function readTaskOutputTail(reported: string, taskId: string, roots?: readonly string[]): string;
+//# sourceMappingURL=task-output.d.ts.map

package/lib/types/backends/claude/task-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-output.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/task-output.ts"],"names":[],"mappings":"AAqBA,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,QAAY,CAAA;AAE/C,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,GAAG,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAe,GAAG,MAAM,EAAE,CAkBzG;AAOD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAYxG;AAED;yDACyD;AACzD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,SAAS,MAAM,EAAsB,GAAG,MAAM,CA0BzH"}

package/lib/types/backends/claude/task-output.js

@@ -0,0 +1,101 @@
+/**
+ * The output tail of a Claude background task (`tasks.readOutput`):
+ * the CLI writes each task's output to a file it names in its own reports
+ * (the backgrounded command's acknowledgement, `task_notification.output_file`);
+ * the TUI reads its last bytes, read-only, while the job's card or panel
+ * entry is on screen.
+ *
+ * The path comes from the CLI's report — model-influenced text — so it is
+ * validated before anything is opened: an absolute path whose file name is
+ * `<taskId>.output`, which after resolving every symlink still lies inside
+ * the CLI's own directories (the system temp directory the CLI keeps task
+ * output in, `/tmp` on POSIX, or the Claude config directory), and which is
+ * a regular file opened without following a final symlink (and without
+ * blocking: a FIFO in its place is refused, not waited on). Only the last
+ * {@link TASK_OUTPUT_TAIL_BYTES} are read.
+ */
+import { closeSync, constants, fstatSync, openSync, readSync, realpathSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { basename, isAbsolute, join, relative, sep } from 'node:path';
+import { t } from '../../i18n.js';
+/** The tail read per call (the card shows 3 lines, the panel 30). */
+export const TASK_OUTPUT_TAIL_BYTES = 64 * 1024;
+/** Where the CLI may keep task output (each resolved, symlinks included). */
+export function taskOutputRoots(env = process.env) {
+    const candidates = [
+        tmpdir(),
+        ...(process.platform === 'win32' ? [] : ['/tmp']),
+        env.CLAUDE_CODE_TMPDIR,
+        env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude'),
+    ];
+    const roots = [];
+    for (const candidate of candidates) {
+        if (candidate === undefined || candidate === '')
+            continue;
+        try {
+            const real = realpathSync(candidate);
+            if (!roots.includes(real))
+                roots.push(real);
+        }
+        catch {
+            // A root that does not exist holds nothing.
+        }
+    }
+    return roots;
+}
+const inside = (root, path) => {
+    const rel = relative(root, path);
+    return rel !== '' && !rel.startsWith(`..${sep}`) && rel !== '..' && !isAbsolute(rel);
+};
+/**
+ * Validate a reported output path for one task; returns the resolved path
+ * or throws a user-facing error (never opening anything that fails).
+ */
+export function resolveTaskOutputPath(reported, taskId, roots) {
+    if (!isAbsolute(reported) || basename(reported) !== `${taskId}.output` || /[\0]/u.test(reported)) {
+        throw new Error(t('claude-task-output-refused', { id: taskId }));
+    }
+    let real;
+    try {
+        real = realpathSync(reported);
+    }
+    catch {
+        throw new Error(t('claude-task-output-missing', { id: taskId }));
+    }
+    if (!roots.some(root => inside(root, real)))
+        throw new Error(t('claude-task-output-refused', { id: taskId }));
+    return real;
+}
+/** The last {@link TASK_OUTPUT_TAIL_BYTES} of a task's output (a partial
+ *  first line dropped when the read starts mid-file). */
+export function readTaskOutputTail(reported, taskId, roots = taskOutputRoots()) {
+    const path = resolveTaskOutputPath(reported, taskId, roots);
+    // O_NONBLOCK (POSIX): a FIFO named like the output file must not park this
+    // synchronous open — the UI thread — until a writer appears; it opens at
+    // once and the regular-file check below refuses it. A regular file ignores
+    // the flag.
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (process.platform === 'win32' ? 0 : constants.O_NONBLOCK ?? 0));
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile())
+            throw new Error(t('claude-task-output-refused', { id: taskId }));
+        const length = Math.min(stat.size, TASK_OUTPUT_TAIL_BYTES);
+        const start = stat.size - length;
+        const buffer = Buffer.alloc(length);
+        let read = 0;
+        while (read < length) {
+            const n = readSync(fd, buffer, read, length - read, start + read);
+            if (n === 0)
+                break;
+            read += n;
+        }
+        const text = buffer.subarray(0, read).toString('utf8');
+        if (start === 0)
+            return text;
+        const newline = text.indexOf('\n');
+        return newline === -1 ? '' : text.slice(newline + 1);
+    }
+    finally {
+        closeSync(fd);
+    }
+}