create-walle 0.9.25 → 0.9.26

package/template/wall-e/coding-orchestrator.js

@@ -60,6 +60,77 @@ function getLlmClient() { if (!_llmClient) _llmClient = require('./llm/client');
 function getLocalTools() { if (!_localTools) _localTools = require('./tools/local-tools'); return _localTools; }
 function getActivityLog() { if (!_activityLog) _activityLog = require('./lib/activity-log'); return _activityLog; }
 
+function createActionMemoryPolicyForRun(opts = {}, { logger = console } = {}) {
+  if (opts.actionMemoryPolicy !== undefined) return opts.actionMemoryPolicy;
+  const mode = String(
+    opts.actionMemoryMode
+      || (opts.actionMemoryStore ? 'audit' : process.env.WALL_E_ACTION_MEMORY_MODE)
+      || 'off'
+  ).trim().toLowerCase();
+  if (!mode || mode === 'off' || mode === '0' || mode === 'false') return null;
+  const { ActionMemoryPolicy } = require('./coding/action-memory-policy');
+  const { ActionMemoryStore } = require('./coding/action-memory-store');
+  const store = opts.actionMemoryStore || new ActionMemoryStore({
+    dbPath: opts.actionMemoryDbPath,
+    artifactsDir: opts.actionMemoryArtifactsDir,
+    logger,
+  });
+  return new ActionMemoryPolicy({
+    store,
+    mode,
+    selector: opts.actionMemorySelector || process.env.WALL_E_ACTION_MEMORY_SELECTOR,
+    minScore: opts.actionMemoryMinScore || process.env.WALL_E_ACTION_MEMORY_MIN_SCORE,
+    minMargin: opts.actionMemoryMinMargin || process.env.WALL_E_ACTION_MEMORY_MIN_MARGIN,
+    limit: opts.actionMemoryLimit || process.env.WALL_E_ACTION_MEMORY_LIMIT,
+    maxCandidates: opts.actionMemoryMaxCandidates || process.env.WALL_E_ACTION_MEMORY_MAX_CANDIDATES,
+    memoryLimit: opts.actionMemoryMemoryLimit || process.env.WALL_E_ACTION_MEMORY_MEMORY_LIMIT,
+    logger,
+  });
+}
+
+function stringifyIntent(intent) {
+  if (!intent) return '';
+  if (typeof intent === 'string') return intent;
+  return String(intent.id || intent.intent || intent.name || intent.type || '');
+}
+
+function callableDecisionTool(decision = {}) {
+  return decision.selectedEntryId || 'no candidate';
+}
+
+function recentShellCommandsForActionMemory(toolCallHistory = [], { limit = 6 } = {}) {
+  return (toolCallHistory || [])
+    .filter((item) => callName(item) === 'run_shell')
+    .slice(-Math.max(1, Number(limit) || 6))
+    .map((item) => {
+      const command = shellCommandFromEvidence(item);
+      if (!command) return '';
+      const status = item.ok === false ? 'tool_error' : 'tool_result';
+      return `${status}: ${command}`;
+    })
+    .filter(Boolean)
+    .join(', ');
+}
+
+function knownFailuresForActionMemory(toolCallHistory = []) {
+  const failures = [];
+  if ((toolCallHistory || []).some((item) => callName(item) === 'run_shell' && item.ok === false)) {
+    failures.push('run_shell tool error');
+  }
+  return failures.join(', ');
+}
+
+function shellCommandFromEvidence(item = {}) {
+  const input = item.input || item.args || {};
+  if (input.command || input.cmd) return String(input.command || input.cmd).trim();
+  try {
+    const parsed = JSON.parse(String(item.inputHash || ''));
+    return String(parsed.command || parsed.cmd || '').trim();
+  } catch {
+    return '';
+  }
+}
+
 // Prompt builders — operating-manual content lives in coding-prompts.js
 // for testability and to apply the Claude Code prompt patterns
 // (edit-vs-create, no-comments, no premature abstractions, verification-
@@ -88,10 +159,18 @@ const {
 } = require('./coding/capability-router');
 const { createCodingTranscript } = require('./coding/transcript-writer');
 const { createCodingCapabilities } = require('./coding/capability-broker');
+const { gitRootFor } = require('./chat/code-review-context');
+const { recordSessionWorkspace, recordSessionAnchor } = require('./coding/session-workspaces');
 const {
   CompactionService,
   DEFAULT_CONTEXT_WINDOW,
 } = require('./coding/compaction-service');
+const {
+  createNoProgressGuard,
+  buildBlockedToolExecution,
+  buildNoProgressNudge,
+  compactRepeatedInspectionToolResults,
+} = require('./coding/no-progress-guard');
 const {
   emitAgentRunContextWarnings,
 } = require('./runtime/agent-run-context');
@@ -99,6 +178,7 @@ const {
   resolveWallERuntimeProfile,
 } = require('./runtime/walle-runtime');
 const { estimateTokens, estimateMessagesTokens } = require('./context/token-counter');
+const usageUtil = require('./lib/usage');
 const { recoverAllowedTextToolCalls } = require('./llm/text-tool-calls');
 
 const MAX_CUMULATIVE_CONTEXT = 4000;
@@ -359,7 +439,7 @@ const CODING_TOOLS = [
   },
   {
     name: 'edit_file',
-    description: 'Make a targeted edit to a file by replacing a string match. Uses a 9-strategy fuzzy matching chain — tolerates minor whitespace, indentation, and Unicode differences. More efficient than write_file for modifying existing files.',
+    description: 'Make a targeted edit by replacing old_string with new_string; for additive changes, include the original old_string inside new_string plus the inserted sibling code so unrelated code is preserved. Uses a 9-strategy fuzzy matching chain — tolerates minor whitespace, indentation, and Unicode differences. More efficient than write_file for modifying existing files.',
     input_schema: {
       type: 'object',
       properties: {
@@ -1134,6 +1214,27 @@ function resolveRunTimeoutMs(opts = {}) {
   return isInteractive ? 0 : 300000;
 }
 
+// Compact-and-continue gate (pure, so it's unit-testable). Returns true when an
+// interactive coding run that is STILL making progress has reached its turn-budget
+// edge and should be extended (instead of force-stripping tools into a "summarize
+// what's left" dead-end). Extends only when: enabled + interactive, at the cap edge,
+// extension + absolute-ceiling budget remains, recent tool activity actually succeeded,
+// and it isn't spinning on one identical call (the doom-loop detector owns that case).
+function shouldExtendInteractiveBudget({
+  enabled, interactive, turnIndex, turns, turnExtensions,
+  maxExtensions, absoluteMax, recent = [], doomThreshold = 3,
+} = {}) {
+  if (!enabled || !interactive) return false;
+  if (turnIndex < turns - 1) return false;
+  if (turnExtensions >= maxExtensions) return false;
+  if (turns >= absoluteMax) return false;
+  if (!recent.some(c => c && c.ok === true)) return false;
+  const looping = recent.length >= doomThreshold
+    && recent.every(c => c.name === recent[0].name && c.inputHash === recent[0].inputHash);
+  if (looping) return false;
+  return true;
+}
+
 function providerSupportsToolCalls(provider) {
   if (!provider) return true;
   if (provider.capabilities?.tools === false) return false;
@@ -1179,10 +1280,87 @@ function createInitialLlmParams(opts = {}, maxTokens = 4096) {
   if (Object.prototype.hasOwnProperty.call(opts, 'temperature')) params.temperature = opts.temperature;
   if (Object.prototype.hasOwnProperty.call(opts, 'thinking')) params.thinking = opts.thinking;
   if (Object.prototype.hasOwnProperty.call(opts, 'reasoningEffort')) params.reasoningEffort = opts.reasoningEffort;
+  if (Object.prototype.hasOwnProperty.call(opts, 'keepAlive')) params.keepAlive = opts.keepAlive;
   if (opts.options && typeof opts.options === 'object') params.options = { ...opts.options };
   return params;
 }
 
+function providerTypeOf(provider) {
+  if (!provider) return '';
+  if (typeof provider === 'string') return provider;
+  return provider.type || provider.provider || provider.id || '';
+}
+
+function isFastGemma4ModelId(model) {
+  return /^gemma4:e4b(?:$|[-:])/i.test(String(model || ''));
+}
+
+function ollamaKeepAliveForRun(opts = {}) {
+  if (Object.prototype.hasOwnProperty.call(opts, 'keepAlive')) return opts.keepAlive;
+  return process.env.WALLE_OLLAMA_CODING_KEEP_ALIVE || process.env.OLLAMA_KEEP_ALIVE || '30m';
+}
+
+async function maybePrewarmLocalOllama({ provider, model, opts = {}, emitProgress }) {
+  if (providerTypeOf(provider) !== 'ollama') return null;
+  if (!isFastGemma4ModelId(model)) return null;
+  if (opts.prewarm === false || opts.ollamaPrewarm === false) return null;
+  if (typeof provider?.prewarm !== 'function') return null;
+
+  const started = Date.now();
+  const keepAlive = ollamaKeepAliveForRun(opts);
+  emitProgress?.({
+    phase: opts.mode || 'executing',
+    step: -1,
+    message: `Prewarming Ollama model ${model}...`,
+    detail: { provider: 'ollama', model, keepAlive },
+  });
+  try {
+    const result = await provider.prewarm({
+      model,
+      keepAlive,
+      timeoutMs: opts.prewarmTimeoutMs || opts.ollamaPrewarmTimeoutMs || 120000,
+    });
+    emitProgress?.({
+      phase: opts.mode || 'executing',
+      step: -1,
+      message: `Prewarmed Ollama model ${model} in ${((Date.now() - started) / 1000).toFixed(1)}s`,
+      detail: { provider: 'ollama', model, keepAlive, result },
+    });
+    return result;
+  } catch (err) {
+    emitProgress?.({
+      phase: opts.mode || 'executing',
+      step: -1,
+      message: `Ollama prewarm failed: ${String(err?.message || err).slice(0, 120)}`,
+      detail: { provider: 'ollama', model, keepAlive },
+    });
+    return null;
+  }
+}
+
+function emitOllamaTurnTiming({ emitProgress, provider, model, phase, step, startedAt, usage, params, toolsCount }) {
+  if (providerTypeOf(provider) !== 'ollama') return;
+  const latencyMs = Date.now() - startedAt;
+  emitProgress?.({
+    phase,
+    step,
+    message: `Ollama turn completed in ${(latencyMs / 1000).toFixed(1)}s`,
+    detail: {
+      provider: 'ollama',
+      model,
+      latencyMs,
+      inputTokens: usage?.input || 0,
+      outputTokens: usage?.output || 0,
+      genTokPerSec: usage?.genTokPerSec ?? null,
+      prefillTokPerSec: usage?.prefillTokPerSec ?? null,
+      numCtx: params?.options?.num_ctx ?? null,
+      maxTokens: params?.maxTokens ?? null,
+      keepAlive: params?.keepAlive ?? null,
+      toolsCount: toolsCount ?? null,
+    },
+  });
+}
+
 function createCodingCompactionService(provider, modelId, opts = {}) {
   if (opts.autoCompact === false || opts.compaction === false || opts.disableCompaction === true) return null;
   if (String(process.env.WALLE_CODING_AUTO_COMPACT || '').trim() === '0') return null;
@@ -2101,6 +2279,18 @@ async function runAgentLoop(prompt, opts = {}) {
   }
 
   // Build system prompt with project context.
+  // Ground the agent in its directory every turn, and surface every root this
+  // session has worked in (so a session reused across repos doesn't lose track of
+  // where it built things — session c3f3af97).
+  let gitRoot = '';
+  try { gitRoot = gitRootFor(resolvedCwd) || ''; } catch { gitRoot = ''; }
+  const groundingSessionKey = opts.chatSessionId || opts.session_id || sid;
+  const sessionWorkspaces = recordSessionWorkspace(opts.brain, groundingSessionKey, resolvedCwd);
+  // Anchor the session to its first project root (git root, else cwd) so it has a
+  // stable "home" even when a later turn is pointed at a different directory — the
+  // agent resolves "the project / the site / what you built" to the anchor instead
+  // of whatever cwd this turn happens to carry (session c3f3af97).
+  const sessionAnchor = recordSessionAnchor(opts.brain, groundingSessionKey, gitRoot || resolvedCwd);
   const systemPrompt = buildAgentSystemPrompt({
     resolvedCwd,
     projectInfo: projectInfo && projectInfo.type !== 'unknown' ? projectInfo : null,
@@ -2115,11 +2305,17 @@ async function runAgentLoop(prompt, opts = {}) {
       promptCapabilities,
       artifactCapabilities,
       userTask: prompt,
+      environment: { gitRoot, isGitRepo: !!gitRoot, platform: process.platform },
+      sessionWorkspaces,
+      sessionAnchor,
     },
   });
 
-  // Resume support: use restored messages if resuming from checkpoint
-  const messages = opts._resumeMessages || [{ role: 'user', content: prompt }];
+  // Resume support: use restored messages if resuming from checkpoint.
+  // For a normal turn the seed is built from the prior conversation + tool trail
+  // (opts.contextMessages) once the compaction service exists (see below); this
+  // placeholder is only used if there is no context to seed from.
+  let messages = opts._resumeMessages || [{ role: 'user', content: prompt }];
   let finalOutput = '';
   let finalAnswerDelivered = false;
   let totalInput = 0;
@@ -2130,6 +2326,147 @@ async function runAgentLoop(prompt, opts = {}) {
   // Doom loop detection (6a)
   const toolCallHistory = []; // { name, inputHash }
   const DOOM_LOOP_THRESHOLD = 3;
+  const noProgressGuard = createNoProgressGuard({
+    cwd: resolvedCwd,
+    enabled: opts.noProgressGuard !== false && process.env.WALLE_NO_PROGRESS_GUARD !== '0',
+    threshold: opts.noProgressGuardThreshold || Number(process.env.WALLE_NO_PROGRESS_THRESHOLD) || DOOM_LOOP_THRESHOLD,
+  });
+  const actionMemoryPolicy = createActionMemoryPolicyForRun(opts, { logger: console });
+  function actionMemoryContextForCall(call = {}) {
+    const recentSequence = toolCallHistory.slice(-6).map((item) => callName(item)).filter(Boolean);
+    const last = recentSequence[recentSequence.length - 1] || '';
+    const shellHistory = recentShellCommandsForActionMemory(toolCallHistory);
+    const failures = knownFailuresForActionMemory(toolCallHistory);
+    return {
+      sessionId: sid,
+      cwd: resolvedCwd,
+      repo: opts.actionMemoryRepo || opts.repo || gitRoot || resolvedCwd,
+      familyId: opts.actionMemoryFamilyId || opts.workflowFamilyId || runtimeMode.id,
+      intent: opts.actionMemoryIntent || stringifyIntent(codingIntent) || opts.mode || runtimeMode.id,
+      intendedTool: callName(call),
+      taskText: String(prompt || ''),
+      sequence: recentSequence.join(' > '),
+      lastTool: last,
+      recentShellCommands: shellHistory,
+      knownFailures: failures,
+      verificationStatus: hasFailedVerificationAttempt(toolCallHistory)
+        ? 'failed'
+        : (hasVerificationEvidence(toolCallHistory) ? 'passed' : ''),
+      toolCatalogId: opts.actionMemoryToolCatalogId || `${llm.type || 'provider'}:${runtimeMode.id}`,
+      metadata: {
+        mode: opts.mode || '',
+        runtimeMode: runtimeMode.id,
+        projectType: projectInfo?.type || '',
+      },
+    };
+  }
+  function actionMemoryModelContext() {
+    return {
+      provider: llm.type || '',
+      modelId,
+      toolFormat: opts.actionMemoryToolFormat || '',
+    };
+  }
+  async function executeWithActionMemoryPolicy({ call, context, execute, allowRewrite = true }) {
+    if (!actionMemoryPolicy) return execute(call, { mode: 'off', action: 'skip', accepted: false });
+    if (!allowRewrite && actionMemoryPolicy.mode !== 'audit') {
+      return execute(call, {
+        mode: actionMemoryPolicy.mode,
+        action: 'skip',
+        accepted: false,
+        reason: 'stream_permission_prechecked',
+      });
+    }
+    const { executeToolCallWithActionMemoryPolicy } = require('./coding/action-memory-policy');
+    return executeToolCallWithActionMemoryPolicy({
+      call,
+      context,
+      model: actionMemoryModelContext(),
+      sessionId: sid,
+      prompt,
+      policy: actionMemoryPolicy,
+      execute,
+    });
+  }
+  function emitActionMemoryDecision(execution, step) {
+    const decision = execution?.actionMemory?.decision;
+    if (!decision || decision.action === 'skip') return;
+    const detail = {
+      ...decision,
+      selectedEntryId: decision.selectedEntryId || '',
+      candidateCount: execution.actionMemory.candidateCount || 0,
+    };
+    emitProgress({
+      type: 'action_memory',
+      phase: opts.mode || 'executing',
+      step,
+      message: `Action memory ${decision.action}: ${callableDecisionTool(decision)}`,
+      detail,
+    });
+    events.emit('action_memory.decision', { sessionId: sid, ...detail });
+  }
+  function compactNoProgressState(step, reason) {
+    if (opts.noProgressGuard === false || process.env.WALLE_NO_PROGRESS_GUARD === '0') return;
+    const compacted = compactRepeatedInspectionToolResults(messages, { cwd: resolvedCwd });
+    if (compacted.compacted > 0) {
+      emitProgress({
+        phase: opts.mode || 'executing',
+        step,
+        message: `Compacted ${compacted.compacted} repeated inspection result(s)`,
+        detail: { reason, groups: compacted.groups },
+      });
+    }
+  }
+
+  // Compact-and-continue (interactive coding): a fixed turn cap that force-strips
+  // tools and makes the model "summarize what's left" turns "out of steps" into a
+  // dead-end ("I investigated; confirm and I'll apply it"). Interactive runs already
+  // have NO wall-clock deadline (run until the agent finishes or the user stops, like
+  // Claude Code / opencode) — the turn counter is the last hard ceiling contradicting
+  // that. When an interactive run is STILL making progress at the cap edge, extend the
+  // budget (bounded) + nudge it to land the edit, instead of forcing the wrap-up.
+  // Headless/benchmark runs keep the hard cap (CI/background must not hang).
+  const codingTurnContinueEnabled = process.env.WALLE_CODING_TURN_CONTINUE !== '0';
+  const ABSOLUTE_MAX_TURNS = Math.max(turns, 200);
+  const TURN_EXTENSION_BATCH = 10;
+  const MAX_TURN_EXTENSIONS = 12;
+  let turnExtensions = 0;
+  // Called at the top of a turn, BEFORE tools get stripped on the final budgeted
+  // round. When an interactive run is still making progress at the cap edge, bump
+  // `turns`, append a directive nudging the model to land the edit (appended to the
+  // last message's content, not a new user message — consecutive user messages are
+  // rejected by the API), and return true. Returns false to let the normal wrap-up run.
+  function tryExtendInteractiveTurnBudget(turnIndex) {
+    if (!shouldExtendInteractiveBudget({
+      enabled: codingTurnContinueEnabled,
+      interactive: interactiveRun,
+      turnIndex,
+      turns,
+      turnExtensions,
+      maxExtensions: MAX_TURN_EXTENSIONS,
+      absoluteMax: ABSOLUTE_MAX_TURNS,
+      recent: toolCallHistory.slice(-DOOM_LOOP_THRESHOLD),
+      doomThreshold: DOOM_LOOP_THRESHOLD,
+    })) return false;
+    turns = Math.min(ABSOLUTE_MAX_TURNS, turns + TURN_EXTENSION_BATCH);
+    turnExtensions += 1;
+    emitProgress({
+      phase: opts.mode || 'executing',
+      step: turnIndex,
+      message: `Coding budget extended (${turnExtensions}/${MAX_TURN_EXTENSIONS}) — still making progress`,
+      detail: { turns },
+    });
+    const directive = '[System: You still have budget. You have gathered enough context — STOP investigating and APPLY the change now with edit_file/multi_edit/apply_patch, then verify. Do not ask the user to confirm before applying; apply, then report what changed.]';
+    const lastMsg = messages[messages.length - 1];
+    if (lastMsg && Array.isArray(lastMsg.content)) {
+      lastMsg.content.push({ type: 'text', text: directive });
+    } else if (lastMsg && lastMsg.role === 'user' && typeof lastMsg.content === 'string') {
+      lastMsg.content += '\n\n' + directive;
+    } else {
+      messages.push({ role: 'user', content: directive });
+    }
+    return true;
+  }
 
   // Screenshots captured by browser_screenshot calls. Drives the
   // visual review pass in coding-review.js.
@@ -2138,6 +2475,59 @@ async function runAgentLoop(prompt, opts = {}) {
   // Per-step cost/token tracking (6q)
   const turnCosts = [];
   let budgetUsed = 0;
+  let totalCostUsd = 0;        // cumulative $ (accurate, cache-discounted)
+  let lastTurnRawUsage = null; // most recent turn's usage → context occupancy
+
+  // Emit a live token/cost snapshot to any watching client (per-session + top-bar
+  // counters). Same shape coding + chat use; see lib/usage.js. `type:'usage'` flows
+  // through emitProgress → CTM emitWalleProgress → browser handleProgress(ev.type).
+  let _usageRequestSeq = 0;
+  function emitUsageSnapshot(rawUsage) {
+    if (rawUsage) lastTurnRawUsage = rawUsage;
+    try {
+      const snap = usageUtil.usageSnapshot({
+        rawUsage: lastTurnRawUsage,
+        cumulativeInput: totalInput,
+        cumulativeOutput: totalOutput,
+        costUsd: totalCostUsd,
+        model: modelId,
+        provider: llm?.type || '',
+      });
+      emitProgress({ type: 'usage', usage: snap });
+    } catch { /* never let telemetry break the run */ }
+  }
+  // Usage fields for the final transcript assistant message — Claude-Code parity:
+  // `usage` mirrors its per-message `message.usage`; `tokens`/`cost` stay for compat.
+  function transcriptUsageFields() {
+    const usage = lastTurnRawUsage
+      ? usageUtil.normalizeUsage(lastTurnRawUsage, { model: modelId, provider: llm?.type || '' })
+      : null;
+    return {
+      tokens: { input: totalInput, output: totalOutput, cost_usd: totalCostUsd },
+      usage,
+      cost: totalCostUsd,
+    };
+  }
+  // Record one turn's usage to the queryable ledger (parity with chat.js, which the
+  // coding agent previously skipped). Deduped per turn via a synthetic requestId.
+  function recordTurnUsageLedger(rawUsage, turnIndex) {
+    if (!rawUsage) return;
+    try {
+      require('./brain').recordModelUsage?.({
+        source: 'wall-e.coding',
+        feature: 'coding_turn',
+        sessionId: sid,
+        providerType: llm?.type || '',
+        modelId,
+        requestId: `${sid}:${turnIndex}:${_usageRequestSeq++}`,
+        usage: usageUtil.normalizeUsage(rawUsage, { model: modelId, provider: llm?.type || '' }),
+        stopReason: rawUsage.stopReason || null,
+        costUsd: usageUtil.costFor(rawUsage, modelId, llm?.type || ''),
+        costSource: 'wall-e.usage',
+        metadata: { turn: turnIndex, runtimeMode: opts.mode || 'executing' },
+      });
+    } catch { /* ledger is best-effort */ }
+  }
 
   // In-flight todo tracking (6m)
   let currentTodos = [];
@@ -2165,6 +2555,7 @@ async function runAgentLoop(prompt, opts = {}) {
   });
   const { AgentCatalog } = require('./coding/agent-catalog');
   const agentCatalog = opts.agentCatalog || new AgentCatalog({ projectRoot: resolvedCwd });
+  await maybePrewarmLocalOllama({ provider: llm, model: modelId, opts, emitProgress });
   const defaultTaskRunner = async ({ prompt: childPrompt, agent, taskId, ctx }) => {
     const childTools = agentCatalog.toolsForAgent(requestedTools, agent);
     const childResult = await runAgentLoop(childPrompt, {
@@ -2222,6 +2613,20 @@ async function runAgentLoop(prompt, opts = {}) {
   // Inspired by OpenCode Question service (packages/opencode/src/question/index.ts)
   const questionManager = opts.questionManager || new QuestionManager(events);
   const compactionService = createCodingCompactionService(llm, modelId, opts);
+
+  // Seed the turn from the prior conversation + tool trail so the agent reads
+  // its own history (a bare "go ahead." now has the proposed plan to refer to,
+  // and the agent does not re-investigate what it already explored). Skipped on
+  // a checkpoint resume (those messages are authoritative). Bounded to the
+  // context window via the compaction service just created above.
+  if (!opts._resumeMessages) {
+    const { buildInitialCodingMessages } = require('./coding/initial-messages');
+    messages = buildInitialCodingMessages({
+      prompt,
+      contextMessages: opts.contextMessages,
+      compactionService,
+    });
+  }
   const { RuntimeEventWriter } = require('./coding/runtime-events');
   const {
     appendPromptManifest,
@@ -2314,6 +2719,7 @@ async function runAgentLoop(prompt, opts = {}) {
     model: modelId,
     mode: opts.mode || '',
     runtimeMode: runtimeMode.id,
+    goal: String(prompt || ''),
     headless: Boolean(opts.headless),
     benchmark: Boolean(opts.benchmark),
     userHooks,
@@ -2353,6 +2759,22 @@ async function runAgentLoop(prompt, opts = {}) {
       provider: llm,
       model: modelId,
       transcript,
+      prepareToolCall: actionMemoryPolicy
+        ? async (call) => {
+          const evaluated = await actionMemoryPolicy.evaluateToolCall({
+            call,
+            context: actionMemoryContextForCall(call),
+            model: actionMemoryModelContext(),
+            sessionId: sid,
+            prompt,
+          });
+          return {
+            call: evaluated.call,
+            decision: evaluated.decision,
+            candidateCount: evaluated.candidates.length,
+          };
+        }
+        : null,
       snapshotService: opts.snapshotService || new SnapshotService({
         cwd: resolvedCwd,
         // Whole-worktree step snapshots + restart-surviving boundaries for
@@ -2362,7 +2784,32 @@ async function runAgentLoop(prompt, opts = {}) {
       }),
       permissionService,
       headless: Boolean(opts.headless || opts.benchmark),
-      toolExecutor: async (call) => {
+      goal: String(prompt || ''),
+      toolExecutor: async (call, runtimeCtx = {}) => {
+        const guardBlock = noProgressGuard.check(call, { cwd: resolvedCwd });
+        if (guardBlock) {
+          const blockedExecution = buildBlockedToolExecution(call, guardBlock);
+          noProgressGuard.record({ name: call.name, input: blockedExecution.evidenceInput }, {
+            ok: false,
+            result: blockedExecution.result,
+            blocked: true,
+            cwd: resolvedCwd,
+          });
+          emitProgress({
+            phase: opts.mode || 'executing',
+            step: 0,
+            message: `No-progress guard blocked repeated ${call.name}`,
+            detail: { tool: call.name, target: guardBlock.target, repeatCount: guardBlock.repeatCount },
+          });
+          events.emit('no_progress.detected', {
+            tool: call.name,
+            target: guardBlock.target,
+            repeatCount: guardBlock.repeatCount,
+            threshold: guardBlock.threshold,
+            sessionId: sid,
+          });
+          return blockedExecution.result;
+        }
         const execution = await streamToolExecutionController.execute(call, {
           sessionId: sid,
           cwd: resolvedCwd,
@@ -2373,7 +2820,26 @@ async function runAgentLoop(prompt, opts = {}) {
           runtimeMode: runtimeMode.id,
           interactive: opts.interactive,
           onTodos: (todos) => { currentTodos = todos; },
+          // Forward the turn's abort signal so user Stop kills an in-flight
+          // run_shell child, and a heartbeat so a long command shows live motion.
+          signal: runtimeCtx.signal,
+          onProgress: (info) => emitProgress({
+            phase: opts.mode || 'executing',
+            step: 0,
+            message: info?.message || 'still running…',
+            detail: info,
+          }),
+        });
+        const guardRecord = noProgressGuard.record({ name: call.name, input: execution.evidenceInput || call.input }, {
+          ok: execution.ok,
+          result: execution.result,
+          blocked: execution.blocked,
+          cwd: resolvedCwd,
         });
+        const guardNudge = buildNoProgressNudge(guardRecord);
+        if (guardNudge && execution.result && typeof execution.result === 'object' && !execution.result.error) {
+          execution.result._walleNoProgressAdvice = guardNudge.trim();
+        }
         return execution.result;
       },
     });
@@ -2389,6 +2855,7 @@ async function runAgentLoop(prompt, opts = {}) {
       // card and waiting state without a reload.
       if (evt && [
         'tool_call', 'tool_result', 'tool_done', 'skill_loaded', 'skill_load_failed',
+        'action_memory',
         'permission_request', 'permission_resolved', 'permission_denied', 'lane_event',
       ].includes(evt.type)) {
         emitProgress(evt);
@@ -2408,6 +2875,9 @@ async function runAgentLoop(prompt, opts = {}) {
     const streamErrors = [];
     let streamProviderError = null;
     let streamHadEdit = false;
+    let completionReportRequested = false;
+    const maxNoProgressGuardBlocks = opts.noProgressGuardMaxBlocks || Number(process.env.WALLE_NO_PROGRESS_MAX_BLOCKS) || 2;
+    let noProgressGuardBlockStreak = 0;
     for (let turnIndex = opts._resumeTurn || 0; turnIndex < turns; turnIndex++) {
       throwIfExternalAbort();
       const remaining = deadline - Date.now();
@@ -2417,6 +2887,10 @@ async function runAgentLoop(prompt, opts = {}) {
         finalOutput += '\n[Timeout reached]';
         break;
       }
+      // Compact-and-continue: if we're at the budget edge but still making progress,
+      // extend the turn budget (+ nudge to land the edit) BEFORE tools get stripped
+      // below, instead of forcing the model into a tool-less "summarize what's left".
+      tryExtendInteractiveTurnBudget(turnIndex);
       emitProgress({
         phase: opts.mode || 'executing',
         step: turnIndex,
@@ -2429,7 +2903,9 @@ async function runAgentLoop(prompt, opts = {}) {
       let turn;
       let toolsForTurn = [];
       try {
-        toolsForTurn = turnIndex >= turns - 1
+        // No tools on the last budgeted round, and none on the completion-report
+        // round (the model must answer, not start new work).
+        toolsForTurn = (turnIndex >= turns - 1 || completionReportRequested)
           ? []
           : await toolRegistry.getDefinitions({
             provider: llm.type,
@@ -2459,21 +2935,35 @@ async function runAgentLoop(prompt, opts = {}) {
           reason: 'stream_pre_turn',
           opts,
         });
+        compactNoProgressState(turnIndex, 'stream_pre_turn');
+        const requestKeepAlive = llmCtx.params.keepAlive ?? ollamaKeepAliveForRun(opts);
+        const llmStartedAt = Date.now();
         turn = await processor.runTurn({
           sessionId: sid,
           cwd: resolvedCwd,
           system: llmCtx.system,
           messages,
           tools: toolsForTurn,
-          maxTokens: taskFileHints.length >= 4 ? 8192 : 4096,
           signal: ac.signal,
           maxTokens: llmCtx.params.maxTokens,
           temperature: llmCtx.params.temperature,
           thinking: llmCtx.params.thinking,
           reasoningEffort: llmCtx.params.reasoningEffort,
           options: llmCtx.params.options,
+          keepAlive: requestKeepAlive,
           promptCache: true,
         });
+        emitOllamaTurnTiming({
+          emitProgress,
+          provider: llm,
+          model: modelId,
+          phase: opts.mode || 'executing',
+          step: turnIndex,
+          startedAt: llmStartedAt,
+          usage: turn.usage,
+          params: { ...llmCtx.params, keepAlive: requestKeepAlive },
+          toolsCount: toolsForTurn.length,
+        });
       } finally {
         clearTimeout(timer);
         unlinkExternalAbort();
@@ -2481,6 +2971,13 @@ async function runAgentLoop(prompt, opts = {}) {
 
       totalInput += turn.usage?.input || 0;
       totalOutput += turn.usage?.output || 0;
+      if (turn.usage) {
+        // Display/ledger only — the stream path has no budget-enforcement check,
+        // so leave budgetUsed's prior semantics unchanged.
+        totalCostUsd += usageUtil.costFor(turn.usage, modelId, llm?.type || '');
+        recordTurnUsageLedger(turn.raw?.usage || turn.usage, turnIndex);
+        emitUsageSnapshot(turn.usage);
+      }
       streamStatus = turn.status;
       streamStopReason = turn.stopReason || streamStopReason;
       streamModel = turn.model || streamModel;
@@ -2489,6 +2986,10 @@ async function runAgentLoop(prompt, opts = {}) {
       if (turn.text) finalOutput += turn.text;
       const streamToolCalls = (turn.toolCalls || []).map(tc => ({ name: tc.name, input: tc.input }));
       const streamToolResults = turn.toolResults || [];
+      const noProgressBlocks = streamToolResults.filter((record) => {
+        const result = record?.result || record;
+        return result?.noProgressGuard === true;
+      });
       toolCallHistory.push(...streamToolCalls.map((tc, index) => {
         const resultRecord = streamToolResults[index] || {};
         return normalizeToolCallEvidence(tc, resultRecord.result || resultRecord);
@@ -2509,6 +3010,30 @@ async function runAgentLoop(prompt, opts = {}) {
       });
       if (turn.hadEdit) streamHadEdit = true;
 
+      if (noProgressBlocks.length > 0) {
+        noProgressGuardBlockStreak += noProgressBlocks.length;
+        const latestBlock = noProgressBlocks[noProgressBlocks.length - 1]?.result || noProgressBlocks[noProgressBlocks.length - 1] || {};
+        if (noProgressGuardBlockStreak >= maxNoProgressGuardBlocks) {
+          const message = `No-progress guard stopped repeated ${latestBlock.tool || 'inspection'} loop after ${noProgressGuardBlockStreak} blocked tool calls.`;
+          streamStatus = 'error';
+          streamErrors.push(message);
+          finalOutput += `\n[${message}]`;
+          emitProgress({
+            phase: opts.mode || 'executing',
+            step: turnIndex,
+            message,
+            detail: {
+              tool: latestBlock.tool || '',
+              target: latestBlock.target || '',
+              repeatCount: latestBlock.repeatCount || noProgressGuardBlockStreak,
+            },
+          });
+          break;
+        }
+      } else if (streamToolCalls.length > 0 || turn.hadEdit) {
+        noProgressGuardBlockStreak = 0;
+      }
+
       if (turn.status === 'error') break;
       if ((turn.toolCalls || []).length === 0) {
         const continuation = getNoActionContinuation({
@@ -2547,7 +3072,25 @@ async function runAgentLoop(prompt, opts = {}) {
       }
       if (turn.assistantMessage) messages.push(turn.assistantMessage);
       if (turn.toolResultMessage) messages.push(turn.toolResultMessage);
-      if (turn.verified && streamHadEdit) break;
+      if (turn.verified && streamHadEdit && !completionReportRequested) {
+        // Verification succeeded after edits — but breaking here ends the run
+        // before the model has seen the verification result, so the persisted
+        // reply is accumulated narration that stops mid-thought ("finished
+        // without an answer", session c3f3af97). When a human is reading the
+        // reply, spend ONE no-tools round on the final completion report, then
+        // stop. Headless/benchmark runs keep the fast exit — their consumers
+        // score outcomes, not prose.
+        if (interactiveRun && turnIndex + 1 < turns) {
+          completionReportRequested = true;
+          messages.push({
+            role: 'user',
+            content: '[System: Verification succeeded and your edits are in place. Provide the final completion report now — what changed, how it was verified, and anything the user should know. Do not call more tools.]',
+          });
+          emitProgress({ phase: opts.mode || 'executing', step: turnIndex, message: 'Verified after edits — requesting final completion report' });
+          continue;
+        }
+        break;
+      }
       if (turn.next !== 'continue') break;
     }
 
@@ -2586,7 +3129,7 @@ async function runAgentLoop(prompt, opts = {}) {
         chatSessionId: opts.chatSessionId || '',
         model: streamModel,
         provider: llm.type || '',
-        tokens: { input: totalInput, output: totalOutput },
+        ...transcriptUsageFields(),
       });
     }
 
@@ -2604,6 +3147,7 @@ async function runAgentLoop(prompt, opts = {}) {
       exitCode: streamStatus === 'error' ? -1 : 0,
       log,
       usage: { input: totalInput, output: totalOutput },
+      costUsd: totalCostUsd,
       provider: llm.type,
       model: streamModel,
       next: 'stop',
@@ -2635,6 +3179,9 @@ async function runAgentLoop(prompt, opts = {}) {
         break;
       }
 
+      // Compact-and-continue: extend the budget (+ nudge to land the edit) at the cap
+      // edge while still making progress, BEFORE turnsRemaining drives the wrap-up below.
+      tryExtendInteractiveTurnBudget(turn);
       emitProgress({
         phase: opts.mode || 'executing',
         step: turn,
@@ -2675,6 +3222,7 @@ async function runAgentLoop(prompt, opts = {}) {
         reason: 'legacy_pre_turn',
         opts,
       });
+      compactNoProgressState(turn, 'legacy_pre_turn');
 
       // Graceful max-steps degradation (6n)
       // Note: warnings are appended to the LAST message's content (not as separate
@@ -2705,6 +3253,8 @@ async function runAgentLoop(prompt, opts = {}) {
 
       let response;
       try {
+        const requestKeepAlive = llmCtx.params.keepAlive ?? ollamaKeepAliveForRun(opts);
+        const llmStartedAt = Date.now();
         response = await llm.chat({
           model: modelId,
           system: llmCtx.system,
@@ -2716,9 +3266,21 @@ async function runAgentLoop(prompt, opts = {}) {
           thinking: llmCtx.params.thinking,
           reasoningEffort: llmCtx.params.reasoningEffort,
           options: llmCtx.params.options,
+          keepAlive: requestKeepAlive,
           promptCache: true,
           signal: ac.signal,
         });
+        emitOllamaTurnTiming({
+          emitProgress,
+          provider: llm,
+          model: modelId,
+          phase: opts.mode || 'executing',
+          step: turn,
+          startedAt: llmStartedAt,
+          usage: response.usage,
+          params: { ...llmCtx.params, keepAlive: requestKeepAlive },
+          toolsCount: adaptedTools.length,
+        });
       } finally {
         clearTimeout(timer);
         unlinkExternalAbort();
@@ -2749,23 +3311,20 @@ async function runAgentLoop(prompt, opts = {}) {
         totalOutput += response.usage.output || 0;
       }
 
-      // Per-step cost tracking (6q)
+      // Per-step cost tracking (6q): centralized pricing (cache-discounted) via
+      // lib/usage so coding + chat agree; also persist to the queryable ledger and
+      // push a live token/cost snapshot to watching clients.
       if (response.usage) {
         const inputTokens = response.usage.input || 0;
         const outputTokens = response.usage.output || 0;
-        // Cache hits cost 0.1x input price, cache writes 1.25x (Anthropic).
         const cacheRead = response.usage.cacheRead || 0;
         const cacheWrite = response.usage.cacheWrite || 0;
-        const effectiveInput = Math.max(0, inputTokens - cacheRead - cacheWrite)
-          + cacheRead * 0.1 + cacheWrite * 1.25;
-        // Cost estimate: rough pricing per 1M tokens
-        const costPer1M = {
-          input: modelId.includes('haiku') ? 0.25 : modelId.includes('sonnet') ? 3.0 : 15.0,
-          output: modelId.includes('haiku') ? 1.25 : modelId.includes('sonnet') ? 15.0 : 75.0,
-        };
-        const turnCost = (effectiveInput * costPer1M.input + outputTokens * costPer1M.output) / 1_000_000;
+        const turnCost = usageUtil.costFor(response.usage, modelId, llm?.type || '');
         turnCosts.push({ turn, inputTokens, outputTokens, cacheRead, cacheWrite, cost: turnCost });
         budgetUsed += turnCost;
+        totalCostUsd += turnCost;
+        recordTurnUsageLedger(response.raw?.usage || response.usage, turn);
+        emitUsageSnapshot(response.usage);
         if (opts.budgetUsd && budgetUsed > opts.budgetUsd) {
           finalOutput += '\n[Budget exceeded]';
           break;
@@ -2841,18 +3400,42 @@ async function runAgentLoop(prompt, opts = {}) {
           detail: { tool: tc.name, input: tc.input },
         });
 
-        const execution = await toolExecutionController.execute(tc, {
-          sessionId: sid,
-          cwd: resolvedCwd,
-          projectRoot: resolvedCwd,
-          model: modelId,
-          provider: llm.type,
-          mode: opts.mode || '',
-          runtimeMode: runtimeMode.id,
-          llmCtx,
-          interactive: opts.interactive,
-          onTodos: (todos) => { currentTodos = todos; },
-        });
+        const guardBlock = noProgressGuard.check(tc, { cwd: resolvedCwd });
+        let execution;
+        if (guardBlock) {
+          execution = buildBlockedToolExecution(tc, guardBlock);
+          emitProgress({
+            phase: opts.mode || 'executing',
+            step: turn,
+            message: `No-progress guard blocked repeated ${tc.name}`,
+            detail: { tool: tc.name, target: guardBlock.target, repeatCount: guardBlock.repeatCount },
+          });
+          events.emit('no_progress.detected', {
+            tool: tc.name,
+            target: guardBlock.target,
+            repeatCount: guardBlock.repeatCount,
+            threshold: guardBlock.threshold,
+            sessionId: sid,
+          });
+        } else {
+          execution = await executeWithActionMemoryPolicy({
+            call: tc,
+            context: actionMemoryContextForCall(tc),
+            execute: (preparedCall) => toolExecutionController.execute(preparedCall, {
+              sessionId: sid,
+              cwd: resolvedCwd,
+              projectRoot: resolvedCwd,
+              model: modelId,
+              provider: llm.type,
+              mode: opts.mode || '',
+              runtimeMode: runtimeMode.id,
+              llmCtx,
+              interactive: opts.interactive,
+              onTodos: (todos) => { currentTodos = todos; },
+            }),
+          });
+          emitActionMemoryDecision(execution, turn);
+        }
         const result = execution.result;
         const evidenceInput = execution.evidenceInput || tc.input || {};
         if (!execution.ok) turnHadError = true;
@@ -2883,11 +3466,19 @@ async function runAgentLoop(prompt, opts = {}) {
           detail: { tool: tc.name, resultLength: resultStr.length },
         });
 
-        const capped = truncated.content;
+        const evidence = normalizeToolCallEvidence({ name: tc.name, input: evidenceInput }, result);
+        const guardRecord = noProgressGuard.record({ name: tc.name, input: evidenceInput }, {
+          ok: execution.ok,
+          result,
+          blocked: execution.blocked,
+          cwd: resolvedCwd,
+        });
+        const guardNudge = buildNoProgressNudge(guardRecord);
+        let capped = truncated.content;
+        if (guardNudge) capped += guardNudge;
         toolResults.push({ type: 'tool_result', tool_use_id: tc.id, content: capped });
 
         log[log.length - 1].toolResults = log[log.length - 1].toolResults || [];
-        const evidence = normalizeToolCallEvidence({ name: tc.name, input: evidenceInput }, result);
         log[log.length - 1].toolResults.push({
           name: tc.name,
           resultLength: resultStr.length,
@@ -2905,7 +3496,7 @@ async function runAgentLoop(prompt, opts = {}) {
           if (recent.every(c => c.name === recent[0].name && c.inputHash === recent[0].inputHash)) {
             // Progressive recovery (Phase 6): suggest alternative tools before forcing wrap-up
             const altTools = {
-              read_file: 'grep_files or glob',
+              read_file: 'edit_file now if the needed location is visible; do not call read_file or list_directory again for the same target',
               edit_file: 'write_file or apply_patch',
               run_shell: 'read the error output carefully and try a different command',
               grep_files: 'glob or read_file on a specific path',
@@ -2915,6 +3506,10 @@ async function runAgentLoop(prompt, opts = {}) {
                        `${DOOM_LOOP_THRESHOLD} times. Try ${suggestion}, or use ask_user if you're stuck.`;
             const lastResult = toolResults[toolResults.length - 1];
             if (lastResult) lastResult.content += doomWarning;
+            if (lastResult && recent[0].name === 'read_file') {
+              const readPath = recent[0].input?.file_path || recent[0].input?.path || 'the file you just read';
+              lastResult.content += `\n[SYSTEM] Next action contract for local models: if the requested change belongs in ${readPath}, call edit_file with a non-identical old_string/new_string. Re-reading or listing is no progress.`;
+            }
             // Force wrap-up: cap remaining turns
             const turnsLeft = turns - turn;
             if (turnsLeft > 3) turns = turn + 3;
@@ -2992,7 +3587,7 @@ async function runAgentLoop(prompt, opts = {}) {
         chatSessionId: opts.chatSessionId || '',
         model: modelId,
         provider: llm?.type || '',
-        tokens: { input: totalInput, output: totalOutput },
+        ...transcriptUsageFields(),
       });
     }
 
@@ -3051,6 +3646,7 @@ async function runAgentLoop(prompt, opts = {}) {
       exitCode: -1,
       log,
       usage: { input: totalInput, output: totalOutput },
+      costUsd: totalCostUsd,
       provider: llm?.type,
       model: modelId,
       runtimeMode: runtimeMode.id,
@@ -3102,7 +3698,7 @@ async function runAgentLoop(prompt, opts = {}) {
       chatSessionId: opts.chatSessionId || '',
       model: modelId,
       provider: llm?.type || '',
-      tokens: { input: totalInput, output: totalOutput },
+      ...transcriptUsageFields(),
     });
   }
 
@@ -3122,6 +3718,7 @@ async function runAgentLoop(prompt, opts = {}) {
     exitCode: 0,
     log,
     usage: { input: totalInput, output: totalOutput },
+    costUsd: totalCostUsd,
     provider: llm?.type,
     model: modelId,
     runtimeMode: runtimeMode.id,
@@ -3263,6 +3860,7 @@ async function runPlannerPrompt(prompt, {
   thinking,
   reasoningEffort,
   options,
+  keepAlive,
   temperature,
   maxTokens,
   onProgress,
@@ -3287,6 +3885,7 @@ async function runPlannerPrompt(prompt, {
       thinking,
       reasoningEffort,
       options,
+      keepAlive,
       temperature: temperature ?? 0,
     }, maxTokens || 4096);
     const response = await llm.chat({
@@ -3300,6 +3899,7 @@ async function runPlannerPrompt(prompt, {
       thinking: params.thinking,
       reasoningEffort: params.reasoningEffort,
       options: params.options,
+      keepAlive: params.keepAlive ?? ollamaKeepAliveForRun(keepAlive !== undefined ? { keepAlive } : {}),
       signal: ac.signal,
     });
     const output = contentToText(response?.content || '');
@@ -4439,6 +5039,7 @@ module.exports = {
   isTimeoutOnlyOutput,
   resolveRunTimeoutMs,
   isInteractiveRun,
+  shouldExtendInteractiveBudget,
   isActionRequiredPrompt,
   isPrematureActionResponse,
   getNoActionContinuation,