@lucascouts/claude-agent-acp-plus 0.25.3 → 0.27.0

package/dist/acp-agent.js

@@ -42,7 +42,8 @@ import { ACCOUNT_CONFIG_ID, accountForValue, accountInForce, createAccountConfig
 import { isUsageCommandText, structuredUsageMarkdown, syntheticLocalCommand, } from "./usage-markdown.js";
 export { DEFAULT_AGENT_ID, EFFORT_CONFIG_ID } from "./session-config-ids.js";
 import { MODE_CONFIG_ID, SessionModeManager } from "./session-mode.js";
-import { TASKS_META_KEY, TaskFeed, TaskFeedPublisher } from "./task-feed.js";
+import { TASKS_CONTRACT_VERSION, TASKS_META_KEY, normaliseStatus, TailPoller, TaskFeed, TaskFeedPublisher, } from "./task-feed.js";
+import { OutputUnavailable, outputPathFromBashResult, readOutput } from "./task-output.js";
 import { EscalationRegistry, GrantStore, createAskOperator, createGrantPreToolUseHook, createPermissionDeniedHook, } from "./classifier-escalation.js";
 export const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
 const execFileAsync = promisify(execFile);
@@ -142,11 +143,37 @@ export const TASKS_STOP_METHOD = "_claude/tasks/stop";
 /** Move a foreground tool call's task to the background (story 012, R2.3).
  *  Params {@link TasksBackgroundRequest}, result {@link TasksBackgroundResponse}. */
 export const TASKS_BACKGROUND_METHOD = "_claude/tasks/background";
-/** `agentCapabilities._meta` key advertising the task feed and its two
- *  methods (R2.7). Zeo gates on this, never on the agent's name — the name is
+/** Read the end of a task's output file (story 041, R2.1). Params
+ *  {@link TasksOutputRequest}, result {@link TasksOutputResponse}. Version 2. */
+export const TASKS_OUTPUT_METHOD = "_claude/tasks/output";
+/** `agentCapabilities._meta` key advertising the task feed and its methods
+ *  (R2.7). Zeo gates on this, never on the agent's name — the name is
  *  `package.json`'s, and differs between this fork and the published mirror. */
 export const TASKS_CAPABILITY_KEY = TASKS_META_KEY;
-export const TASKS_CAPABILITY_VERSION = 1;
+/** Version 2 (story 041) adds `hasOutput`, `tail` and `_claude/tasks/output`. */
+export const TASKS_CAPABILITY_VERSION = TASKS_CONTRACT_VERSION;
+/** Refresh the account quota windows of one session now, on demand. Params
+ *  {@link UsageRefreshRequest}, result {@link UsageRefreshResponse}. The windows
+ *  themselves arrive the way they always do — one `usage_update` per window,
+ *  carrying `_meta["_claude/rateLimit"]` — before the response does. */
+export const USAGE_REFRESH_METHOD = "_claude/usage/refresh";
+/** `agentCapabilities._meta` key advertising {@link USAGE_REFRESH_METHOD}. A
+ *  client gates on this, never on the agent's name (see
+ *  {@link TASKS_CAPABILITY_KEY}). */
+export const USAGE_CAPABILITY_KEY = "_claude/usage";
+export const USAGE_CAPABILITY_VERSION = 1;
+/** How old a shared quota sample may be and still answer an on-demand refresh.
+ *
+ *  The client asks on every hover of the context ring, so this is the knob that
+ *  trades freshness against cost. Five seconds is shorter than any change a
+ *  person reading a tooltip could tell apart — neither the five-hour nor the
+ *  weekly window moves measurably in that time — yet long enough that a burst
+ *  of hovers, or several Zeo windows hovered in turn, costs one control request
+ *  between them rather than one each. Much shorter than the idle poll's
+ *  {@link sharedSampleMaxAgeMs}: a hover is someone asking "what is it NOW?",
+ *  and a sample most of an interval old is exactly what the poll already
+ *  showed them. */
+export const USAGE_REFRESH_MAX_SAMPLE_AGE_MS = 5_000;
 /** The SDK's own text for a rejected control request, passed through to the
  *  client as the internal error's message (R2.4). */
 function errorMessage(error) {
@@ -171,6 +198,18 @@ export function parseTasksStopRequest(params) {
         taskId: requireIdField(params, TASKS_STOP_METHOD, "taskId"),
     };
 }
+/** Validate raw JSON-RPC params into a {@link TasksOutputRequest}. Extra keys —
+ *  a `path` included — are ignored: only a file the adapter recorded is read
+ *  (R2.5). */
+export function parseTasksOutputRequest(params) {
+    const sessionId = requireIdField(params, TASKS_OUTPUT_METHOD, "sessionId");
+    const taskId = requireIdField(params, TASKS_OUTPUT_METHOD, "taskId");
+    const maxBytes = params && typeof params === "object" ? params.maxBytes : undefined;
+    if (typeof maxBytes !== "number" || !Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+        throw RequestError.invalidParams(undefined, `${TASKS_OUTPUT_METHOD} params require maxBytes, a positive integer`);
+    }
+    return { sessionId, taskId, maxBytes };
+}
 /** Validate raw JSON-RPC params into a {@link TasksBackgroundRequest}. */
 export function parseTasksBackgroundRequest(params) {
     return {
@@ -178,6 +217,10 @@ export function parseTasksBackgroundRequest(params) {
         toolCallId: requireIdField(params, TASKS_BACKGROUND_METHOD, "toolCallId"),
     };
 }
+/** Validate raw JSON-RPC params into a {@link UsageRefreshRequest}. */
+export function parseUsageRefreshRequest(params) {
+    return { sessionId: requireIdField(params, USAGE_REFRESH_METHOD, "sessionId") };
+}
 /** How often the account quota windows are refreshed while a session sits idle,
  *  in milliseconds; `0` disables polling entirely.
  *
@@ -187,10 +230,17 @@ export function parseTasksBackgroundRequest(params) {
  *  the old utilization, and the bar is wrong in the one direction that matters
  *  (it under-reports how much is available) until the next turn ends.
  *
+ *  Thirty seconds by default (sixty until the quota tooltip): the tooltip over
+ *  the context ring shows these windows as numbers, so a reading up to a minute
+ *  old was visible as one. The cost does not double with it — every adapter
+ *  process on the desktop shares one sample per interval (quota-cache.ts), so
+ *  it is still about one control request per interval per account. Hovering
+ *  the ring asks for a fresher one on demand (`_claude/usage/refresh`).
+ *
  *  The floor is not timidity: each tick costs one control request, and neither
  *  the five-hour nor the seven-day window can move fast enough for a tighter
  *  loop to show anything a 15-second one would miss. */
-const QUOTA_POLL_DEFAULT_MS = 60_000;
+const QUOTA_POLL_DEFAULT_MS = 30_000;
 const QUOTA_POLL_FLOOR_MS = 15_000;
 /** Whether sessions ask the SDK for progress summaries on subagent tasks
  *  (`CLAUDE_ACP_PROGRESS_SUMMARIES`). Only `1` or `true` turn it on; anything
@@ -855,6 +905,7 @@ export class ClaudeAcpAgent {
                         promptQueueing: true,
                     },
                     [TASKS_CAPABILITY_KEY]: { version: TASKS_CAPABILITY_VERSION },
+                    [USAGE_CAPABILITY_KEY]: { version: USAGE_CAPABILITY_VERSION },
                 },
                 promptCapabilities: {
                     image: true,
@@ -1333,14 +1384,19 @@ export class ClaudeAcpAgent {
      */
     /** Fetch the account's quota windows and publish them to this session.
      *
-     *  `allowCache` is the difference between the two callers. A turn ending and a
+     *  `cacheMaxAgeMs` is the difference between the callers. A turn ending and a
      *  session being established are moments when THIS session's own consumption
-     *  just changed, so they always fetch. The idle poll has no such reason: it is
-     *  asking about an account, and every other adapter process on the desktop is
-     *  asking the same question about the same account. It reads the shared sample
-     *  instead -- see quota-cache.ts for why sharing, not tighter intervals, is
-     *  what makes separate windows agree. */
-    async publishAccountUsage(sessionId, session, { allowCache = false } = {}) {
+     *  just changed, so they pass none and always fetch. The idle poll and the
+     *  on-demand refresh have no such reason: they are asking about an account,
+     *  and every other adapter process on the desktop is asking the same question
+     *  about the same account. They accept a shared sample up to that age instead
+     *  -- see quota-cache.ts for why sharing, not tighter intervals, is what makes
+     *  separate windows agree.
+     *
+     *  Resolves `true` when at least one window was published, `false` when none
+     *  was: no report, a report with no plan windows (an API-key session), or a
+     *  session replaced while the request was in flight. Never rejects. */
+    async publishAccountUsage(sessionId, session, { cacheMaxAgeMs } = {}) {
         try {
             // Not `getUsage`: this awful spelling is the only name the real `Query`
             // answers to, and it is written out here rather than hidden behind a
@@ -1354,9 +1410,7 @@ export class ClaudeAcpAgent {
             // A sample another process already paid for, when this call is allowed to
             // take one. `null` covers every failure the cache can have, so a broken
             // cache degrades to exactly the behaviour that existed before it.
-            const cached = allowCache
-                ? await readFreshLimits(sharedSampleMaxAgeMs(quotaPollIntervalMs()))
-                : null;
+            const cached = cacheMaxAgeMs !== undefined ? await readFreshLimits(cacheMaxAgeMs) : null;
             const report = cached ??
                 (await session.query.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET({
                     skipBehaviors: true,
@@ -1371,7 +1425,7 @@ export class ClaudeAcpAgent {
             // flight (provider switch, a changed cwd on session/load). A successor
             // must not inherit its predecessor's windows.
             if (this.sessions[sessionId] !== session) {
-                return;
+                return false;
             }
             // `usage_update` is the only carrier ACP gives this `_meta`, and it
             // requires both numbers. `contextUsedTokens` is the session-scoped mirror
@@ -1387,6 +1441,7 @@ export class ClaudeAcpAgent {
             // single report's bars disagree about the context they were measured in.
             const used = session.contextUsedTokens ?? 0;
             const size = session.contextWindowSize;
+            let published = false;
             for (const window of this.accountUsageTracker(session).windowsFrom(report)) {
                 await this.client.sessionUpdate({
                     sessionId,
@@ -1397,10 +1452,13 @@ export class ClaudeAcpAgent {
                         _meta: { "_claude/rateLimit": window },
                     },
                 });
+                published = true;
             }
+            return published;
         }
         catch (error) {
             this.logger.error(`Session ${sessionId}: structured usage report unavailable: ${error}`);
+            return false;
         }
     }
     /** Start the idle refresh of the account quota windows for this session.
@@ -1421,6 +1479,7 @@ export class ClaudeAcpAgent {
         if (intervalMs === 0) {
             return;
         }
+        const cacheMaxAgeMs = sharedSampleMaxAgeMs(intervalMs);
         // Closure-local rather than a Session field: it guards this timer alone, and
         // a slow report must not let ticks pile up into a queue of duplicate control
         // requests against a session that is already struggling to answer one.
@@ -1439,7 +1498,7 @@ export class ClaudeAcpAgent {
             inFlight = true;
             // `publishAccountUsage` never rejects — it logs and returns — so this
             // cannot become an unhandled rejection, and `finally` always re-opens.
-            void this.publishAccountUsage(sessionId, session, { allowCache: true }).finally(() => {
+            void this.publishAccountUsage(sessionId, session, { cacheMaxAgeMs }).finally(() => {
                 inFlight = false;
             });
         }, intervalMs);
@@ -1447,6 +1506,70 @@ export class ClaudeAcpAgent {
         timer.unref?.();
         session.accountUsageTimer = timer;
     }
+    /**
+     * `_claude/usage/refresh`: publish this session's quota windows now, on
+     * demand, and answer whether any were published.
+     *
+     * The client asks on every hover of the context ring, so the cost is bounded
+     * twice. A shared sample younger than {@link USAGE_REFRESH_MAX_SAMPLE_AGE_MS}
+     * answers without a control request, and a refresh already in flight for this
+     * session is joined rather than repeated — however fast the hovers come, one
+     * session never has two of these requests queued.
+     *
+     * Skipped while a turn is in flight, answering `{ refreshed: false }`. The
+     * report is read-only, but SDK control requests are SERIALIZED: an interrupt
+     * queued behind a usage request waits for it (upstream #1216 measured
+     * 0.7-1.1 s for the same queueing behind `getContextUsage`), and `cancel`
+     * awaits its interrupt. A hover during a turn is the common case — people
+     * watch the ring fill — so allowing it would put a round-trip in front of the
+     * Stop button exactly when it is most likely to be pressed. Nothing is lost:
+     * the turn's own end refreshes the windows (R1.2), and a live
+     * `rate_limit_event` still lands mid-turn.
+     *
+     * Before the first turn a control request may not be serviced at all on older
+     * CLIs (#886/#880); such a call simply waits, joined by every later hover,
+     * alongside the establishment refresh that is already waiting the same way.
+     *
+     * Never rejects for a missing report: a fetch failure is logged by
+     * `publishAccountUsage` and answers `false`, as does an API-key session,
+     * which has no plan windows to publish. Only an unknown session is an error,
+     * the same invalid-params error the `_claude/tasks` methods answer.
+     */
+    async refreshUsage(params) {
+        const { sessionId } = params;
+        const log = (outcome, reason) => this.logger.log(`[usage/refresh] method=${USAGE_REFRESH_METHOD} sessionId=${logValue(sessionId)} outcome=${outcome}` +
+            (reason ? ` reason=${reason}` : ""));
+        const session = Object.hasOwn(this.sessions, sessionId) ? this.sessions[sessionId] : undefined;
+        if (!session) {
+            log("error", "unknown_session");
+            throw RequestError.invalidParams(undefined, `unknown session ${sessionId}`);
+        }
+        if (session.queryClosed) {
+            log("skipped", "session_ended");
+            return { refreshed: false };
+        }
+        let coalesced = true;
+        let pending = session.usageRefreshInFlight;
+        if (!pending) {
+            if (session.turnQueue?.length || session.activeTurn) {
+                log("skipped", "turn_in_flight");
+                return { refreshed: false };
+            }
+            coalesced = false;
+            pending = this.publishAccountUsage(sessionId, session, {
+                cacheMaxAgeMs: USAGE_REFRESH_MAX_SAMPLE_AGE_MS,
+            }).finally(() => {
+                if (session.usageRefreshInFlight === pending) {
+                    session.usageRefreshInFlight = undefined;
+                }
+            });
+            session.usageRefreshInFlight = pending;
+        }
+        // `publishAccountUsage` never rejects, so neither does this await.
+        const refreshed = await pending;
+        log(refreshed ? "published" : "nothing", coalesced ? "coalesced" : undefined);
+        return { refreshed };
+    }
     async publishGoalFromPrompt(sessionId, prompt, commandUuid) {
         const goalUpdate = goalUpdateFromPrompt(prompt);
         if (goalUpdate !== undefined) {
@@ -1520,6 +1643,39 @@ export class ClaudeAcpAgent {
             return {};
         });
     }
+    /**
+     * `_claude/tasks/output`: the end of a task's output file (story 041, R2.1–R2.7).
+     * Serves only a path the feed recorded for its own task, and works on an
+     * ended session too, as long as the session object exists. One log line,
+     * never the content.
+     */
+    async taskOutput(params) {
+        const { sessionId, taskId, maxBytes } = params;
+        const log = (outcome, detail) => this.logger.log(`[tasks/output] method=${TASKS_OUTPUT_METHOD} sessionId=${logValue(sessionId)} taskId=${logValue(taskId)} ${detail} outcome=${outcome}`);
+        const refuse = (error, reason) => {
+            log("error", `reason=${logValue(reason)}`);
+            throw error;
+        };
+        const session = Object.hasOwn(this.sessions, sessionId) ? this.sessions[sessionId] : undefined;
+        if (!session) {
+            return refuse(RequestError.invalidParams(undefined, `unknown session ${sessionId}`), "unknown_session");
+        }
+        const path = session.taskFeed?.outputPathFor(taskId) ?? null;
+        if (path === null) {
+            return refuse(RequestError.invalidParams(undefined, `task ${taskId} has no recorded output`), "no_recorded_output");
+        }
+        try {
+            const result = await readOutput(path, maxBytes);
+            log("ok", `bytes=${Buffer.byteLength(result.content, "utf8")} truncated=${result.truncated}`);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof OutputUnavailable) {
+                return refuse(RequestError.internalError(undefined, `output of task ${taskId} is no longer available (${error.code})`), error.code);
+            }
+            return refuse(RequestError.internalError(undefined, logValue(errorMessage(error))), "unexpected");
+        }
+    }
     /** `_claude/tasks/background`: background the task a foreground tool call
      *  started (R2.3, R2.4). `false` means the id matched no foreground task. */
     async backgroundTask(params) {
@@ -3114,7 +3270,14 @@ export class ClaudeAcpAgent {
                                 // The task settled — no further tool calls can originate
                                 // from it, so its registry entry can be dropped.
                                 session.liveBackgroundTasks.delete(message.task_id);
-                                session.taskFeedPublisher?.notify(session.taskFeed.onNotification(message));
+                                if (session.taskFeed && session.taskFeedPublisher) {
+                                    const readable = await endingOutputReadable(session, message.task_id, message.output_file);
+                                    const change = session.taskFeed.onNotification(message);
+                                    if (change === "terminal" && readable !== null) {
+                                        session.taskFeed.setTail(message.task_id, null, readable);
+                                    }
+                                    session.taskFeedPublisher.notify(change);
+                                }
                                 break;
                             case "task_updated":
                                 // terminal-status task_updated patch and a (deduplicated)
@@ -3127,7 +3290,19 @@ export class ClaudeAcpAgent {
                                     message.patch.status === "killed") {
                                     session.liveBackgroundTasks.delete(message.task_id);
                                 }
-                                session.taskFeedPublisher?.notify(session.taskFeed.onUpdated(message));
+                                if (session.taskFeed && session.taskFeedPublisher) {
+                                    // The CLI queues the terminal patch BEFORE the
+                                    // task_notification, so this is usually where a shell ends
+                                    // and its output check has to happen (story 041, R1.7).
+                                    const readable = normaliseStatus(message.patch.status) !== null
+                                        ? await endingOutputReadable(session, message.task_id)
+                                        : null;
+                                    const change = session.taskFeed.onUpdated(message);
+                                    if (change === "terminal" && readable !== null) {
+                                        session.taskFeed.setTail(message.task_id, null, readable);
+                                    }
+                                    session.taskFeedPublisher.notify(change);
+                                }
                                 break;
                             case "worker_shutting_down":
                                 // Defer until stream end. The announcement is durable and may be
@@ -4249,6 +4424,9 @@ export class ClaudeAcpAgent {
                             content = message.message.content;
                         }
                         const acceptedPlanToolUseId = observeExitPlanToolResults(message, content, session);
+                        // Before toAcpNotifications, which prunes the tool_use cache entry
+                        // that says the result is a Bash call's.
+                        observeBackgroundBashResult(message, content, session);
                         for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, session.toolUseCache, this.client, this.logger, {
                             clientCapabilities: this.clientCapabilities,
                             parentToolUseId: message.parent_tool_use_id,
@@ -4764,6 +4942,9 @@ export class ClaudeAcpAgent {
      *  query recreate is the one exit that keeps the feed, and does not come
      *  through here. */
     retireTaskFeed(session) {
+        // Before the publisher: a tick landing after the flush would publish a
+        // tail into a feed whose session is gone (story 041).
+        session.tailPoller?.dispose();
         const publisher = session.taskFeedPublisher;
         if (!publisher)
             return;
@@ -4783,7 +4964,8 @@ export class ClaudeAcpAgent {
             sessionId,
             update: { sessionUpdate: "session_info_update", _meta: { [TASKS_META_KEY]: snapshot } },
         }), undefined, (error) => this.logger.error(`[tasks/feed] sessionId=${logValue(sessionId)} outcome=send_failed reason=${logValue(errorMessage(error))}`));
-        return { taskFeed, taskFeedPublisher };
+        const tailPoller = new TailPoller(taskFeed, taskFeedPublisher, undefined, undefined, (line) => this.logger.log(line), sessionId);
+        return { taskFeed, taskFeedPublisher, tailPoller };
     }
     /** Cleanly tear down a session: cancel in-flight work, release stream
      *  resources, and remove it from the session map. */
@@ -8646,7 +8828,9 @@ export function runAcp(logger) {
         .onNotification(methods.agent.session.cancel, (ctx) => agent.cancel(ctx.params))
         .onRequest(STEER_METHOD, { parse: parseSteerRequest }, (ctx) => agent.steer(ctx.params))
         .onRequest(TASKS_STOP_METHOD, { parse: parseTasksStopRequest }, (ctx) => agent.stopTask(ctx.params))
+        .onRequest(TASKS_OUTPUT_METHOD, { parse: parseTasksOutputRequest }, (ctx) => agent.taskOutput(ctx.params))
         .onRequest(TASKS_BACKGROUND_METHOD, { parse: parseTasksBackgroundRequest }, (ctx) => agent.backgroundTask(ctx.params))
+        .onRequest(USAGE_REFRESH_METHOD, { parse: parseUsageRefreshRequest }, (ctx) => agent.refreshUsage(ctx.params))
         .onRequest(GOAL_CONTROL_METHOD, { parse: parseGoalRequest }, (ctx) => agent.goal(ctx.params))
         .connect(stream);
     agent = new ClaudeAcpAgent(new ClientConnection(connection.client), logger);
@@ -8821,3 +9005,58 @@ function getMatchingModelUsage(modelUsage, currentModel) {
         return { key: bestKey, usage: modelUsage[bestKey] };
     }
 }
+/**
+ * Story 041 (R1.1, R1.6): a backgrounded Bash call's result names the file the
+ * CLI writes its output to. When the structured `BashOutput` carries
+ * `backgroundTaskId` and the text names exactly `<that id>.output` by an
+ * absolute path, the path is recorded for the task's tail. Anything else
+ * records nothing, so the task gets no tail. The rendered tool content is not
+ * touched.
+ */
+function observeBackgroundBashResult(message, content, session) {
+    if (message.type !== "user" || !session.taskFeed || !Array.isArray(content))
+        return;
+    const result = message.tool_use_result;
+    if (typeof result !== "object" || result === null || !("backgroundTaskId" in result))
+        return;
+    const taskId = result.backgroundTaskId;
+    if (typeof taskId !== "string" || taskId === "")
+        return;
+    const blocks = content.filter((c) => typeof c === "object" && c !== null && c.type === "tool_result");
+    // `tool_use_result` describes "the" tool_result of its message: only one.
+    if (blocks.length !== 1)
+        return;
+    const [block] = blocks;
+    if (session.toolUseCache[block.tool_use_id]?.name !== "Bash")
+        return;
+    const text = typeof block.content === "string"
+        ? block.content
+        : Array.isArray(block.content)
+            ? block.content
+                .filter((c) => typeof c === "object" &&
+                c !== null &&
+                c.type === "text" &&
+                typeof c.text === "string")
+                .map((c) => c.text)
+                .join("\n")
+            : "";
+    const path = outputPathFromBashResult(text, taskId);
+    if (path === null)
+        return;
+    session.taskFeedPublisher?.notify(session.taskFeed.onOutputPath(taskId, path));
+    session.tailPoller?.kick();
+}
+/**
+ * Story 041 (R1.7): whether an ending shell task's output file reads, checked
+ * BEFORE the ending is folded into the feed — once the feed holds the ending,
+ * any publish (a throttled trailer, a poller tick) could send it while the
+ * check is still pending, and with `hasOutput: false`. Returns null without
+ * awaiting anything when there is no file to check, so every other ending
+ * keeps its synchronous place in the SDK message loop.
+ */
+async function endingOutputReadable(session, taskId, outputFile) {
+    const path = session.taskFeed?.endingOutputPath(taskId, outputFile) ?? null;
+    if (path === null || !session.tailPoller)
+        return null;
+    return session.tailPoller.checkOutput(path);
+}

package/dist/task-feed.d.ts

@@ -27,10 +27,21 @@
  *
  * Neither class ever copies a command line (`SDKTaskStartedMessage.prompt`)
  * into an entry or a log line.
+ *
+ * Version 2 (story 041) adds `hasOutput` and `tail`. A shell task's output
+ * path — named by the Bash result while it runs, by `task_notification` when
+ * it ends — is kept beside the table, never on the wire. Once an ended shell
+ * task leaves the table, its path moves to a bounded registry so
+ * `_claude/tasks/output` can still serve it.
  */
 import type { SDKTaskNotificationMessage, SDKTaskProgressMessage, SDKTaskStartedMessage, SDKTaskUpdatedMessage } from "@anthropic-ai/claude-agent-sdk";
 /** The `session_info_update._meta` key the snapshot is published under. */
 export declare const TASKS_META_KEY = "_claude/tasks";
+/** The `_claude/tasks` contract version advertised at `initialize`. Version 2
+ *  adds `hasOutput`, `tail` and `_claude/tasks/output`. */
+export declare const TASKS_CONTRACT_VERSION = 2;
+/** Ended shell outputs still servable per session, most recent kept. */
+export declare const ENDED_OUTPUTS_MAX = 256;
 export type TaskStatus = "running" | "completed" | "failed" | "stopped" | "interrupted";
 export type TaskUsage = {
     tokens: number;
@@ -51,6 +62,10 @@ export type TaskEntry = {
     usage: TaskUsage | null;
     lastTool: string | null;
     summary: string | null;
+    /** True when `_claude/tasks/output` can serve this task (version 2). */
+    hasOutput: boolean;
+    /** A running shell's last lines, sanitized; null otherwise (version 2). */
+    tail: string[] | null;
 };
 export type TasksSnapshot = {
     tasks: TaskEntry[];
@@ -97,6 +112,10 @@ export declare class TaskFeed {
     private readonly held;
     /** Shell task ids labelled by their tool call: a patch never relabels them. */
     private readonly toolDescribed;
+    /** Shell task id → its output file, while the task is in the table. */
+    private readonly outputs;
+    /** Ended shell outputs that left the table, oldest first; see `ENDED_OUTPUTS_MAX`. */
+    private readonly endedOutputs;
     constructor(clock: () => number, log?: TaskFeedLog, sessionId?: string);
     /**
      * `toolDescription` is the spawning tool call's own `description` input. A
@@ -126,6 +145,33 @@ export declare class TaskFeed {
     /** The CLI process restarted: whatever was running did not survive it. A
      *  held shell task was never shown, so it is dropped rather than ended. */
     onProcessRestart(): TaskChange;
+    /**
+     * Records the output file a Bash result named for a known shell task. Any
+     * other task, or an unknown id, is ignored: only a shell writes an output
+     * file, and only one the adapter recorded is ever read (R2.5).
+     */
+    onOutputPath(taskId: string, path: string): TaskChange;
+    /**
+     * Sets a shell task's tail and whether its output reads. A running task
+     * keeps `lines`; an ended one keeps none, so this only confirms its output.
+     * Returns `"none"` when nothing changed, so an idle file publishes nothing.
+     */
+    setTail(taskId: string, lines: string[] | null, readable: boolean): TaskChange;
+    /**
+     * The file the ending's existence check reads (R1.7), or null when there is
+     * nothing to check: `taskId` must be a running shell in the table. A non-empty
+     * `output_file` from the ending (the CLI's own) wins over the path the Bash result named.
+     * The caller checks BEFORE folding the ending in, so the snapshot that
+     * carries the ending already says whether the output can be served.
+     */
+    endingOutputPath(taskId: string, outputFile?: string): string | null;
+    /** Running shell tasks with a recorded output file: the tail poller's work. */
+    runningOutputs(): {
+        taskId: string;
+        path: string;
+    }[];
+    /** The output file `_claude/tasks/output` may read for `taskId`, or null. */
+    outputPathFor(taskId: string): string | null;
     /** True when the feed holds `taskId` as running — the stop request's gate. */
     isRunning(taskId: string): boolean;
     /** Running tasks plus ended tasks not yet published, oldest start first.
@@ -148,6 +194,8 @@ export declare class TaskFeed {
      *  the tool call is never replaced. */
     private patch;
     private end;
+    /** Moves a task that left the table to the ended registry, newest last. */
+    private retireOutput;
 }
 export type PublisherTimers = {
     now: () => number;
@@ -192,4 +240,47 @@ export declare class TaskFeedPublisher {
     private armHold;
     private armReconcile;
 }
+/** The longest the ending's existence check may hold the SDK message loop. */
+export declare const ENDING_CHECK_TIMEOUT_MS = 2000;
+/** How often the tail poller looks at running shells' output files (R1.4). */
+export declare const TAIL_POLL_INTERVAL_MS = 1000;
+export type PollerTimers = {
+    setInterval: (fn: () => void, ms: number) => unknown;
+    clearInterval: (handle: any) => void;
+};
+/**
+ * Publishes a running shell task's tail (story 041, R1.4, R1.5). One interval
+ * while any shell output is known; each tick `stat`s every file and reads the
+ * tail only when its size changed, shrinking included. A read error publishes
+ * `tail: null, hasOutput: false` and logs once per task until the file reads
+ * again. A tick never overlaps the previous one, and no rejection escapes it:
+ * the interval runs outside every caller that could handle one, and Node exits
+ * on an unhandled rejection.
+ */
+export declare class TailPoller {
+    private readonly feed;
+    private readonly publisher;
+    private readonly timers;
+    private readonly readTailFn;
+    private readonly log;
+    private readonly sessionId;
+    private interval;
+    private busy;
+    private closed;
+    /** task id → the file size the last published tail was read at. */
+    private readonly sizes;
+    /** Task ids whose file failed to read: logged once, until it reads again. */
+    private readonly failing;
+    constructor(feed: TaskFeed, publisher: TaskFeedPublisher, timers?: PollerTimers, readTailFn?: (path: string) => Promise<string[]>, log?: (line: string) => void, sessionId?: string);
+    /** Arms the interval when there is output to watch. Called after a path is recorded. */
+    kick(): void;
+    /**
+     * The ending's existence check (R1.7): true when `path` reads as a regular
+     * file within `ENDING_CHECK_TIMEOUT_MS`. Never rejects.
+     */
+    checkOutput(path: string): Promise<boolean>;
+    dispose(): void;
+    private stop;
+    private tick;
+}
 //# sourceMappingURL=task-feed.d.ts.map

package/dist/task-feed.d.ts.map

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