pulseed 0.4.14 → 0.4.16

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

@@ -3,6 +3,11 @@
 // Central coordinator for 1-shot chat execution (Tier 1).
 // Bypasses TaskLifecycle — calls adapter.execute() directly.
 import { execFile } from "node:child_process";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+import { getPulseedDirPath } from "../../base/utils/paths.js";
+import { loadProviderConfig } from "../../base/llm/provider-config.js";
+import { TaskSchema } from "../../base/types/task.js";
 import { ChatHistory } from "./chat-history.js";
 import { ChatSessionCatalog, ChatSessionSelectorError, } from "./chat-session-store.js";
 import { buildChatContext, resolveGitRoot } from "../../platform/observation/context-provider.js";
@@ -13,6 +18,7 @@ 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 { recognizeRuntimeControlIntent } from "../../runtime/control/index.js";
+import { resolveExecutionPolicy, summarizeExecutionPolicy, withExecutionPolicyOverrides, } from "../../orchestrator/execution/agent-loop/execution-policy.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_VERIFY_RETRIES = 2;
 const MAX_TOOL_LOOPS = 5;
@@ -20,6 +26,7 @@ const ACTIVITY_PREVIEW_CHARS = 40;
 const DIRECT_ANSWER_MAX_TOKENS = 256;
 // ─── Command help text ───
 const COMMAND_HELP = `Available commands:
+Session
   /help                 Show this help message
   /clear                Clear conversation history
   /sessions             List prior chat sessions
@@ -27,9 +34,31 @@ const COMMAND_HELP = `Available commands:
   /title <title>        Rename the current 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
   /exit                 Exit chat mode
+
+Goals and tasks
+  /status [goal-id]     Show active goal status, or one goal when an id is provided
+  /goals                List goals
+  /tasks [goal-id]      List tasks for a goal; uses the only active goal when unambiguous
+  /task <task-id> [goal-id]
+                        Show one task; searches goals when no goal id is provided
   /track                Promote session to Tier 2 goal pursuit (not yet implemented)
-  /tend                 Generate a goal from chat history and start autonomous daemon execution`;
+  /tend                 Generate a goal from chat history and start autonomous daemon execution
+
+Configuration
+  /config               Show provider configuration with secrets masked
+  /model                Show the active provider/model/adapter
+  /permissions [args]   Show or update session execution policy
+  /plugins              List installed plugins when plugin metadata is available
+
+Review and branching
+  /review               Show current diff summary and verification context
+  /fork [title]         Fork the current chat session into a new session
+  /undo                 Remove the latest chat turn from session history
+
+Deferred
+  /retry and /usage are intentionally not supported yet.`;
 // ─── Helpers ───
 function checkGitChanges(cwd) {
     return new Promise((resolve) => {
@@ -92,6 +121,7 @@ export class ChatRunner {
     onEvent = undefined;
     nativeAgentLoopStatePath = null;
     runtimeControlContext = null;
+    sessionExecutionPolicy = null;
     constructor(deps) {
         this.deps = deps;
     }
@@ -108,6 +138,7 @@ export class ChatRunner {
         this.sessionActive = true;
         this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
         this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.sessionExecutionPolicy = null;
     }
     startSessionFromLoadedSession(session) {
         const chatSession = this.loadedSessionToChatSession(session);
@@ -116,6 +147,7 @@ export class ChatRunner {
         this.sessionActive = true;
         this.nativeAgentLoopStatePath = session.agentLoopStatePath ?? `chat/agentloop/${session.id}.state.json`;
         this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        this.sessionExecutionPolicy = null;
     }
     getSessionId() {
         return this.history?.getSessionId() ?? null;
@@ -165,6 +197,352 @@ export class ChatRunner {
         });
         return `Session ${session.id}${title} (${session.cwd})\n${lines.join("\n")}`;
     }
+    async loadGoals() {
+        const goalIds = await this.deps.stateManager.listGoalIds();
+        const goals = await Promise.all(goalIds.map((id) => this.deps.stateManager.loadGoal(id)));
+        return goals.filter((goal) => goal !== null);
+    }
+    async listAllGoalIds() {
+        const activeIds = await this.deps.stateManager.listGoalIds();
+        const archivedIds = await this.deps.stateManager.listArchivedGoals();
+        const recoverableArchivedIds = await this.listRecoverableArchivedGoalIds();
+        return [...new Set([...activeIds, ...archivedIds, ...recoverableArchivedIds])];
+    }
+    resolveStatePath(baseDir, ...segments) {
+        const base = path.resolve(baseDir);
+        const resolved = path.resolve(base, ...segments);
+        if (!resolved.startsWith(base + path.sep))
+            return null;
+        return resolved;
+    }
+    async listRecoverableArchivedGoalIds() {
+        const stateManager = this.deps.stateManager;
+        if (typeof stateManager.getBaseDir !== "function")
+            return [];
+        const archiveDir = this.resolveStatePath(stateManager.getBaseDir(), "archive");
+        if (archiveDir === null)
+            return [];
+        let entries = [];
+        try {
+            entries = await fsp.readdir(archiveDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const goalIds = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === ".staging")
+                continue;
+            try {
+                await fsp.access(path.join(archiveDir, entry.name, "goal", "goal.json"));
+                goalIds.push(entry.name);
+            }
+            catch {
+                continue;
+            }
+        }
+        return goalIds;
+    }
+    activeGoals(goals) {
+        return goals.filter((goal) => goal.status === "active" || goal.status === "waiting" || goal.loop_status === "running");
+    }
+    formatGoalLine(goal) {
+        const dimensions = goal.dimensions.length === 0
+            ? "no dimensions"
+            : goal.dimensions
+                .slice(0, 3)
+                .map((dimension) => `${dimension.name}: ${String(dimension.current_value)} target ${JSON.stringify(dimension.threshold)}`)
+                .join("; ");
+        return `${goal.id} - ${goal.title} [${goal.status}, loop ${goal.loop_status}] ${dimensions}`;
+    }
+    async handleStatus(args, start) {
+        if (args) {
+            const goal = await this.deps.stateManager.loadGoal(args);
+            if (!goal) {
+                return { success: false, output: `Goal not found: ${args}`, elapsed_ms: Date.now() - start };
+            }
+            const lines = [
+                `Goal status: ${goal.title}`,
+                `ID: ${goal.id}`,
+                `Status: ${goal.status}`,
+                `Loop: ${goal.loop_status}`,
+                `Updated: ${goal.updated_at}`,
+                `Children: ${goal.children_ids.length}`,
+                `Dimensions:`,
+                ...goal.dimensions.map((dimension) => `- ${dimension.name}: current=${String(dimension.current_value)}, threshold=${JSON.stringify(dimension.threshold)}, confidence=${dimension.confidence}`),
+            ];
+            return { success: true, output: lines.join("\n"), elapsed_ms: Date.now() - start };
+        }
+        const goals = await this.loadGoals();
+        const active = this.activeGoals(goals);
+        if (active.length === 0) {
+            return { success: true, output: "No active goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Active goals:\n${active.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleGoals(start) {
+        const goals = await this.loadGoals();
+        if (goals.length === 0) {
+            return { success: true, output: "No goals found.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Goals:\n${goals.map((goal) => this.formatGoalLine(goal)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async readTasksFromDir(tasksDir) {
+        let entries = [];
+        try {
+            entries = await fsp.readdir(tasksDir);
+        }
+        catch {
+            return [];
+        }
+        const tasks = [];
+        for (const entry of entries) {
+            if (!entry.endsWith(".json") || entry === "task-history.json" || entry === "last-failure-context.json")
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(await fsp.readFile(path.join(tasksDir, entry), "utf-8"));
+            }
+            catch {
+                continue;
+            }
+            const parsed = TaskSchema.safeParse(raw);
+            if (parsed.success)
+                tasks.push(parsed.data);
+        }
+        return tasks.sort((a, b) => (a.created_at < b.created_at ? 1 : -1));
+    }
+    async readTasksForGoal(goalId) {
+        const stateManager = this.deps.stateManager;
+        if (typeof stateManager.getBaseDir !== "function")
+            return [];
+        const baseDir = stateManager.getBaseDir();
+        const activeTasksDir = this.resolveStatePath(baseDir, "tasks", goalId);
+        const archiveTasksDir = this.resolveStatePath(baseDir, "archive", goalId, "tasks");
+        if (activeTasksDir === null || archiveTasksDir === null)
+            return [];
+        const activeTasks = await this.readTasksFromDir(activeTasksDir);
+        if (activeTasks.length > 0)
+            return activeTasks;
+        return this.readTasksFromDir(archiveTasksDir);
+    }
+    async resolveGoalForTasks(selector) {
+        if (selector)
+            return { goalId: selector };
+        const active = this.activeGoals(await this.loadGoals());
+        if (active.length === 1)
+            return { goalId: active[0].id };
+        if (active.length === 0)
+            return { error: "No active goals found. Use /tasks <goal-id>." };
+        return { error: "Multiple active goals found. Use /tasks <goal-id>." };
+    }
+    formatTaskLine(task) {
+        const verdict = task.verification_verdict ? `, verdict ${task.verification_verdict}` : "";
+        return `${task.id} - ${task.status}${verdict}: ${task.work_description}`;
+    }
+    async handleTasks(args, start) {
+        const resolved = await this.resolveGoalForTasks(args);
+        if (resolved.error || !resolved.goalId) {
+            return { success: false, output: resolved.error ?? "Usage: /tasks <goal-id>", elapsed_ms: Date.now() - start };
+        }
+        const tasks = await this.readTasksForGoal(resolved.goalId);
+        if (tasks.length === 0) {
+            return { success: true, output: `No tasks found for goal "${resolved.goalId}".`, elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Tasks for goal ${resolved.goalId}:\n${tasks.map((task) => this.formatTaskLine(task)).join("\n")}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    parseTaskArgs(args) {
+        const parts = args.split(/\s+/).filter(Boolean);
+        const goalFlagIndex = parts.indexOf("--goal");
+        if (goalFlagIndex >= 0) {
+            const goalId = parts[goalFlagIndex + 1];
+            parts.splice(goalFlagIndex, goalId ? 2 : 1);
+            return { taskId: parts[0], goalId };
+        }
+        return { taskId: parts[0], goalId: parts[1] };
+    }
+    async findTask(taskId, goalId) {
+        const goalIds = goalId ? [goalId] : await this.listAllGoalIds();
+        const matches = [];
+        for (const candidateGoalId of goalIds) {
+            let raw = null;
+            try {
+                raw = await this.deps.stateManager.readRaw(`tasks/${candidateGoalId}/${taskId}.json`);
+            }
+            catch {
+                raw = null;
+            }
+            if (!raw) {
+                const tasks = await this.readTasksForGoal(candidateGoalId);
+                const matched = tasks.find((task) => task.id === taskId || task.id.startsWith(taskId));
+                if (matched)
+                    matches.push({ goalId: candidateGoalId, task: matched });
+                continue;
+            }
+            const parsed = TaskSchema.safeParse(raw);
+            if (parsed.success)
+                matches.push({ goalId: candidateGoalId, task: parsed.data });
+        }
+        return { task: matches.length === 1 ? matches[0].task : undefined, matches };
+    }
+    formatTask(task) {
+        const lines = [
+            `Task: ${task.id}`,
+            `Goal: ${task.goal_id}`,
+            `Status: ${task.status}`,
+            `Category: ${task.task_category}`,
+            `Created: ${task.created_at}`,
+            `Work: ${task.work_description}`,
+            `Approach: ${task.approach}`,
+        ];
+        if (task.started_at)
+            lines.push(`Started: ${task.started_at}`);
+        if (task.completed_at)
+            lines.push(`Completed: ${task.completed_at}`);
+        if (task.verification_verdict)
+            lines.push(`Verification: ${task.verification_verdict}`);
+        if (task.verification_evidence?.length)
+            lines.push(`Evidence: ${task.verification_evidence.join("; ")}`);
+        if (task.success_criteria.length > 0) {
+            lines.push("Success criteria:");
+            lines.push(...task.success_criteria.map((criterion) => `- ${criterion.description}`));
+        }
+        return lines.join("\n");
+    }
+    async handleTask(args, start) {
+        const { taskId, goalId } = this.parseTaskArgs(args);
+        if (!taskId) {
+            return { success: false, output: "Usage: /task <task-id> [goal-id]", elapsed_ms: Date.now() - start };
+        }
+        const found = await this.findTask(taskId, goalId);
+        if (found.matches.length > 1) {
+            return {
+                success: false,
+                output: `Task selector "${taskId}" matched multiple goals. Use /task ${taskId} <goal-id>.\n${found.matches.map((match) => `- ${match.goalId}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        if (!found.task) {
+            const suffix = goalId ? ` for goal "${goalId}"` : "";
+            return { success: false, output: `Task not found: ${taskId}${suffix}`, elapsed_ms: Date.now() - start };
+        }
+        return { success: true, output: this.formatTask(found.task), elapsed_ms: Date.now() - start };
+    }
+    providerConfigBaseDir() {
+        const stateManager = this.deps.stateManager;
+        return typeof stateManager.getBaseDir === "function" ? stateManager.getBaseDir() : getPulseedDirPath();
+    }
+    async readProviderConfigSummary() {
+        const config = await loadProviderConfig({
+            baseDir: this.providerConfigBaseDir(),
+            saveMigration: false,
+        });
+        return {
+            provider: config.provider,
+            model: config.model,
+            adapter: config.adapter,
+            light_model: config.light_model,
+            base_url: config.base_url,
+            codex_cli_path: config.codex_cli_path,
+            has_api_key: Boolean(config.api_key),
+        };
+    }
+    formatConfig(config) {
+        return Object.entries(config)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => `${key}: ${typeof value === "string" && /key|token|secret/i.test(key) ? "[masked]" : String(value)}`)
+            .join("\n");
+    }
+    async handleConfig(start) {
+        const config = await this.readProviderConfigSummary();
+        return { success: true, output: `Provider configuration:\n${this.formatConfig(config)}`, elapsed_ms: Date.now() - start };
+    }
+    async handleModel(start) {
+        const config = await this.readProviderConfigSummary();
+        return {
+            success: true,
+            output: `Model: ${config.model}\nProvider: ${config.provider}\nAdapter: ${config.adapter}`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handlePlugins(start) {
+        if (!this.deps.pluginLoader) {
+            return { success: true, output: "Plugin information is not available in this chat session.", elapsed_ms: Date.now() - start };
+        }
+        try {
+            const plugins = await this.deps.pluginLoader.loadAll();
+            if (plugins.length === 0) {
+                return { success: true, output: "No plugins found.", elapsed_ms: Date.now() - start };
+            }
+            return {
+                success: true,
+                output: `Plugins:\n${plugins.map((plugin) => `${plugin.name} - ${plugin.type ?? "unknown"} - ${plugin.enabled === false ? "disabled" : "enabled"}`).join("\n")}`,
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { success: true, output: `Plugin information is unavailable: ${message}`, elapsed_ms: Date.now() - start };
+        }
+    }
+    deterministicChatSummary(messages) {
+        const lines = messages.map((message) => `${message.role}: ${message.content.replace(/\s+/g, " ").trim()}`);
+        return lines.join("\n").slice(0, 4_000);
+    }
+    async summarizeChatForCompaction(messages, existingSummary) {
+        const content = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            `Messages to summarize:\n${messages.map((message) => `${message.role}: ${message.content}`).join("\n")}`,
+        ].filter(Boolean).join("\n\n");
+        if (this.deps.llmClient) {
+            try {
+                const response = await this.deps.llmClient.sendMessage([
+                    { role: "user", content: `Summarize this chat history for later continuation. Preserve decisions, open tasks, constraints, and user preferences. Keep it concise.\n\n${content}` },
+                ], { max_tokens: 700, model_tier: "light" });
+                if (response.content.trim())
+                    return { summary: response.content.trim(), usedLlm: true };
+            }
+            catch {
+                // Fall back to deterministic summary below.
+            }
+        }
+        const fallback = [
+            existingSummary ? `Previous summary:\n${existingSummary}` : "",
+            "Extractive summary:",
+            this.deterministicChatSummary(messages),
+        ].filter(Boolean).join("\n\n");
+        return { summary: fallback, usedLlm: false };
+    }
+    async handleCompact(start) {
+        if (!this.history) {
+            return { success: false, output: "No active chat session to compact.", elapsed_ms: Date.now() - start };
+        }
+        const session = this.history.getSessionData();
+        if (session.messages.length <= 4) {
+            return { success: true, output: "Chat history is already compact. No messages were removed.", elapsed_ms: Date.now() - start };
+        }
+        const olderMessages = session.messages.slice(0, -4);
+        const { summary, usedLlm } = await this.summarizeChatForCompaction(olderMessages, session.compactionSummary);
+        const { before, after } = await this.history.compact(summary, 4);
+        const method = usedLlm ? "LLM summary" : "deterministic summary";
+        return {
+            success: true,
+            output: `Compacted chat history with ${method}. Persisted ${before} message(s) down to ${after}; the latest user/assistant turns were kept.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
     async handleCommand(input) {
         const trimmed = input.trim();
         if (!trimmed.startsWith("/"))
@@ -175,7 +553,7 @@ export class ChatRunner {
             return { success: true, output: COMMAND_HELP, elapsed_ms: Date.now() - start };
         }
         if (cmd === "/clear") {
-            this.history?.clear();
+            await this.history?.clear();
             return { success: true, output: "Conversation history cleared.", elapsed_ms: Date.now() - start };
         }
         if (cmd === "/sessions") {
@@ -224,6 +602,42 @@ export class ChatRunner {
                 elapsed_ms: Date.now() - start,
             };
         }
+        if (cmd === "/compact") {
+            return this.handleCompact(start);
+        }
+        if (cmd === "/status") {
+            return this.handleStatus(trimmed.slice("/status".length).trim(), start);
+        }
+        if (cmd === "/goals") {
+            return this.handleGoals(start);
+        }
+        if (cmd === "/tasks") {
+            return this.handleTasks(trimmed.slice("/tasks".length).trim(), start);
+        }
+        if (cmd === "/task") {
+            return this.handleTask(trimmed.slice("/task".length).trim(), start);
+        }
+        if (cmd === "/config") {
+            return this.handleConfig(start);
+        }
+        if (cmd === "/model") {
+            return this.handleModel(start);
+        }
+        if (cmd === "/permissions") {
+            return this.handlePermissions(trimmed.slice("/permissions".length).trim(), start);
+        }
+        if (cmd === "/plugins") {
+            return this.handlePlugins(start);
+        }
+        if (cmd === "/review") {
+            return this.handleReview(start);
+        }
+        if (cmd === "/fork") {
+            return this.handleFork(trimmed.slice("/fork".length).trim(), start);
+        }
+        if (cmd === "/undo") {
+            return this.handleUndo(start);
+        }
         if (cmd === "/exit") {
             return { success: true, output: "Exiting chat mode.", elapsed_ms: Date.now() - start };
         }
@@ -276,6 +690,114 @@ export class ChatRunner {
             };
         }
     }
+    async handlePermissions(args, start) {
+        const policy = await this.getSessionExecutionPolicy();
+        if (!args) {
+            return {
+                success: true,
+                output: summarizeExecutionPolicy(policy),
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        const tokens = args.toLowerCase().split(/\s+/).filter(Boolean);
+        let nextPolicy = policy;
+        for (let index = 0; index < tokens.length; index++) {
+            const token = tokens[index];
+            if (token === "read-only" || token === "readonly" || token === "read_only") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "read_only" });
+                continue;
+            }
+            if (token === "workspace-write" || token === "workspace_write") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "workspace_write" });
+                continue;
+            }
+            if (token === "full-access" || token === "danger-full-access" || token === "danger_full_access") {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { sandboxMode: "danger_full_access" });
+                continue;
+            }
+            if (token === "network" && tokens[index + 1]) {
+                nextPolicy = withExecutionPolicyOverrides(nextPolicy, { networkAccess: tokens[index + 1] === "on" });
+                index += 1;
+                continue;
+            }
+            if (token === "approval" && tokens[index + 1]) {
+                const approvalPolicy = tokens[index + 1];
+                if (approvalPolicy === "never" || approvalPolicy === "on_request" || approvalPolicy === "untrusted") {
+                    nextPolicy = withExecutionPolicyOverrides(nextPolicy, { approvalPolicy });
+                    index += 1;
+                    continue;
+                }
+            }
+            return {
+                success: false,
+                output: "Usage: /permissions [read-only|workspace-write|full-access] [network on|off] [approval on_request|never|untrusted]",
+                elapsed_ms: Date.now() - start,
+            };
+        }
+        this.sessionExecutionPolicy = nextPolicy;
+        return {
+            success: true,
+            output: summarizeExecutionPolicy(nextPolicy),
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleReview(start) {
+        const cwd = this.sessionCwd ?? process.cwd();
+        const diffStat = await checkGitChanges(cwd);
+        const policy = await this.getSessionExecutionPolicy();
+        const output = [
+            "Review summary",
+            diffStat ? diffStat : "No uncommitted changes detected.",
+            "",
+            "Execution policy",
+            summarizeExecutionPolicy(policy),
+        ].join("\n");
+        return { success: true, output, elapsed_ms: Date.now() - start };
+    }
+    async handleFork(title, start) {
+        const cwd = this.sessionCwd ?? process.cwd();
+        const sessionId = crypto.randomUUID();
+        const baseSession = this.history?.getSessionData() ?? {
+            id: sessionId,
+            cwd,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            messages: [],
+        };
+        const now = new Date().toISOString();
+        const forkedSession = {
+            ...baseSession,
+            id: sessionId,
+            createdAt: now,
+            updatedAt: now,
+            title: title || (baseSession.title ? `${baseSession.title} (fork)` : "Forked session"),
+        };
+        this.history = ChatHistory.fromSession(this.deps.stateManager, forkedSession);
+        this.sessionCwd = cwd;
+        this.sessionActive = true;
+        this.nativeAgentLoopStatePath = `chat/agentloop/${sessionId}.state.json`;
+        this.history.setAgentLoopStatePath(this.nativeAgentLoopStatePath);
+        await this.history.persist();
+        return {
+            success: true,
+            output: `Forked chat session as ${sessionId}.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
+    async handleUndo(start) {
+        if (!this.history) {
+            return { success: false, output: "No active chat session to undo.", elapsed_ms: Date.now() - start };
+        }
+        const removed = await this.history.removeLastTurn();
+        if (removed === 0) {
+            return { success: false, output: "No chat turn to undo.", elapsed_ms: Date.now() - start };
+        }
+        return {
+            success: true,
+            output: `Removed ${removed} message(s) from chat history. File changes were not reverted.`,
+            elapsed_ms: Date.now() - start,
+        };
+    }
     async handleTend(args, start) {
         if (!this.deps.llmClient) {
             return {
@@ -496,13 +1018,21 @@ export class ChatRunner {
                 this.cachedStaticSystemPrompt = "";
             }
         }
-        // Build conversation history from prior turns (last 10)
+        // Build conversation history from prior turns (last 10), including any manual compaction summary.
         const messages = history.getMessages();
+        const compactionSummary = history.getSessionData().compactionSummary;
         const priorTurns = resumeOnly ? messages.slice(-10) : messages.slice(0, -1).slice(-10);
         let historyBlock = "";
+        const historySections = [];
+        if (compactionSummary) {
+            historySections.push(`Compacted previous conversation summary:\n${compactionSummary}`);
+        }
         if (priorTurns.length > 0) {
             const lines = priorTurns.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`).join("\n");
-            historyBlock = `Previous conversation:\n${lines}\n\nCurrent message:\n`;
+            historySections.push(`Previous conversation:\n${lines}`);
+        }
+        if (historySections.length > 0) {
+            historyBlock = `${historySections.join("\n\n")}\n\nCurrent message:\n`;
         }
         const directAnswerRoute = !resumeOnly && !this.deps.chatAgentLoopRunner && this.deps.llmClient !== undefined && shouldUseDirectAnswerRoute(input);
         const directPrompt = historyBlock ? `${historyBlock}${input}` : input;
@@ -570,6 +1100,13 @@ export class ChatRunner {
             .filter((section) => section && section.trim().length > 0)
             .join("\n\n")
             .trim();
+        const agentLoopSystemPrompt = [
+            systemPrompt,
+            compactionSummary ? `## Compacted Chat Summary\n${compactionSummary}` : "",
+        ]
+            .filter((section) => section && section.trim().length > 0)
+            .join("\n\n")
+            .trim();
         const context = resumeOnly ? "" : await buildChatContext(input, gitRoot);
         const basePrompt = resumeOnly ? "" : (context ? `${context}\n\n${input}` : input);
         const prompt = historyBlock ? `${historyBlock}${basePrompt}` : basePrompt;
@@ -624,10 +1161,13 @@ export class ChatRunner {
                         }
                         return false;
                     },
+                    toolCallContext: {
+                        executionPolicy: await this.getSessionExecutionPolicy(),
+                    },
                     ...(this.nativeAgentLoopStatePath ? { resumeStatePath: this.nativeAgentLoopStatePath } : {}),
                     ...(resumeState ? { resumeState } : {}),
                     ...(resumeOnly ? { resumeOnly: true } : {}),
-                    ...(systemPrompt ? { systemPrompt } : {}),
+                    ...(agentLoopSystemPrompt ? { systemPrompt: agentLoopSystemPrompt } : {}),
                 });
                 const elapsed_ms = Date.now() - start;
                 if (result.output) {
@@ -806,7 +1346,7 @@ export class ChatRunner {
     async executeWithTools(prompt, eventContext, assistantBuffer, systemPrompt) {
         const llmClient = this.deps.llmClient;
         const messages = [{ role: "user", content: prompt }];
-        const toolCallContext = this.buildToolCallContext();
+        const toolCallContext = await this.buildToolCallContext();
         for (let loop = 0; loop < MAX_TOOL_LOOPS; loop++) {
             // Recompute tools each iteration so newly activated deferred tools are included
             const tools = this.deps.registry
@@ -1260,7 +1800,18 @@ export class ChatRunner {
         });
     }
     /** Build a ToolCallContext from ChatRunnerDeps for tool dispatch. */
-    buildToolCallContext() {
+    async getSessionExecutionPolicy() {
+        if (this.sessionExecutionPolicy)
+            return this.sessionExecutionPolicy;
+        const config = await loadProviderConfig({ saveMigration: false });
+        this.sessionExecutionPolicy = resolveExecutionPolicy({
+            workspaceRoot: this.sessionCwd ?? process.cwd(),
+            security: config.agent_loop?.security,
+        });
+        return this.sessionExecutionPolicy;
+    }
+    async buildToolCallContext() {
+        const executionPolicy = await this.getSessionExecutionPolicy();
         return {
             cwd: this.sessionCwd ?? process.cwd(),
             goalId: this.deps.goalId ?? "",
@@ -1272,6 +1823,7 @@ export class ChatRunner {
                 }
                 return false;
             },
+            executionPolicy,
         };
     }
 }