@gajae-code/coding-agent 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -17,9 +17,11 @@
 ### Changed
 
 - Added conservative `timeout-minutes` values to all CI workflow jobs to prevent indefinite hangs.
+- Made coordinator MCP turn waiting state-backed by durable turn/session files, with runtime session sidecar updates for running/completed/error states and Meeseeks guidance that avoids fixed sleep/capture-pane loops.
 
 ### Fixed
 
+- Failed stale coordinator turns quickly when their recorded tmux session is gone, clearing active-turn state instead of burning await timeouts.
 - Improved the grep limit-reached message to show the current limit value and suggest using `--limit` for more results.
 - Passed the active model's `maxTokens` (reserved completion budget) into the auto-compaction threshold and context-usage reserve so prompt packing reserves output for large-window models, keeping the safe input budget below the total context window (e.g. ~272K for a 400K/128K model) instead of filling the whole window ([#442](https://github.com/Yeachan-Heo/gajae-code/issues/442)).
 - Fixed a `gjc harness` recovery deadlock where a session created by `start` without `--detach` (persisted as `started` with no owner lease/endpoint) could never get a live owner: `recover` refused to spawn one because no prior endpoint existed, while `start` reported `session-already-exists`. `recover` now bootstraps a fresh owner for a never-started session (no lease, no endpoint, no owner-run evidence) without writing a misleading `vanish` receipt, reported via `bootstrappedOwner: true`. Bootstrap is independent of the vanish classifier's `ownerRequired` verdict (nothing has vanished), so a session started in a non-git workspace (git delta `unknown`) is recovered too, while a deleted worktree is still refused (#421).

package/dist/types/async/job-manager.d.ts

@@ -1,4 +1,4 @@
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 export interface AsyncJob {
     id: string;
     type: "bash" | "task";
@@ -189,6 +189,24 @@ export declare class AsyncJobManager {
     registerLiveHandle(subagentId: string, handle: SubagentLiveHandle): void;
     getLiveHandle(subagentId: string): SubagentLiveHandle | undefined;
     removeLiveHandle(subagentId: string): void;
+    /**
+     * Retain the latest live `AgentProgress` for a subagent (deep-cloned so later
+     * mutation of the live object cannot corrupt retained state). Read by the
+     * `subagent` await panel; cleared on terminal/cancel/purge/dispose.
+     *
+     * Ignored for ids without a canonical `SubagentRecord` (e.g. foreground/inline
+     * task runs that share the executor path) so the map only holds detached
+     * subagent progress and never accumulates untracked foreground task state.
+     */
+    recordSubagentProgress(subagentId: string, progress: AgentProgress): void;
+    getSubagentProgress(subagentId: string): AgentProgress | undefined;
+    /**
+     * True only when a live, in-session progress producer exists for this id: a
+     * canonical registered record with a live handle or an in-memory running job.
+     * False for `SubagentTool` backward-compat job synthesis and resumed-from-disk
+     * records, which have no live producer to stream from.
+     */
+    hasLiveSubagent(subagentId: string, filter?: AsyncJobFilter): boolean;
     /** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
     setResumeRunner(runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined): void;
     registerResumeDescriptor(descriptor: ResumeDescriptor): void;

package/dist/types/cli/setup-cli.d.ts

@@ -1,4 +1,4 @@
-export type SetupComponent = "defaults" | "hooks" | "provider" | "python" | "stt";
+export type SetupComponent = "defaults" | "hermes" | "hooks" | "provider" | "python" | "stt";
 export interface SetupCommandArgs {
     component: SetupComponent;
     flags: {
@@ -12,6 +12,19 @@ export interface SetupCommandArgs {
         apiKeyEnv?: string;
         model?: string[];
         modelsPath?: string;
+        smoke?: boolean;
+        install?: boolean;
+        root?: string[];
+        repo?: string;
+        profile?: string;
+        sessionCommand?: string;
+        stateRoot?: string;
+        mutation?: string[];
+        artifactByteCap?: string;
+        serverKey?: string;
+        gjcCommand?: string;
+        target?: string;
+        profileDir?: string;
     };
 }
 /**

package/dist/types/commands/coordinator.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "@gajae-code/utils/cli";
+export default class Coordinator extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        action: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/mcp-serve.d.ts

@@ -0,0 +1,24 @@
+import { Command } from "@gajae-code/utils/cli";
+export declare function validateMcpServeSubcommandForTest(server: string | undefined): void;
+export default class McpServe extends Command {
+    static description: string;
+    static strict: boolean;
+    static args: {
+        server: import("@gajae-code/utils/cli").ArgDescriptor & {
+            description: string;
+            required: false;
+        };
+    };
+    static flags: {
+        json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+        check: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+            default: boolean;
+        };
+    };
+    run(): Promise<void>;
+}

package/dist/types/commands/setup.d.ts

@@ -24,6 +24,47 @@ export default class Setup extends Command {
         json: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        smoke: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        install: import("@gajae-code/utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
+        root: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        repo: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        profile: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "session-command": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "state-root": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        mutation: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            multiple: true;
+        };
+        "artifact-byte-cap": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "server-key": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "gjc-command": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        target: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
+        "profile-dir": import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+        };
         preset: import("@gajae-code/utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/coordinator/contract.d.ts

@@ -0,0 +1,4 @@
+export declare const COORDINATOR_MCP_PROTOCOL_VERSION = "2024-11-05";
+export declare const COORDINATOR_MCP_SERVER_NAME = "gjc-coordinator-mcp";
+export declare const COORDINATOR_MCP_TOOL_NAMES: readonly ["gjc_coordinator_list_sessions", "gjc_coordinator_read_status", "gjc_coordinator_read_tail", "gjc_coordinator_list_questions", "gjc_coordinator_list_artifacts", "gjc_coordinator_read_artifact", "gjc_coordinator_read_coordination_status", "gjc_coordinator_start_session", "gjc_coordinator_send_prompt", "gjc_coordinator_submit_question_answer", "gjc_coordinator_read_turn", "gjc_coordinator_await_turn", "gjc_coordinator_report_status"];
+export type CoordinatorToolName = (typeof COORDINATOR_MCP_TOOL_NAMES)[number];

package/dist/types/coordinator-mcp/policy.d.ts

@@ -0,0 +1,24 @@
+export type CoordinatorMutationClass = "sessions" | "questions" | "reports";
+export interface CoordinatorNamespace {
+    profile: string | null;
+    repo: string | null;
+}
+export interface CoordinatorMcpConfig {
+    allowedRoots: string[];
+    mutationClasses: Set<CoordinatorMutationClass>;
+    artifactByteCap: number;
+    namespace: CoordinatorNamespace;
+    stateRoot: string;
+    sessionCommand: string | null;
+}
+export interface CoordinatorMutationRequest {
+    allow_mutation?: boolean;
+}
+export declare function buildCoordinatorMcpConfig(env?: NodeJS.ProcessEnv): CoordinatorMcpConfig;
+export declare function assertCoordinatorWorkdir(config: CoordinatorMcpConfig, cwd: unknown): Promise<string>;
+export declare function assertCoordinatorArtifactPath(config: CoordinatorMcpConfig, artifactPath: unknown): Promise<{
+    path: string;
+    byteCap: number;
+}>;
+export declare function requireCoordinatorMutation(config: CoordinatorMcpConfig, mutationClass: CoordinatorMutationClass, request: CoordinatorMutationRequest): void;
+export declare function coordinatorNamespacePath(config: CoordinatorMcpConfig): string;

package/dist/types/coordinator-mcp/safety.d.ts

@@ -0,0 +1,26 @@
+import { type CoordinatorMutationClass } from "./policy";
+export declare const COORDINATOR_MUTATION_CLASSES: readonly ["sessions", "questions", "reports"];
+export type { CoordinatorMutationClass };
+export interface CoordinatorSafetyConfig {
+    allowedRoots: string[];
+    artifactMaxBytes: number;
+    enabledMutationClasses: Set<CoordinatorMutationClass>;
+    repo?: string;
+    profile?: string;
+}
+export interface CoordinatorSafetyPolicy {
+    config: CoordinatorSafetyConfig;
+    resolveWorkdir(input: unknown): Promise<string>;
+    resolveArtifactPath(input: unknown): Promise<string>;
+    assertMutationAllowed(mutationClass: CoordinatorMutationClass, args: Record<string, unknown>): {
+        ok: true;
+    } | CoordinatorFailure;
+}
+export interface CoordinatorFailure {
+    ok: false;
+    reason: string;
+    [key: string]: unknown;
+}
+export declare function createCoordinatorSafetyPolicy(options?: {
+    env?: NodeJS.ProcessEnv;
+}): Promise<CoordinatorSafetyPolicy>;

package/dist/types/coordinator-mcp/server.d.ts

@@ -0,0 +1,52 @@
+import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES, type CoordinatorToolName } from "../coordinator/contract";
+import { type CoordinatorMcpConfig } from "./policy";
+export type { CoordinatorToolName };
+export { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME, COORDINATOR_MCP_TOOL_NAMES };
+interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: string | number | null;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: any;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface SessionStartInput {
+    cwd: string;
+    prompt?: string;
+    namespace: {
+        profile: string | null;
+        repo: string | null;
+    };
+    worktree: true;
+}
+interface CoordinatorServices {
+    listSessions?: () => unknown[] | Promise<unknown[]>;
+    startSession?: (input: SessionStartInput) => unknown | Promise<unknown>;
+}
+interface CoordinatorMcpServerOptions {
+    env?: NodeJS.ProcessEnv;
+    services?: CoordinatorServices;
+}
+interface LegacyHandlerOptions {
+    env?: NodeJS.ProcessEnv;
+    createSession?: () => unknown;
+}
+export declare function readCoordinatorArtifact(config: CoordinatorMcpConfig, args: {
+    path: unknown;
+}): Promise<Record<string, unknown>>;
+export declare function createCoordinatorMcpServer(options?: CoordinatorMcpServerOptions): {
+    config: CoordinatorMcpConfig;
+    callTool: (name: string, args?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    handleJsonRpc: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+    handle: (request: JsonRpcRequest) => Promise<JsonRpcResponse>;
+};
+export declare function handleCoordinatorMcpRequest(request: JsonRpcRequest, options?: LegacyHandlerOptions): Promise<any>;
+export declare function runCoordinatorMcpStdio(options?: CoordinatorMcpServerOptions): Promise<void>;

package/dist/types/extensibility/extensions/types.d.ts

@@ -62,6 +62,19 @@ export interface ExtensionUIDialogOptions {
      * select-only rendering hint; non-TUI bridges drop it and do not serialize it.
      */
     scrollTitleRows?: number;
+    /**
+     * For interactive TUI select dialogs, handle the option with `optionLabel`
+     * inline: selecting it keeps the title and option list on screen and opens
+     * a free-text input below the list. Submitting calls `onSubmit` with the
+     * typed text and resolves the select with `optionLabel`; Escape returns to
+     * option selection. Non-TUI bridges (RPC, ACP) drop it; callers must keep
+     * a fallback path for selects that resolve `optionLabel` without invoking
+     * `onSubmit`.
+     */
+    customInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+    };
 }
 /** Raw terminal input listener for extensions. */
 export type TerminalInputHandler = (data: string) => {

package/dist/types/gjc-runtime/session-state-sidecar.d.ts

@@ -0,0 +1,13 @@
+export declare const GJC_COORDINATOR_SESSION_STATE_FILE_ENV = "GJC_COORDINATOR_SESSION_STATE_FILE";
+export declare const GJC_COORDINATOR_SESSION_ID_ENV = "GJC_COORDINATOR_SESSION_ID";
+interface RuntimeStateEvent {
+    type: string;
+    messages?: unknown[];
+}
+interface RuntimeStateContext {
+    sessionId: string;
+    cwd: string;
+    sessionFile?: string | null;
+}
+export declare function persistCoordinatorRuntimeStateFromEvent(event: RuntimeStateEvent, context: RuntimeStateContext): Promise<void>;
+export {};

package/dist/types/modes/components/hook-selector.d.ts

@@ -22,6 +22,17 @@ export interface HookSelectorOptions {
      */
     wrapFocused?: boolean;
     scrollTitleRows?: number;
+    /**
+     * Inline free-text entry for the option with this label (e.g. the ask
+     * tool's "Other (type your own)"). Selecting it keeps the title and option
+     * list on screen and opens a prompt-style editor below the list instead of
+     * replacing the whole selector. Enter submits via `onSubmit`; Escape
+     * returns to option selection.
+     */
+    customInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+    };
 }
 export declare class HookSelectorComponent extends Container {
     #private;

package/dist/types/setup/hermes-setup.d.ts

@@ -0,0 +1,71 @@
+import { COORDINATOR_MCP_PROTOCOL_VERSION, COORDINATOR_MCP_SERVER_NAME } from "../coordinator/contract";
+export type HermesMutationClass = "sessions" | "questions" | "reports";
+export type HermesSetupMode = "render" | "install" | "check" | "smoke";
+export interface HermesSetupFlags {
+    json?: boolean;
+    check?: boolean;
+    smoke?: boolean;
+    install?: boolean;
+    force?: boolean;
+    root?: string[];
+    repo?: string;
+    profile?: string;
+    sessionCommand?: string;
+    stateRoot?: string;
+    mutation?: string[];
+    artifactByteCap?: string;
+    serverKey?: string;
+    gjcCommand?: string;
+    target?: string;
+    profileDir?: string;
+}
+export interface CoordinatorSetupSpec {
+    schemaVersion: 1;
+    coordinator: "hermes";
+    serverKey: string;
+    serverName: typeof COORDINATOR_MCP_SERVER_NAME;
+    protocolVersion: typeof COORDINATOR_MCP_PROTOCOL_VERSION;
+    gjcCommand: string;
+    args: ["mcp-serve", "coordinator"];
+    roots: string[];
+    namespace: {
+        profile?: string;
+        repo?: string;
+    };
+    sessionCommand?: string;
+    stateRoot?: string;
+    mutationPolicy: {
+        classes: HermesMutationClass[];
+        perCallConsentRequired: true;
+    };
+    artifactByteCap?: number;
+    installTarget?: {
+        kind: "profile-dir" | "config-file";
+        path: string;
+    };
+    operatorTemplateVersion: 1;
+    contractDocVersion: 1;
+}
+export interface HermesSetupResult {
+    ok: boolean;
+    mode: HermesSetupMode;
+    files_written: string[];
+    previews: Array<{
+        path: string;
+        content: string;
+    }>;
+    warnings: string[];
+    smoke: null | {
+        ok: boolean;
+        protocolVersion: string;
+        serverName: string;
+        requiredTools: string[];
+        missingTools: string[];
+    };
+}
+export declare function buildHermesSetupSpec(flags: HermesSetupFlags): CoordinatorSetupSpec;
+export declare function computeHermesSetupSignature(spec: CoordinatorSetupSpec): string;
+export declare function renderHermesServerBlock(spec: CoordinatorSetupSpec): Record<string, unknown>;
+export declare function runHermesSetup(flags: HermesSetupFlags): Promise<HermesSetupResult>;
+export declare function formatHermesSetupResult(result: HermesSetupResult): string;
+export declare function hermesSetupExitCode(error: unknown): number;

package/dist/types/task/render.d.ts

@@ -1,11 +1,17 @@
 import type { Component } from "@gajae-code/tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import type { TaskParams, TaskToolDetails } from "./types";
+import type { AgentProgress, TaskParams, TaskToolDetails } from "./types";
 /**
  * Render the tool call arguments.
  */
 export declare function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component;
+/**
+ * Public wrapper to render a single subagent's live `AgentProgress` for the
+ * `subagent` await panel. Reuses the internal task-progress renderer so the
+ * await panel stays at parity with the inline task panel.
+ */
+export declare function renderSubagentLiveProgress(progress: AgentProgress, expanded: boolean, theme: Theme, spinnerFrame?: number): string[];
 /**
  * Render the tool result.
  */

package/dist/types/tools/subagent-render.d.ts

@@ -0,0 +1,25 @@
+/**
+ * TUI renderer for the `subagent` tool.
+ *
+ * The await panel surfaces each awaited subagent's live streaming status at
+ * parity with the inline `task` panel by reusing `renderSubagentLiveProgress`.
+ * Falls back to a `running, no activity yet` placeholder when a live producer
+ * exists but has not emitted yet, and to a static status line when no live
+ * producer is available (resumed-from-disk or backward-compat records).
+ */
+import type { Component } from "@gajae-code/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { SubagentToolDetails } from "./subagent";
+export declare const subagentToolRenderer: {
+    inline: boolean;
+    renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SubagentToolDetails;
+    }, options: RenderResultOptions, theme: Theme): Component;
+    mergeCallAndResult: boolean;
+};

package/dist/types/tools/subagent.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import * as z from "zod/v4";
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 import type { ToolSession } from "./index";
 declare const subagentSchema: z.ZodObject<{
     action: z.ZodEnum<{
@@ -42,6 +42,10 @@ export interface SubagentSnapshot {
     outputRef?: string;
     truncated?: boolean;
     guidance?: string;
+    /** Live streaming progress for the awaited subagent (await panel only; UI detail). */
+    progress?: AgentProgress;
+    /** True when a live in-session progress producer exists for this subagent. */
+    liveProgressAvailable?: boolean;
 }
 export interface SubagentToolDetails {
     subagents: SubagentSnapshot[];

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/coding-agent",
-	"version": "0.4.3",
+	"version": "0.4.4",
 	"description": "Gajae Code CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://gaebal-gajae.dev",
 	"author": "Yeachan-Heo",
@@ -50,12 +50,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@gajae-code/stats": "0.4.3",
-		"@gajae-code/agent-core": "0.4.3",
-		"@gajae-code/ai": "0.4.3",
-		"@gajae-code/natives": "0.4.3",
-		"@gajae-code/tui": "0.4.3",
-		"@gajae-code/utils": "0.4.3",
+		"@gajae-code/stats": "0.4.4",
+		"@gajae-code/agent-core": "0.4.4",
+		"@gajae-code/ai": "0.4.4",
+		"@gajae-code/natives": "0.4.4",
+		"@gajae-code/tui": "0.4.4",
+		"@gajae-code/utils": "0.4.4",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/async/job-manager.ts

@@ -1,5 +1,5 @@
 import { logger } from "@gajae-code/utils";
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 
 const DELIVERY_RETRY_BASE_MS = 500;
 const DELIVERY_RETRY_MAX_MS = 30_000;
@@ -248,6 +248,7 @@ export class AsyncJobManager {
 	#disposed = false;
 	readonly #subagentRecords = new Map<string, SubagentRecord>();
 	readonly #liveHandles = new Map<string, SubagentLiveHandle>();
+	readonly #subagentProgress = new Map<string, AgentProgress>();
 	readonly #resumeQueue: ResumeQueueEntry[] = [];
 	#resumeSeq = 0;
 	#resumeRunner?: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined;
@@ -531,6 +532,38 @@ export class AsyncJobManager {
 		this.#liveHandles.delete(subagentId);
 	}
 
+	/**
+	 * Retain the latest live `AgentProgress` for a subagent (deep-cloned so later
+	 * mutation of the live object cannot corrupt retained state). Read by the
+	 * `subagent` await panel; cleared on terminal/cancel/purge/dispose.
+	 *
+	 * Ignored for ids without a canonical `SubagentRecord` (e.g. foreground/inline
+	 * task runs that share the executor path) so the map only holds detached
+	 * subagent progress and never accumulates untracked foreground task state.
+	 */
+	recordSubagentProgress(subagentId: string, progress: AgentProgress): void {
+		if (!this.#subagentRecords.has(subagentId)) return;
+		this.#subagentProgress.set(subagentId, structuredClone(progress));
+	}
+
+	getSubagentProgress(subagentId: string): AgentProgress | undefined {
+		return this.#subagentProgress.get(subagentId);
+	}
+
+	/**
+	 * True only when a live, in-session progress producer exists for this id: a
+	 * canonical registered record with a live handle or an in-memory running job.
+	 * False for `SubagentTool` backward-compat job synthesis and resumed-from-disk
+	 * records, which have no live producer to stream from.
+	 */
+	hasLiveSubagent(subagentId: string, filter?: AsyncJobFilter): boolean {
+		const rec = this.getSubagentRecord(subagentId, filter);
+		if (!rec) return false;
+		if (this.#liveHandles.has(rec.subagentId)) return true;
+		const job = rec.currentJobId ? this.#jobs.get(rec.currentJobId) : undefined;
+		return job?.status === "running";
+	}
+
 	/** Install the TaskTool-owned resume runner. Returns the new job id, or undefined on failure. */
 	setResumeRunner(
 		runner: (subagentId: string, message?: string, descriptor?: ResumeDescriptor) => string | undefined,
@@ -561,6 +594,7 @@ export class AsyncJobManager {
 		if (rec) {
 			rec.status = "paused";
 			this.#liveHandles.delete(rec.subagentId);
+			this.#subagentProgress.delete(rec.subagentId);
 		}
 	}
 
@@ -569,6 +603,7 @@ export class AsyncJobManager {
 		if (!rec) return;
 		rec.status = status;
 		this.#liveHandles.delete(rec.subagentId);
+		this.#subagentProgress.delete(rec.subagentId);
 	}
 
 	/** Request a graceful safe-boundary pause of a running subagent. */
@@ -626,6 +661,9 @@ export class AsyncJobManager {
 		message?: string,
 	): { ok: boolean; status?: SubagentLifecycle; jobId?: string; reason?: string } {
 		const prevJobId = rec.currentJobId;
+		// Clear any retained progress from the previous run so a resumed subagent
+		// never renders the prior run's tool/output as live before it emits again.
+		this.#subagentProgress.delete(rec.subagentId);
 		const newJobId = this.#resumeRunner?.(rec.subagentId, message, this.#resumeDescriptors.get(rec.subagentId));
 		if (!newJobId) return { ok: false, reason: "resume_failed" };
 		if (prevJobId && prevJobId !== newJobId) rec.historicalJobIds.push(prevJobId);
@@ -663,6 +701,7 @@ export class AsyncJobManager {
 			}
 			rec.status = "cancelled";
 			this.#liveHandles.delete(rec.subagentId);
+			this.#subagentProgress.delete(rec.subagentId);
 			this.#drainResumeQueue();
 			return true;
 		}
@@ -671,6 +710,7 @@ export class AsyncJobManager {
 			if (idx !== -1) this.#resumeQueue.splice(idx, 1);
 			rec.status = "cancelled";
 			rec.queued = undefined;
+			this.#subagentProgress.delete(rec.subagentId);
 			return true;
 		}
 		return false;
@@ -685,6 +725,7 @@ export class AsyncJobManager {
 				this.#liveHandles.delete(sid);
 				this.#resumeDescriptors.delete(sid);
 				this.#subagentRecords.delete(sid);
+				this.#subagentProgress.delete(sid);
 			}
 		}
 	}
@@ -1021,6 +1062,7 @@ export class AsyncJobManager {
 		this.#ownerCleanups.clear();
 		this.#subagentRecords.clear();
 		this.#liveHandles.clear();
+		this.#subagentProgress.clear();
 		this.#resumeDescriptors.clear();
 		this.#resumeQueue.length = 0;
 		this.#notifyChange();