pulseed 0.5.2 → 0.5.3

package/dist/interface/chat/chat-runner.js

@@ -18,12 +18,15 @@ import { toToolDefinitionsFiltered } from "../../tools/tool-definition-adapter.j
 import { TendCommand } from "./tend-command.js";
 import { EventSubscriber } from "./event-subscriber.js";
 import { buildPromptedToolProtocolSystemPrompt, extractPromptedToolCalls, } from "../../orchestrator/execution/agent-loop/prompted-tool-protocol.js";
+import { classifyFailureRecovery, formatFailureRecovery, formatLifecycleFailureMessage } from "./failure-recovery.js";
 import { resolveExecutionPolicy, summarizeExecutionPolicy, withExecutionPolicyOverrides, } from "../../orchestrator/execution/agent-loop/execution-policy.js";
 import { buildStandaloneIngressMessage, createIngressRouter, } from "./ingress-router.js";
+import { createRuntimeSessionRegistry } from "../../runtime/session-registry/index.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_VERIFY_RETRIES = 2;
 const MAX_TOOL_LOOPS = 5;
 const ACTIVITY_PREVIEW_CHARS = 40;
+const DIFF_ARTIFACT_MAX_LINES = 80;
 const standaloneIngressRouter = createIngressRouter();
 // ─── Command help text ───
 const COMMAND_HELP = `Available commands:
@@ -36,6 +39,7 @@ Session
   /resume [id|title]    Resume native agentloop state for the current or selected session
   /cleanup [--dry-run]  Clean up stale chat sessions
   /compact              Summarize older chat turns and keep the latest turns
+  /context              Show active working context and session assumptions
   /exit                 Exit chat mode
 
 Goals and tasks
@@ -69,14 +73,109 @@ function checkGitChanges(cwd) {
         });
     });
 }
+function runGit(cwd, args, timeout = 5_000) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, timeout }, (err, stdout, stderr) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            resolve((stdout + stderr).trim());
+        });
+    });
+}
+function parseGitLines(output) {
+    return output ? output.split("\n").map((line) => line.trim()).filter(Boolean) : [];
+}
+async function buildUntrackedFilePatch(cwd, relativePath) {
+    const absolutePath = path.resolve(cwd, relativePath);
+    const relativeFromCwd = path.relative(cwd, absolutePath);
+    if (relativeFromCwd.startsWith("..") || path.isAbsolute(relativeFromCwd)) {
+        return `diff --git a/${relativePath} b/${relativePath}\nnew file skipped: path outside workspace`;
+    }
+    try {
+        const stat = await fsp.stat(absolutePath);
+        if (!stat.isFile()) {
+            return `diff --git a/${relativePath} b/${relativePath}\nnew file skipped: not a regular file`;
+        }
+        if (stat.size > 100_000) {
+            return `diff --git a/${relativePath} b/${relativePath}\nnew file skipped: ${stat.size} bytes`;
+        }
+        const content = await fsp.readFile(absolutePath, "utf-8");
+        const lines = content.split("\n");
+        const body = lines.map((line) => `+${line}`).join("\n");
+        return [
+            `diff --git a/${relativePath} b/${relativePath}`,
+            "new file mode 100644",
+            "--- /dev/null",
+            `+++ b/${relativePath}`,
+            `@@ -0,0 +1,${lines.length} @@`,
+            body,
+        ].join("\n");
+    }
+    catch {
+        return `diff --git a/${relativePath} b/${relativePath}\nnew file skipped: unreadable`;
+    }
+}
+async function collectGitDiffArtifact(cwd) {
+    const trackedStat = await runGit(cwd, ["diff", "HEAD", "--stat"]);
+    const untrackedFiles = parseGitLines(await runGit(cwd, ["ls-files", "--others", "--exclude-standard"]));
+    if (!trackedStat && untrackedFiles.length === 0)
+        return null;
+    const trackedNameStatus = await runGit(cwd, ["diff", "HEAD", "--name-status"]) ?? "";
+    const trackedPatch = await runGit(cwd, ["diff", "HEAD", "--patch", "--unified=3"], 10_000) ?? "";
+    const untrackedPatchParts = await Promise.all(untrackedFiles.slice(0, 10).map((file) => buildUntrackedFilePatch(cwd, file)));
+    if (untrackedFiles.length > 10) {
+        untrackedPatchParts.push(`... ${untrackedFiles.length - 10} additional untracked file(s) omitted`);
+    }
+    const stat = [
+        trackedStat,
+        untrackedFiles.length > 0
+            ? ["Untracked files:", ...untrackedFiles.map((file) => `  ${file}`)].join("\n")
+            : "",
+    ].filter(Boolean).join("\n");
+    const nameStatus = [
+        trackedNameStatus,
+        ...untrackedFiles.map((file) => `A\t${file}`),
+    ].filter(Boolean).join("\n");
+    const patch = [trackedPatch, ...untrackedPatchParts].filter(Boolean).join("\n");
+    const patchLines = patch.split("\n");
+    const truncated = patchLines.length > DIFF_ARTIFACT_MAX_LINES;
+    return {
+        stat,
+        nameStatus,
+        patch: patchLines.slice(0, DIFF_ARTIFACT_MAX_LINES).join("\n"),
+        truncated,
+    };
+}
 function previewActivityText(value, maxChars = ACTIVITY_PREVIEW_CHARS) {
     const normalized = value.replace(/\s+/g, " ").trim();
     return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized;
 }
+function classifyInterruptRedirect(input) {
+    const normalized = input.trim().toLowerCase();
+    if (/\b(background|bg)\b|バックグラウンド|裏で|裏側|continue.*background/.test(normalized)) {
+        return "background";
+    }
+    if (/\b(review|read.?only|readonly)\b|レビュー|確認だけ|読むだけ/.test(normalized)) {
+        return "review";
+    }
+    if (/\b(diff|changes?|patch)\b|差分|変更.*見|変更内容/.test(normalized)) {
+        return "diff";
+    }
+    if (/\b(stop|pause|summary|summarize|interrupt)\b|止め|停止|中断|一旦|要約/.test(normalized)) {
+        return "summary";
+    }
+    return "redirect";
+}
 function formatToolActivity(action, toolName, detail) {
     const preview = detail ? previewActivityText(detail) : "";
     return preview ? `${action} tool: ${toolName} - ${preview}` : `${action} tool: ${toolName}`;
 }
+function formatIntentInput(input, maxChars = 96) {
+    const normalized = input.replace(/\s+/g, " ").trim();
+    return normalized.length > maxChars ? `${normalized.slice(0, maxChars - 3)}...` : normalized;
+}
 function resolveSelfIdentityResponse(input, baseDir) {
     const normalized = input.trim().toLowerCase().replace(/\s+/g, "");
     if (!normalized)
@@ -116,6 +215,8 @@ export class ChatRunner {
     nativeAgentLoopStatePath = null;
     runtimeControlContext = null;
     sessionExecutionPolicy = null;
+    lastSelectedRoute = null;
+    activeTurn = null;
     constructor(deps) {
         this.deps = deps;
         this.groundingGateway = createChatGroundingGateway({
@@ -153,6 +254,68 @@ export class ChatRunner {
     getCurrentSessionMessages() {
         return this.history?.getMessages() ?? [];
     }
+    hasActiveTurn() {
+        return this.activeTurn !== null;
+    }
+    async interruptAndRedirect(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn) {
+            return this.execute(input, cwd, timeoutMs);
+        }
+        const start = Date.now();
+        const redirect = classifyInterruptRedirect(input);
+        if (redirect === "background") {
+            return this.emitEphemeralAssistantResult(input, [
+                "Continuing this same turn in the background is not available yet.",
+                "",
+                "The active turn is still running in the foreground.",
+                "Use /tend for daemon-backed work, or send a narrower follow-up request.",
+            ].join("\n"), true, start);
+        }
+        activeTurn.interruptRequested = true;
+        if (!activeTurn.abortController.signal.aborted) {
+            activeTurn.abortController.abort();
+        }
+        this.emitCheckpoint("Interrupt requested", `Redirect: ${previewActivityText(input, 120)}`, activeTurn.context, "interrupt");
+        const stopped = await this.waitForActiveTurn(activeTurn, 2_000);
+        if (!stopped) {
+            return this.emitEphemeralAssistantResult(input, "Interrupt requested. The active turn will stop at the next safe point.", false, start);
+        }
+        if (redirect === "redirect") {
+            return this.execute(input, cwd, timeoutMs);
+        }
+        let output;
+        if (redirect === "diff") {
+            const diff = await collectGitDiffArtifact(activeTurn.cwd);
+            if (diff) {
+                const context = this.createEventContext();
+                this.emitDiffArtifact(diff, context);
+                output = "Interrupted the active turn. Current diff is shown above.";
+            }
+            else {
+                output = "Interrupted the active turn. No working-tree changes were detected.";
+            }
+        }
+        else if (redirect === "review") {
+            const review = await this.handleReview(start);
+            output = `Interrupted the active turn and switched to review-only mode.\n\n${review.output}`;
+        }
+        else {
+            output = [
+                "Interrupted the active turn.",
+                "",
+                "Recent activity",
+                ...(activeTurn.recentEvents.length > 0
+                    ? activeTurn.recentEvents.slice(-6).map((event) => `- ${event}`)
+                    : ["- No activity was captured before the interrupt."]),
+                "",
+                "Next actions",
+                "- Ask for the exact continuation you want.",
+                "- Ask to show diff or switch to review if files may have changed.",
+            ].join("\n");
+        }
+        return this.emitEphemeralAssistantResult(input, output, true, start);
+    }
     setRuntimeControlContext(context) {
         this.runtimeControlContext = context;
     }
@@ -179,6 +342,9 @@ export class ChatRunner {
             hasAgentLoop: this.deps.chatAgentLoopRunner !== undefined,
             hasToolLoop: this.deps.llmClient !== undefined,
             hasRuntimeControlService: this.deps.runtimeControlService !== undefined,
+            hasDaemonTend: this.deps.llmClient !== undefined
+                && this.deps.goalNegotiator !== undefined
+                && this.deps.daemonClient !== undefined,
         };
     }
     buildStandaloneIngressMessage(input, runtimeControlContext) {
@@ -259,15 +425,94 @@ export class ChatRunner {
             ...(session.agentLoop ? { agentLoop: session.agentLoop } : {}),
         };
     }
-    formatSessionsList(entries) {
-        if (entries.length === 0)
-            return "No chat sessions found.";
-        const lines = entries.map((entry) => {
-            const title = entry.title ? ` "${entry.title}"` : "";
-            const resumable = entry.agentLoopResumable ? " resumable" : "";
-            return `${entry.id}${title} - ${entry.messageCount} message(s), updated ${entry.updatedAt}, cwd ${entry.cwd}${resumable}`;
-        });
-        return `Chat sessions:\n${lines.join("\n")}`;
+    formatRuntimeTimestamp(value) {
+        return value ?? "unknown";
+    }
+    formatRuntimeTitle(value) {
+        return value ? ` "${value}"` : "";
+    }
+    runtimeWarningLine(warnings) {
+        return warnings.length > 0 ? `Warnings: ${warnings.length}` : null;
+    }
+    activeRuntimeSession(session) {
+        return session.status === "active";
+    }
+    statusRuntimeRun(run) {
+        return run.status === "queued"
+            || run.status === "running"
+            || run.status === "failed"
+            || run.status === "timed_out"
+            || run.status === "lost";
+    }
+    compactRunLine(run) {
+        const title = this.formatRuntimeTitle(run.title);
+        const updated = this.formatRuntimeTimestamp(run.updated_at ?? run.started_at ?? run.created_at);
+        const summary = run.summary ? ` - ${run.summary.replace(/\s+/g, " ").trim()}` : "";
+        const error = run.error ? ` - error: ${run.error.replace(/\s+/g, " ").trim()}` : "";
+        return `- ${run.id}${title} [${run.kind}, ${run.status}], updated ${updated}${summary}${error}`;
+    }
+    compactSessionLine(session) {
+        const displayId = session.kind === "conversation"
+            ? session.transcript_ref?.id ?? session.id.replace(/^session:conversation:/, "")
+            : session.id;
+        const title = this.formatRuntimeTitle(session.title);
+        const updated = this.formatRuntimeTimestamp(session.updated_at ?? session.last_event_at ?? session.created_at);
+        const workspace = session.workspace ? `, cwd ${session.workspace}` : "";
+        const resumable = session.resumable ? ", resumable" : "";
+        const attachable = session.attachable ? ", attachable" : "";
+        const runtimeId = displayId === session.id ? "" : `, runtime ${session.id}`;
+        return `- ${displayId}${title} [${session.kind}, ${session.status}], updated ${updated}${workspace}${resumable}${attachable}${runtimeId}`;
+    }
+    formatRuntimeSessionsList(snapshot) {
+        const chatSessions = snapshot.sessions.filter((session) => session.kind === "conversation");
+        const nonChatSessions = snapshot.sessions.filter((session) => session.kind !== "conversation");
+        const lines = ["Chat sessions:"];
+        if (chatSessions.length === 0) {
+            lines.push("No chat sessions found.");
+        }
+        else {
+            for (const session of chatSessions) {
+                lines.push(this.compactSessionLine(session));
+                const runs = snapshot.background_runs.filter((run) => run.parent_session_id === session.id);
+                for (const run of runs) {
+                    lines.push(`  ${this.compactRunLine(run)}`);
+                }
+            }
+        }
+        if (nonChatSessions.length > 0) {
+            lines.push("", "Other runtime sessions:");
+            lines.push(...nonChatSessions.map((session) => this.compactSessionLine(session)));
+        }
+        if (snapshot.background_runs.length > 0) {
+            lines.push("", "Background runs:");
+            lines.push(...snapshot.background_runs.map((run) => this.compactRunLine(run)));
+        }
+        const warningLine = this.runtimeWarningLine(snapshot.warnings);
+        if (warningLine)
+            lines.push("", warningLine);
+        return lines.join("\n");
+    }
+    formatRuntimeStatus(snapshot) {
+        const activeSessions = snapshot.sessions.filter((session) => this.activeRuntimeSession(session));
+        const statusRuns = snapshot.background_runs.filter((run) => this.statusRuntimeRun(run));
+        const lines = [];
+        if (activeSessions.length > 0) {
+            lines.push("Active runtime sessions:");
+            lines.push(...activeSessions.map((session) => this.compactSessionLine(session)));
+        }
+        if (statusRuns.length > 0) {
+            if (lines.length > 0)
+                lines.push("");
+            lines.push("Background runs (queued/running/attention-needed):");
+            lines.push(...statusRuns.map((run) => this.compactRunLine(run)));
+        }
+        const warningLine = this.runtimeWarningLine(snapshot.warnings);
+        if (warningLine) {
+            if (lines.length > 0)
+                lines.push("");
+            lines.push(warningLine);
+        }
+        return lines.length > 0 ? lines.join("\n") : "No active runtime sessions or running/failed/lost background runs found.";
     }
     formatHistory(session) {
         const title = session.title ? ` "${session.title}"` : "";
@@ -356,14 +601,19 @@ export class ChatRunner {
             ];
             return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
         }
-        const goals = await this.loadGoals();
+        const registry = createRuntimeSessionRegistry({ stateManager: this.deps.stateManager });
+        const [goals, runtimeSnapshot] = await Promise.all([
+            this.loadGoals(),
+            registry.snapshot(),
+        ]);
         const active = this.activeGoals(goals);
+        const runtimeStatus = this.formatRuntimeStatus(runtimeSnapshot);
         if (active.length === 0) {
-            return { success: true, output: "No active goals found.", elapsed_ms: Date.now() - start };
+            return { success: true, output: `No active goals found.\n\n${runtimeStatus}`, elapsed_ms: Date.now() - start };
         }
         return {
             success: true,
-            output: `Active goals:\n${active.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            output: `Active goals:\n${active.map((goal) => this.formatGoalLine(goal)).join("\n")}\n\n${runtimeStatus}`,
             elapsed_ms: Date.now() - start,
         };
     }
@@ -812,7 +1062,79 @@ export class ChatRunner {
             elapsed_ms: Date.now() - start,
         };
     }
-    async handleCommand(input) {
+    formatRoute(route) {
+        if (!route)
+            return "none selected yet";
+        const details = [
+            `lane=${route.lane}`,
+            `kind=${route.kind}`,
+            `reason=${route.reason}`,
+        ];
+        if (route.kind === "direct_answer") {
+            details.push(`model_tier=${route.modelTier}`, `max_tokens=${route.maxTokens}`);
+        }
+        if (route.kind === "runtime_control") {
+            details.push(`intent=${route.intent.kind}`);
+        }
+        return details.join(", ");
+    }
+    async handleContext(start, cwdOverride) {
+        const cwd = this.sessionCwd ?? (cwdOverride ? resolveGitRoot(cwdOverride) : process.cwd());
+        const session = this.history?.getSessionData() ?? null;
+        const messages = session?.messages ?? [];
+        const policy = await this.getSessionExecutionPolicy();
+        const recentMessages = messages.slice(-6);
+        const userTurns = messages.filter((message) => message.role === "user").length;
+        const assistantTurns = messages.filter((message) => message.role === "assistant").length;
+        const compactionSummary = session?.compactionSummary?.trim() ?? "";
+        const agentLoopPath = this.nativeAgentLoopStatePath ?? session?.agentLoopStatePath ?? null;
+        const replyTarget = this.runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null;
+        const routeCapabilities = this.getRouteCapabilities();
+        const replyTargetParts = replyTarget
+            ? [replyTarget.surface, replyTarget.platform, replyTarget.conversation_id].filter(Boolean)
+            : [];
+        const contextLines = [
+            "Working context",
+            "",
+            "Session",
+            `- session_id: ${this.history?.getSessionId() ?? "none"}`,
+            `- cwd: ${cwd}`,
+            `- messages: ${messages.length} (${userTurns} user, ${assistantTurns} assistant)`,
+            `- recent_turns_retained: ${recentMessages.length}`,
+            `- compaction_summary: ${compactionSummary ? "present" : "none"}`,
+            `- agentloop_state_path: ${agentLoopPath ?? "none"}`,
+            "",
+            "Turn context",
+            `- last_selected_route: ${this.formatRoute(this.lastSelectedRoute)}`,
+            `- reply_target: ${replyTargetParts.length > 0 ? replyTargetParts.join(":") : "none"}`,
+            `- route_capabilities: light_llm=${routeCapabilities.hasLightweightLlm}, agent_loop=${routeCapabilities.hasAgentLoop}, tool_loop=${routeCapabilities.hasToolLoop}, runtime_control=${routeCapabilities.hasRuntimeControlService}, daemon_tend=${routeCapabilities.hasDaemonTend}`,
+            "",
+            "Working assumptions",
+            "- this view exposes operational context, not hidden reasoning",
+            "- last_selected_route describes the most recent non-command turn in this ChatRunner",
+            "- future turns may select a different route based on the next input",
+            "",
+            "Active constraints",
+            ...summarizeExecutionPolicy(policy).split("\n").map((line) => `- ${line}`),
+            "",
+            "Included context",
+            "- current session cwd and execution policy because they constrain tool and route behavior",
+            `- ${recentMessages.length} latest persisted message(s)`,
+            `- ${compactionSummary ? "compacted older chat summary because older turns were summarized" : "no compacted older chat summary because none is stored"}`,
+            `- ${agentLoopPath ? "native agent-loop resume path because this session can persist agent-loop state" : "no native agent-loop resume path because none is active"}`,
+            "",
+            "Not included",
+            "- hidden reasoning or private model chain-of-thought",
+            "- raw state files unless a command explicitly reads them",
+            "- older chat turns beyond the retained window unless compacted into the session summary",
+        ];
+        return {
+            success: true,
+            output: contextLines.join("\n"),
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleCommand(input, cwd) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/"))
             return null;
@@ -826,9 +1148,9 @@ export class ChatRunner {
             return { success: true, output: "Conversation history cleared.", elapsed_ms: Date.now() - start };
         }
         if (cmd === "/sessions") {
-            const catalog = new ChatSessionCatalog(this.deps.stateManager);
-            const sessions = await catalog.listSessions();
-            return { success: true, output: this.formatSessionsList(sessions), elapsed_ms: Date.now() - start };
+            const registry = createRuntimeSessionRegistry({ stateManager: this.deps.stateManager });
+            const snapshot = await registry.snapshot();
+            return { success: true, output: this.formatRuntimeSessionsList(snapshot), elapsed_ms: Date.now() - start };
         }
         if (cmd === "/history") {
             const catalog = new ChatSessionCatalog(this.deps.stateManager);
@@ -901,6 +1223,9 @@ export class ChatRunner {
         if (cmd === "/usage") {
             return this.handleUsage(trimmed.slice("/usage".length).trim(), start);
         }
+        if (cmd === "/context" || cmd === "/working-memory") {
+            return this.handleContext(start, cwd);
+        }
         if (cmd === "/review") {
             return this.handleReview(start);
         }
@@ -910,6 +1235,26 @@ export class ChatRunner {
         if (cmd === "/undo") {
             return this.handleUndo(start);
         }
+        if (cmd === "/retry") {
+            return {
+                success: false,
+                output: [
+                    "/retry is not supported yet.",
+                    "",
+                    formatFailureRecovery({
+                        kind: "runtime_interruption",
+                        label: "Retry unavailable",
+                        summary: "PulSeed does not yet have a safe replay contract for the previous turn.",
+                        nextActions: [
+                            "Use /review to inspect any current diff before continuing.",
+                            "Use /resume when PulSeed reports resumable agent-loop state.",
+                            "Ask for the exact next step to rerun instead of replaying the full turn.",
+                        ],
+                    }),
+                ].join("\n"),
+                elapsed_ms: Date.now() - start,
+            };
+        }
         if (cmd === "/exit") {
             return { success: true, output: "Exiting chat mode.", elapsed_ms: Date.now() - start };
         }
@@ -1110,6 +1455,9 @@ export class ChatRunner {
             daemonClient: this.deps.daemonClient,
             stateManager: this.deps.stateManager,
             chatHistory: history,
+            sessionId: this.history?.getSessionId() ?? null,
+            workspace: this.sessionCwd ?? process.cwd(),
+            replyTarget: this.runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null,
         };
         const tendCommand = new TendCommand();
         const result = await tendCommand.execute(args, tendDeps);
@@ -1175,7 +1523,34 @@ export class ChatRunner {
             }
         }
         try {
-            await this.deps.daemonClient.startGoal(goalId);
+            const tendDeps = {
+                llmClient: this.deps.llmClient,
+                goalNegotiator: this.deps.goalNegotiator,
+                daemonClient: this.deps.daemonClient,
+                stateManager: this.deps.stateManager,
+                chatHistory: this.history?.getMessages() ?? [],
+                sessionId: this.history?.getSessionId() ?? null,
+                workspace: this.sessionCwd ?? process.cwd(),
+                replyTarget: this.runtimeControlContext?.replyTarget ?? this.deps.runtimeReplyTarget ?? null,
+            };
+            const result = await new TendCommand().startAcceptedGoal(goalId, maxIterations, tendDeps);
+            if (!result.success) {
+                if (subscriber) {
+                    subscriber.unsubscribe();
+                    this.activeSubscribers.delete(goalId);
+                }
+                return {
+                    success: false,
+                    output: result.message,
+                    elapsed_ms: Date.now() - start,
+                };
+            }
+            const shortId = goalId.length > 12 ? goalId.slice(0, 12) : goalId;
+            return {
+                success: true,
+                output: `[tend] ${shortId}: Started — daemon is now tending your goal${maxIterations !== undefined ? ` (max ${maxIterations} iterations)` : ""}.\nBackground run: ${result.backgroundRunId}\nRun 'pulseed status' to check progress.`,
+                elapsed_ms: Date.now() - start,
+            };
         }
         catch (err) {
             if (subscriber) {
@@ -1189,13 +1564,6 @@ export class ChatRunner {
                 elapsed_ms: Date.now() - start,
             };
         }
-        const iterNote = maxIterations !== undefined ? ` (max ${maxIterations} iterations)` : "";
-        const shortId = goalId.length > 12 ? goalId.slice(0, 12) : goalId;
-        return {
-            success: true,
-            output: `[tend] ${shortId}: Started — daemon is now tending your goal${iterNote}.\nRun 'pulseed status' to check progress.`,
-            elapsed_ms: Date.now() - start,
-        };
     }
     /**
      * Execute a single chat turn.
@@ -1211,12 +1579,13 @@ export class ChatRunner {
      */
     async execute(input, cwd, timeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
         const eventContext = this.createEventContext();
+        const activeTurn = this.beginActiveTurn(eventContext, resolveGitRoot(cwd));
         const resumeCommand = this.parseResumeCommand(input);
         const resumeOnly = resumeCommand !== null;
         const runtimeControlContext = options.runtimeControlContext ?? this.runtimeControlContext;
         const executionGoalId = options.goalId ?? this.deps.goalId;
         // Intercept commands before any adapter call
-        const commandResult = resumeOnly ? null : await this.handleCommand(input);
+        const commandResult = resumeOnly ? null : await this.handleCommand(input, cwd);
         if (commandResult !== null) {
             if (commandResult.output) {
                 this.emitEvent({
@@ -1245,11 +1614,24 @@ export class ChatRunner {
         }
         if (resumeOnly && resumeCommand.selector) {
             try {
+                const selectorResolution = await this.resolveChatResumeSelector(resumeCommand.selector);
+                if (selectorResolution.nonResumableMessage) {
+                    const elapsed_ms = 0;
+                    const output = selectorResolution.nonResumableMessage;
+                    this.emitEvent({
+                        type: "assistant_final",
+                        text: output,
+                        persisted: false,
+                        ...this.eventBase(eventContext),
+                    });
+                    this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
+                    return { success: false, output, elapsed_ms };
+                }
                 const catalog = new ChatSessionCatalog(this.deps.stateManager);
-                const session = await catalog.loadSessionBySelector(resumeCommand.selector);
+                const session = await catalog.loadSessionBySelector(selectorResolution.chatSelector);
                 if (!session) {
                     const elapsed_ms = 0;
-                    const output = `No chat session matched selector "${resumeCommand.selector}".`;
+                    const output = `No chat session matched selector "${selectorResolution.chatSelector}".`;
                     this.emitEvent({
                         type: "assistant_final",
                         text: output,
@@ -1284,6 +1666,7 @@ export class ChatRunner {
         }
         const executionCwd = this.sessionCwd ?? cwd;
         const gitRoot = this.sessionCwd ?? resolveGitRoot(cwd);
+        activeTurn.cwd = gitRoot;
         // history is always assigned by this point (either by startSession or the block above)
         const history = this.history;
         this.emitEvent({
@@ -1323,7 +1706,14 @@ export class ChatRunner {
         const selectedRoute = resumeOnly
             ? null
             : (options.selectedRoute ?? this.resolveRouteFromInput(input, runtimeControlContext));
+        this.lastSelectedRoute = selectedRoute;
         const directPrompt = historyBlock ? `${historyBlock}${input}` : input;
+        if (!resumeOnly) {
+            this.emitIntent(input, selectedRoute, eventContext);
+        }
+        else if (resumeOnly) {
+            this.emitIntent(input, null, eventContext);
+        }
         const start = Date.now();
         const assistantBuffer = { text: "" };
         const turnUsage = this.zeroUsageCounter();
@@ -1346,9 +1736,11 @@ export class ChatRunner {
             };
         }
         if (selectedRoute?.kind === "runtime_control") {
+            this.emitCheckpoint("Runtime control selected", `${selectedRoute.intent.kind} request recognized.`, eventContext, "route");
             const runtimeControlResult = await this.executeRuntimeControlRoute(selectedRoute, runtimeControlContext, executionCwd, start);
             if (runtimeControlResult.success) {
                 await history.appendAssistantMessage(runtimeControlResult.output);
+                this.emitCheckpoint("Runtime control completed", "The runtime-control operation produced a result.", eventContext, "complete");
                 this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                 this.emitEvent({
                     type: "assistant_final",
@@ -1359,11 +1751,32 @@ export class ChatRunner {
                 this.emitLifecycleEndEvent("completed", runtimeControlResult.elapsed_ms, eventContext, true);
             }
             else {
-                this.emitLifecycleErrorEvent(runtimeControlResult.output, assistantBuffer.text, eventContext);
+                runtimeControlResult.output = this.emitLifecycleErrorEvent(runtimeControlResult.output, assistantBuffer.text, eventContext);
                 this.emitLifecycleEndEvent("error", runtimeControlResult.elapsed_ms, eventContext, false);
             }
             return runtimeControlResult;
         }
+        if (selectedRoute?.kind === "daemon_tend") {
+            this.emitCheckpoint("Durable goal selected", "This long-running request is being prepared for daemon-backed CoreLoop execution.", eventContext, "route");
+            const tendResult = await this.handleTend("", start);
+            if (tendResult.success) {
+                await history.appendAssistantMessage(tendResult.output);
+                this.emitCheckpoint("Durable goal prepared", "The daemon-backed goal confirmation is ready.", eventContext, "complete");
+                this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
+                this.emitEvent({
+                    type: "assistant_final",
+                    text: tendResult.output,
+                    persisted: true,
+                    ...this.eventBase(eventContext),
+                });
+                this.emitLifecycleEndEvent("completed", tendResult.elapsed_ms, eventContext, true);
+            }
+            else {
+                tendResult.output = this.emitLifecycleErrorEvent(tendResult.output, assistantBuffer.text, eventContext);
+                this.emitLifecycleEndEvent("error", tendResult.elapsed_ms, eventContext, false);
+            }
+            return tendResult;
+        }
         if (selectedRoute?.kind === "direct_answer") {
             try {
                 this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
@@ -1378,7 +1791,12 @@ export class ChatRunner {
                 if (this.hasUsage(turnUsage)) {
                     history.recordUsage("execution", turnUsage);
                 }
+                const diffArtifact = await collectGitDiffArtifact(gitRoot);
+                if (diffArtifact) {
+                    this.emitDiffArtifact(diffArtifact, eventContext);
+                }
                 await history.appendAssistantMessage(output);
+                this.emitCheckpoint("Response ready", "The direct answer has been persisted for this turn.", eventContext, "complete");
                 this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                 this.emitEvent({
                     type: "assistant_final",
@@ -1401,13 +1819,11 @@ export class ChatRunner {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
+                const output = this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
                 this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
                 return {
                     success: false,
-                    output: assistantBuffer.text
-                        ? `${assistantBuffer.text}\n\n[interrupted: ${message}]`
-                        : `Error: ${message}`,
+                    output,
                     elapsed_ms: Date.now() - start,
                     diagnostics: {
                         route: "direct",
@@ -1453,6 +1869,9 @@ export class ChatRunner {
             catch {
                 systemPrompt = this.cachedStaticSystemPrompt ?? "";
             }
+            this.emitCheckpoint("Context gathered", usesNativeAgentLoop
+                ? "Workspace and agent-loop grounding are ready."
+                : "Workspace grounding is ready.", eventContext, "context");
         }
         const agentLoopSystemPrompt = [
             systemPrompt,
@@ -1466,13 +1885,7 @@ export class ChatRunner {
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
         if (resumeOnly && !this.deps.chatAgentLoopRunner) {
             const elapsed_ms = Date.now() - start;
-            const output = "Resume requires the native chat agentloop runtime.";
-            this.emitEvent({
-                type: "assistant_final",
-                text: output,
-                persisted: false,
-                ...this.eventBase(eventContext),
-            });
+            const output = this.emitLifecycleErrorEvent("Resume requires the native chat agentloop runtime.", assistantBuffer.text, eventContext);
             this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
             return {
                 success: false,
@@ -1486,13 +1899,7 @@ export class ChatRunner {
                 const resumeState = resumeOnly ? await this.loadResumableAgentLoopState() : null;
                 if (resumeOnly && !resumeState) {
                     const elapsed_ms = Date.now() - start;
-                    const output = "No resumable native agentloop state found.";
-                    this.emitEvent({
-                        type: "assistant_final",
-                        text: output,
-                        persisted: false,
-                        ...this.eventBase(eventContext),
-                    });
+                    const output = this.emitLifecycleErrorEvent("No resumable native agentloop state found.", assistantBuffer.text, eventContext);
                     this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
                     return {
                         success: false,
@@ -1500,6 +1907,9 @@ export class ChatRunner {
                         elapsed_ms,
                     };
                 }
+                this.emitCheckpoint(resumeOnly ? "Session resumed" : "Agent loop started", resumeOnly
+                    ? "Resumable agent-loop state is loaded."
+                    : "The agent loop can now inspect, plan, edit, or verify with visible tool activity.", eventContext, "execution");
                 this.emitActivity("lifecycle", "Calling model...", eventContext, "lifecycle:model");
                 const result = await chatAgentLoopRunner.execute({
                     message: basePrompt,
@@ -1523,6 +1933,7 @@ export class ChatRunner {
                     ...(resumeState ? { resumeState } : {}),
                     ...(resumeOnly ? { resumeOnly: true } : {}),
                     ...(agentLoopSystemPrompt ? { systemPrompt: agentLoopSystemPrompt } : {}),
+                    abortSignal: activeTurn.abortController.signal,
                 });
                 const elapsed_ms = Date.now() - start;
                 const agentLoopUsage = result.agentLoop?.usage
@@ -1535,7 +1946,12 @@ export class ChatRunner {
                     this.pushAssistantDelta(result.output, assistantBuffer, eventContext);
                 }
                 if (result.success) {
+                    const diffArtifact = await collectGitDiffArtifact(gitRoot);
+                    if (diffArtifact) {
+                        this.emitDiffArtifact(diffArtifact, eventContext);
+                    }
                     await history.appendAssistantMessage(result.output);
+                    this.emitCheckpoint("Response ready", "The agent-loop response has been persisted for this turn.", eventContext, "complete");
                     this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                     this.emitEvent({
                         type: "assistant_final",
@@ -1546,7 +1962,7 @@ export class ChatRunner {
                     this.emitLifecycleEndEvent("completed", elapsed_ms, eventContext, true);
                 }
                 else {
-                    this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", assistantBuffer.text, eventContext);
+                    result.output = this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", assistantBuffer.text, eventContext);
                     this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
                 }
                 return {
@@ -1557,13 +1973,11 @@ export class ChatRunner {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
+                const output = this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
                 this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
                 return {
                     success: false,
-                    output: assistantBuffer.text
-                        ? `${assistantBuffer.text}\n\n[interrupted: ${message}]`
-                        : `Error: ${message}`,
+                    output,
                     elapsed_ms: Date.now() - start,
                 };
             }
@@ -1571,12 +1985,18 @@ export class ChatRunner {
         // Prefer the local LLM/tool loop over the external adapter fallback whenever a client is available.
         if (selectedRoute?.kind === "tool_loop") {
             try {
+                this.emitCheckpoint("Tool loop started", "The model will choose tools from the active catalog.", eventContext, "execution");
                 const toolResult = await this.executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt || undefined, executionGoalId);
                 const elapsed_ms = Date.now() - start;
                 if (this.hasUsage(toolResult.usage)) {
                     history.recordUsage("execution", toolResult.usage);
                 }
+                const diffArtifact = await collectGitDiffArtifact(gitRoot);
+                if (diffArtifact) {
+                    this.emitDiffArtifact(diffArtifact, eventContext);
+                }
                 await history.appendAssistantMessage(toolResult.output);
+                this.emitCheckpoint("Response ready", "The tool-loop response has been persisted for this turn.", eventContext, "complete");
                 this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
                 this.emitEvent({
                     type: "assistant_final",
@@ -1589,21 +2009,18 @@ export class ChatRunner {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
+                const output = this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
                 this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
                 return {
                     success: false,
-                    output: assistantBuffer.text
-                        ? `${assistantBuffer.text}\n\n[interrupted: ${message}]`
-                        : `Error: ${message}`,
+                    output,
                     elapsed_ms: Date.now() - start,
                 };
             }
         }
         if (!resumeOnly && selectedRoute && selectedRoute.kind !== "adapter") {
             const elapsed_ms = Date.now() - start;
-            const output = `Unsupported chat route: ${selectedRoute.kind}`;
-            this.emitLifecycleErrorEvent(output, assistantBuffer.text, eventContext);
+            const output = this.emitLifecycleErrorEvent(`Unsupported chat route: ${selectedRoute.kind}`, assistantBuffer.text, eventContext);
             this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
             return {
                 success: false,
@@ -1619,10 +2036,25 @@ export class ChatRunner {
             ...(systemPrompt ? { system_prompt: systemPrompt } : {}),
         };
         const resolvedTimeoutMs = task.timeout_ms ?? DEFAULT_TIMEOUT_MS;
+        this.emitCheckpoint("Adapter started", "The configured adapter has the current prompt and project context.", eventContext, "execution");
         this.emitActivity("lifecycle", "Calling adapter...", eventContext, "lifecycle:adapter");
         const adapterPromise = this.deps.adapter.execute(task);
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Chat adapter timed out after ${resolvedTimeoutMs}ms`)), resolvedTimeoutMs));
-        let result = await Promise.race([adapterPromise, timeoutPromise]);
+        let result;
+        try {
+            result = await Promise.race([adapterPromise, timeoutPromise]);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const output = this.emitLifecycleErrorEvent(message, assistantBuffer.text, eventContext);
+            const timeoutElapsedMs = Date.now() - start;
+            this.emitLifecycleEndEvent("error", timeoutElapsedMs, eventContext, false);
+            return {
+                success: false,
+                output,
+                elapsed_ms: timeoutElapsedMs,
+            };
+        }
         // Surface adapter errors into output when output is empty
         if (!result.output && result.error) {
             result = { ...result, output: `Error: ${result.error}` };
@@ -1632,34 +2064,47 @@ export class ChatRunner {
             this.pushAssistantDelta(result.output, assistantBuffer, eventContext);
         }
         // Verification loop: check if git has uncommitted changes; if so, run tests
-        const gitChanges = await checkGitChanges(gitRoot);
-        if (gitChanges !== null && gitChanges !== "") {
+        const diffArtifact = await collectGitDiffArtifact(gitRoot);
+        if (diffArtifact) {
             let retries = 0;
             const VERIFY_TIMEOUT_MS = 30_000;
+            this.emitCheckpoint("Changes detected", "Verification is starting because the turn changed the working tree.", eventContext, "changes");
             this.emitActivity("lifecycle", "Checking result...", eventContext, "lifecycle:checking");
             let verification = await Promise.race([
-                verifyChatAction(gitRoot, this.deps.toolExecutor),
+                verifyChatAction(gitRoot, this.deps.toolExecutor, { force: true }),
                 new Promise((resolve) => setTimeout(() => resolve({ passed: true }), VERIFY_TIMEOUT_MS)),
             ]);
             while (!verification.passed && retries < MAX_VERIFY_RETRIES) {
                 retries++;
+                this.emitCheckpoint("Verification retry", `Attempt ${retries} of ${MAX_VERIFY_RETRIES} is repairing failed checks.`, eventContext, `verification-retry-${retries}`);
                 const retryPrompt = `The previous changes caused test failures. Please fix them.\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`;
                 const retryTask = { ...task, prompt: retryPrompt };
                 result = await this.deps.adapter.execute(retryTask);
-                verification = await verifyChatAction(gitRoot, this.deps.toolExecutor);
+                verification = await verifyChatAction(gitRoot, this.deps.toolExecutor, { force: true });
             }
             if (!verification.passed) {
-                this.emitLifecycleErrorEvent(`Changes applied but tests are still failing after ${MAX_VERIFY_RETRIES} retries.`, assistantBuffer.text, eventContext);
+                const finalDiffArtifact = await collectGitDiffArtifact(gitRoot);
+                if (finalDiffArtifact) {
+                    this.emitDiffArtifact(finalDiffArtifact, eventContext);
+                }
+                this.emitCheckpoint("Verification failed", `Checks are still failing after ${MAX_VERIFY_RETRIES} retries.`, eventContext, "verification");
+                const failureOutput = this.emitLifecycleErrorEvent(`Changes applied but tests are still failing after ${MAX_VERIFY_RETRIES} retries.`, assistantBuffer.text, eventContext);
                 this.emitLifecycleEndEvent("error", Date.now() - start, eventContext, false);
                 return {
                     success: false,
-                    output: `${assistantBuffer.text}\n\n[interrupted: tests are still failing after ${MAX_VERIFY_RETRIES} retries]\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`.trim(),
+                    output: `${failureOutput}\n\nTest output:\n${verification.testOutput ?? verification.errors.join("\n")}`.trim(),
                     elapsed_ms: Date.now() - start,
                 };
             }
+            const finalDiffArtifact = await collectGitDiffArtifact(gitRoot);
+            if (finalDiffArtifact) {
+                this.emitDiffArtifact(finalDiffArtifact, eventContext);
+            }
+            this.emitCheckpoint("Verification passed", "Changed files passed the configured chat verification.", eventContext, "verification");
         }
         if (result.success) {
             await history.appendAssistantMessage(result.output);
+            this.emitCheckpoint("Response ready", "The assistant response has been persisted for this turn.", eventContext, "complete");
             this.emitActivity("lifecycle", "Finalizing response...", eventContext, "lifecycle:finalizing");
             this.emitEvent({
                 type: "assistant_final",
@@ -1671,7 +2116,7 @@ export class ChatRunner {
         }
         else {
             const partialText = assistantBuffer.text !== result.output ? assistantBuffer.text : "";
-            this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", partialText, eventContext);
+            result.output = this.emitLifecycleErrorEvent(result.output || result.error || "Unknown error", partialText, eventContext);
             this.emitLifecycleEndEvent("error", elapsed_ms, eventContext, false);
         }
         return {
@@ -1854,6 +2299,7 @@ export class ChatRunner {
                 }
                 if (event.type === "plan_update") {
                     this.emitActivity("tool", `Updated plan: ${previewActivityText(event.summary)}`, eventContext, `plan:${event.turnId}`);
+                    this.emitCheckpoint("Plan updated", previewActivityText(event.summary, 160), eventContext, `plan:${event.eventId}`);
                     this.emitEvent({
                         type: "tool_update",
                         toolCallId: `plan:${event.turnId}:${event.createdAt}`,
@@ -1866,6 +2312,7 @@ export class ChatRunner {
                 }
                 if (event.type === "approval_request") {
                     this.emitActivity("tool", formatToolActivity("Running", event.toolName, `awaiting approval: ${event.reason}`), eventContext, event.callId);
+                    this.emitCheckpoint("Approval requested", `${event.toolName}: ${event.reason}`, eventContext, `approval:${event.callId}`);
                     this.emitEvent({
                         type: "tool_update",
                         toolCallId: event.callId,
@@ -1924,6 +2371,34 @@ export class ChatRunner {
         }
         return preview ? { preview } : {};
     }
+    async resolveChatResumeSelector(selector) {
+        if (selector.startsWith("session:conversation:")) {
+            return { chatSelector: selector.slice("session:conversation:".length) };
+        }
+        if (selector.startsWith("session:") || selector.startsWith("run:")) {
+            const registry = createRuntimeSessionRegistry({ stateManager: this.deps.stateManager });
+            if (selector.startsWith("session:")) {
+                const session = await registry.getSession(selector);
+                if (session?.kind === "conversation") {
+                    return { chatSelector: selector.slice("session:conversation:".length) };
+                }
+                if (session?.kind === "agent"
+                    && session.resumable
+                    && session.parent_session_id?.startsWith("session:conversation:")) {
+                    return { chatSelector: session.parent_session_id.slice("session:conversation:".length) };
+                }
+                return {
+                    chatSelector: selector,
+                    nonResumableMessage: `Runtime session ${selector} is not chat-resumable. Inspect it with 'pulseed runtime session ${selector}'.`,
+                };
+            }
+            return {
+                chatSelector: selector,
+                nonResumableMessage: `Background run ${selector} is not chat-resumable. Inspect it with 'pulseed runtime run ${selector}'.`,
+            };
+        }
+        return { chatSelector: selector };
+    }
     parseResumeCommand(input) {
         const trimmed = input.trim();
         const match = /^\/resume(?:\s+(.+))?$/i.exec(trimmed);
@@ -2134,11 +2609,81 @@ export class ChatRunner {
     eventBase(context) {
         return { ...context, createdAt: new Date().toISOString() };
     }
+    beginActiveTurn(context, cwd) {
+        let resolveFinished = () => { };
+        const finished = new Promise((resolve) => {
+            resolveFinished = resolve;
+        });
+        const turn = {
+            context,
+            cwd,
+            startedAt: Date.now(),
+            abortController: new AbortController(),
+            finished,
+            resolveFinished,
+            recentEvents: [],
+            interruptRequested: false,
+        };
+        this.activeTurn = turn;
+        return turn;
+    }
+    finishActiveTurn(context) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn || activeTurn.context.runId !== context.runId)
+            return;
+        activeTurn.resolveFinished();
+        this.activeTurn = null;
+    }
+    waitForActiveTurn(turn, timeoutMs) {
+        return Promise.race([
+            turn.finished.then(() => true),
+            new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+        ]);
+    }
+    emitEphemeralAssistantResult(input, output, success, start) {
+        const context = this.createEventContext();
+        this.emitEvent({
+            type: "lifecycle_start",
+            input,
+            ...this.eventBase(context),
+        });
+        this.emitEvent({
+            type: "assistant_final",
+            text: output,
+            persisted: false,
+            ...this.eventBase(context),
+        });
+        const elapsed_ms = Date.now() - start;
+        this.emitLifecycleEndEvent(success ? "completed" : "error", elapsed_ms, context, false);
+        return { success, output, elapsed_ms };
+    }
+    rememberActiveTurnEvent(event) {
+        const activeTurn = this.activeTurn;
+        if (!activeTurn || activeTurn.context.turnId !== event.turnId)
+            return;
+        let summary = null;
+        if (event.type === "activity") {
+            summary = previewActivityText(event.message, 140);
+        }
+        else if (event.type === "tool_start") {
+            summary = `Started ${event.toolName}`;
+        }
+        else if (event.type === "tool_update") {
+            summary = `${event.toolName}: ${previewActivityText(event.message, 100)}`;
+        }
+        else if (event.type === "tool_end") {
+            summary = `${event.success ? "Finished" : "Failed"} ${event.toolName}: ${previewActivityText(event.summary, 100)}`;
+        }
+        if (!summary)
+            return;
+        activeTurn.recentEvents = [...activeTurn.recentEvents, summary].slice(-12);
+    }
     emitEvent(event) {
+        this.rememberActiveTurnEvent(event);
         const handler = this.onEvent ?? this.deps.onEvent;
         handler?.(event);
     }
-    emitActivity(kind, message, eventContext, sourceId) {
+    emitActivity(kind, message, eventContext, sourceId, transient = true) {
         if (!message.trim())
             return;
         this.emitEvent({
@@ -2146,10 +2691,72 @@ export class ChatRunner {
             kind,
             message,
             ...(sourceId ? { sourceId } : {}),
-            transient: true,
+            transient,
             ...this.eventBase(eventContext),
         });
     }
+    emitIntent(input, selectedRoute, eventContext) {
+        const subject = formatIntentInput(input);
+        let nextStep = "resume the saved agent loop state before continuing.";
+        let reason = "resume needs the prior runtime context before any further action.";
+        if (selectedRoute?.kind === "runtime_control") {
+            nextStep = `prepare the ${selectedRoute.intent.kind} runtime-control request.`;
+            reason = "runtime changes need an explicit operation plan and approval path.";
+        }
+        else if (selectedRoute?.kind === "daemon_tend") {
+            nextStep = "convert the request into a daemon-backed CoreLoop goal confirmation.";
+            reason = "long-running work should survive chat turn timeouts and run through durable runtime state.";
+        }
+        else if (selectedRoute?.kind === "direct_answer") {
+            nextStep = "ask the lightweight model for a concise direct answer.";
+            reason = "the router classified this as a simple question that does not need tools.";
+        }
+        else if (selectedRoute?.kind === "agent_loop") {
+            nextStep = "gather workspace context, then let the agent loop inspect or change files with visible tool activity.";
+            reason = "this request may require multiple tool-backed steps.";
+        }
+        else if (selectedRoute?.kind === "tool_loop") {
+            nextStep = "call the model with the tool catalog, then execute selected tools with visible activity.";
+            reason = "the available tools are needed to answer from current project state.";
+        }
+        else if (selectedRoute?.kind === "adapter") {
+            nextStep = "prepare project context before handing the turn to the configured adapter.";
+            reason = "the adapter needs the current workspace context to act correctly.";
+        }
+        const message = [
+            "Intent",
+            `- Confirm: ${subject || "the current request"}`,
+            `- Next: ${nextStep}`,
+            `- Why: ${reason}`,
+        ].join("\n");
+        this.emitActivity("commentary", message, eventContext, "intent:first-step", false);
+    }
+    emitCheckpoint(title, detail, eventContext, sourceKey) {
+        const message = detail
+            ? `Checkpoint\n- ${title}: ${detail}`
+            : `Checkpoint\n- ${title}`;
+        this.emitActivity("checkpoint", message, eventContext, `checkpoint:${sourceKey}`, false);
+    }
+    emitDiffArtifact(artifact, eventContext) {
+        const sections = [
+            "Changed files",
+            "",
+            "Modified files",
+            artifact.nameStatus || artifact.stat,
+            "",
+            "Diff summary",
+            artifact.stat,
+            "",
+            "Inline patch",
+            "```diff",
+            artifact.patch || "(patch unavailable)",
+            artifact.truncated ? `... truncated after ${DIFF_ARTIFACT_MAX_LINES} lines; run /review for the full diff.` : "",
+            "```",
+            "",
+            "Files inspected are shown separately in the activity log.",
+        ].filter((line) => line !== "").join("\n");
+        this.emitActivity("diff", sections, eventContext, "diff:working-tree", false);
+    }
     pushAssistantDelta(delta, assistantBuffer, eventContext) {
         if (!delta)
             return;
@@ -2169,15 +2776,19 @@ export class ChatRunner {
             persisted,
             ...this.eventBase(eventContext),
         });
+        this.finishActiveTurn(eventContext);
     }
     emitLifecycleErrorEvent(error, partialText, eventContext) {
+        const recovery = classifyFailureRecovery(error);
         this.emitEvent({
             type: "lifecycle_error",
             error,
             partialText,
             persisted: false,
+            recovery,
             ...this.eventBase(eventContext),
         });
+        return formatLifecycleFailureMessage(error, partialText, recovery);
     }
     /** Build a ToolCallContext from ChatRunnerDeps for tool dispatch. */
     async getSessionExecutionPolicy() {