@wrongstack/core 0.6.0 → 0.6.3

package/dist/defaults/index.js

@@ -3691,17 +3691,23 @@ async function streamProviderToResponse(provider, req, signal, ctx, events) {
           handleTextDelta(state, ev.text);
           events.emit("provider.text_delta", { ctx, text: ev.text });
           break;
-        case "tool_use_start":
-          handleToolUseStart(state, ev);
-          events.emit("provider.tool_use_start", { ctx, id: ev.id, name: ev.name });
+        case "tool_use_start": {
+          const idVal = ev.id;
+          const nameVal = ev.name;
+          handleToolUseStart(state, { id: idVal, name: nameVal });
+          const emittedPayload = { ctx, id: idVal ?? "unknown", name: nameVal ?? "unknown" };
+          events.emit("provider.tool_use_start", emittedPayload);
           break;
+        }
         case "tool_use_input_delta":
           handleToolUseInputDelta(state, ev);
           break;
-        case "tool_use_stop":
+        case "tool_use_stop": {
+          const stoppedName = state.tools.get(ev.id)?.name ?? "unknown";
           handleToolUseStop(state, ev);
-          events.emit("provider.tool_use_stop", { ctx, id: ev.id });
+          events.emit("provider.tool_use_stop", { ctx, id: ev.id, name: stoppedName });
           break;
+        }
         case "thinking_start":
           handleThinkingStart(state, ev);
           break;
@@ -3828,7 +3834,7 @@ var DefaultProviderRunner = class {
 };
 
 // src/utils/token-estimate.ts
-var RoughTokenEstimate = (text) => Math.max(1, Math.ceil(text.length / 4));
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
 var ESTIMATE_CACHE_MAX_SIZE = 1e4;
 function getCachedEstimate(key, compute) {
@@ -3915,7 +3921,7 @@ var HybridCompactor = class {
   eliseThreshold;
   estimator;
   constructor(opts = {}) {
-    this.preserveK = opts.preserveK ?? 10;
+    this.preserveK = opts.preserveK ?? 5;
     this.eliseThreshold = opts.eliseThreshold ?? 2e3;
     this.estimator = opts.estimator ?? estimateTextTokens;
   }
@@ -3959,6 +3965,17 @@ var HybridCompactor = class {
         preserveStart = i;
       }
     }
+    for (let i = preserveStart; i < messages.length; i++) {
+      const m = messages[i];
+      if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
+      const hasToolUse2 = m.content.some((b) => b.type === "tool_use");
+      if (hasToolUse2 && i + 1 < messages.length) {
+        const next = messages[i + 1];
+        if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => b.type === "tool_result")) {
+          preserveStart = i + 1;
+        }
+      }
+    }
     let saved = 0;
     let changed = false;
     const nextMessages = new Array(messages.length);
@@ -3980,7 +3997,7 @@ var HybridCompactor = class {
         const elided = {
           type: "tool_result",
           tool_use_id: b.tool_use_id,
-          content: `[elided: ~${tokens} tokens removed. Call the tool again if needed.]`,
+          content: `[elided: ~${tokens} tokens]`,
           is_error: b.is_error
         };
         return elided;
@@ -4119,7 +4136,28 @@ var IntelligentCompactor = class {
     try {
       summaryText = await this.callSummarizer(toSummarize, ctx);
     } catch {
-      summaryText = `[${toSummarize.length} earlier turns omitted \u2014 key decisions and file states preserved in context]`;
+      const toolNames = /* @__PURE__ */ new Set();
+      const filePaths = /* @__PURE__ */ new Set();
+      let userTurns = 0, assistantTurns = 0;
+      for (const m of toSummarize) {
+        if (m.role === "user") userTurns++;
+        else if (m.role === "assistant") {
+          assistantTurns++;
+          if (Array.isArray(m.content)) {
+            for (const b of m.content) {
+              if (b.type === "tool_use") toolNames.add(b.name ?? "unknown");
+            }
+          }
+        }
+        const text = typeof m.content === "string" ? m.content : "";
+        const matches = text.matchAll(/(?:[\w.,\-/@]+\/)*[\w.,\-/@]+\.\w+/g);
+        for (const m_ of matches) filePaths.add(m_[0]);
+      }
+      const parts = [`${toSummarize.length} turns (${userTurns} user, ${assistantTurns} assistant)`];
+      if (toolNames.size > 0) parts.push(`tools: ${[...toolNames].join(", ")}`);
+      if (filePaths.size > 0) parts.push(`files: ${[...filePaths].slice(0, 10).join(", ")}`);
+      summaryText = parts.join(" | ");
+      if (!summaryText) summaryText = `${toSummarize.length} earlier turns omitted`;
     }
     const summaryMsg = {
       role: "system",
@@ -4203,6 +4241,17 @@ var IntelligentCompactor = class {
         preserveStart = i;
       }
     }
+    for (let i = preserveStart; i < messages.length; i++) {
+      const m = messages[i];
+      if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
+      const hasToolUse2 = m.content.some((b) => b.type === "tool_use");
+      if (hasToolUse2 && i + 1 < messages.length) {
+        const next = messages[i + 1];
+        if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => b.type === "tool_result")) {
+          preserveStart = i + 1;
+        }
+      }
+    }
     let saved = 0;
     let changed = false;
     const nextMessages = new Array(messages.length);
@@ -4717,7 +4766,15 @@ var AutoCompactionMiddleware = class {
   }
   async compact(ctx, aggressive, pressure) {
     try {
-      await this.compactor.compact(ctx, { aggressive });
+      const report = await this.compactor.compact(ctx, { aggressive });
+      this.events?.emit("compaction.fired", {
+        level: pressure.level,
+        tokens: pressure.tokens,
+        load: pressure.load,
+        maxContext: this._maxContext,
+        report,
+        aggressive
+      });
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
       const fatal = this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard";
@@ -4971,13 +5028,17 @@ var ToolExecutor = class {
     const ctrl = new AbortController();
     const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
     const combined = AbortSignal.any([parentSignal, ctrl.signal]);
+    let cleanupCalled = false;
+    let caught = false;
     try {
       if (typeof tool.executeStream === "function") {
         return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
       }
       return await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
+      caught = true;
       if (combined.aborted && typeof tool.cleanup === "function") {
+        cleanupCalled = true;
         try {
           await tool.cleanup(input, ctx);
         } catch {
@@ -4986,6 +5047,16 @@ var ToolExecutor = class {
       throw err;
     } finally {
       clearTimeout(timer);
+      if (combined.aborted && !caught) {
+        if (!cleanupCalled && typeof tool.cleanup === "function") {
+          try {
+            await tool.cleanup(input, ctx);
+          } catch {
+          }
+        }
+        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
+        throw reason;
+      }
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -5043,7 +5114,8 @@ var ToolExecutor = class {
     if (subjectKey) {
       const v = obj[subjectKey];
       if (typeof v === "string") {
-        return subjectKey === "path" || subjectKey === "file" || subjectKey === "files" ? normalizePath(v) : escapeGlob(v);
+        const isPathKey = subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+        return isPathKey ? normalizePath(v) : escapeGlob(v);
       }
     }
     if (toolName === "bash" && typeof obj.command === "string") {
@@ -5269,6 +5341,8 @@ function appendJournal(goal, entry) {
 
 // src/execution/eternal-autonomy.ts
 var execFileP = promisify(execFile);
+var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
+var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]?complete\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
     this.opts = opts;
@@ -5278,6 +5352,14 @@ var EternalAutonomyEngine = class {
   state = "idle";
   stopRequested = false;
   consecutiveFailures = 0;
+  consecutiveBrainstormDone = 0;
+  /**
+   * Count of consecutive transient (recoverable) provider failures. Drives
+   * the exponential backoff between iterations. Reset on the first
+   * successful iteration so a single bad afternoon doesn't permanently
+   * slow the loop down.
+   */
+  consecutiveTransientRetries = 0;
   currentCtrl = null;
   iterationsSinceCompact = 0;
   goalPath;
@@ -5347,9 +5429,16 @@ var EternalAutonomyEngine = class {
       this.stopRequested = true;
       return false;
     }
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") {
+      this.stopRequested = true;
+      return false;
+    }
     const action = await this.decide(goal);
     if (!action) {
-      await sleep(5e3);
+      if (!this.stopRequested) {
+        await sleep(5e3);
+      }
       return false;
     }
     const ctrl = new AbortController();
@@ -5360,13 +5449,29 @@ var EternalAutonomyEngine = class {
     );
     let status = "success";
     let note;
+    let finalText = "";
+    let isTransientFailure = false;
     const tc = this.opts.agent.ctx?.tokenCounter;
     const beforeUsage = tc?.total?.();
     const beforeCost = tc?.estimateCost?.().total;
     try {
       const result = await this.opts.agent.run(
         [{ type: "text", text: action.directive }],
-        { signal: ctrl.signal }
+        {
+          signal: ctrl.signal,
+          // Enable per-call autonomous continuation so the agent can chain
+          // multiple internal tool/response cycles end-to-end on one
+          // directive instead of returning to the engine after a single
+          // round-trip. The model uses `[continue]` / `[done]` markers
+          // (or the `continue_to_next_iteration` tool) to control the
+          // inner loop. Without this flag the engine produced shallow
+          // iterations and almost never let a real task finish.
+          autonomousContinue: true,
+          // Cap the inner loop so a runaway agent.run can't burn through
+          // the iteration timeout — the engine's own outer loop is the
+          // long-running thing, each tick should be bounded.
+          maxIterations: this.opts.iterationMaxAgentSteps ?? 50
+        }
       );
       if (result.status === "aborted") {
         status = "aborted";
@@ -5374,22 +5479,30 @@ var EternalAutonomyEngine = class {
       } else if (result.status === "failed") {
         status = "failure";
         note = result.error?.describe?.() ?? "agent run failed";
+        isTransientFailure = result.error?.recoverable === true;
       } else if (result.status === "max_iterations") {
         status = "failure";
         note = `max iterations (${result.iterations})`;
       } else {
         status = "success";
-        const tail = (result.finalText ?? "").slice(0, 240).replace(/\s+/g, " ").trim();
+        finalText = result.finalText ?? "";
+        const tail = finalText.slice(0, 240).replace(/\s+/g, " ").trim();
         if (tail) note = tail;
       }
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
       status = isAbort ? "aborted" : "failure";
       note = err instanceof Error ? err.message : String(err);
+      if (!isAbort && typeof err?.recoverable === "boolean") {
+        isTransientFailure = err.recoverable;
+      }
     } finally {
       clearTimeout(timer);
       this.currentCtrl = null;
     }
+    if (action.source === "todo" && action.todoId && status !== "success") {
+      await this.bumpTodoAttempt(action.todoId);
+    }
     const afterUsage = tc?.total?.();
     const afterCost = tc?.estimateCost?.().total;
     const tokens = beforeUsage && afterUsage ? {
@@ -5422,6 +5535,14 @@ var EternalAutonomyEngine = class {
       costUsd
     });
     if (status === "failure") {
+      if (isTransientFailure) {
+        this.consecutiveTransientRetries++;
+        const delay = this.computeTransientBackoffMs();
+        if (delay > 0) {
+          await this.sleepInterruptible(delay);
+        }
+        return false;
+      }
       this.consecutiveFailures++;
       return false;
     }
@@ -5430,6 +5551,12 @@ var EternalAutonomyEngine = class {
       this.consecutiveFailures++;
       return false;
     }
+    this.consecutiveTransientRetries = 0;
+    if (GOAL_COMPLETE_MARKER.test(finalText)) {
+      await this.markGoalCompleted(action, finalText);
+      this.stopRequested = true;
+      return true;
+    }
     this.iterationsSinceCompact++;
     await this.maybeCompact().catch((err) => {
       this.opts.onError?.(
@@ -5493,11 +5620,12 @@ var EternalAutonomyEngine = class {
   async decide(goal) {
     const forceBrainstorm = this.consecutiveFailures >= (this.opts.failureBudget ?? 3);
     if (!forceBrainstorm) {
-      const todo = this.pickPendingTodo();
+      const todo = this.pickPendingTodo(goal);
       if (todo) {
         return {
           source: "todo",
           task: todo.content,
+          todoId: todo.id,
           directive: this.buildDirective(goal, "todo", todo.content)
         };
       }
@@ -5511,17 +5639,38 @@ var EternalAutonomyEngine = class {
       }
     }
     const brainstormed = await this.brainstormTask(goal);
+    if (brainstormed === BRAINSTORM_DONE) {
+      this.consecutiveBrainstormDone++;
+      const threshold = this.opts.brainstormDoneStopThreshold ?? 3;
+      if (this.consecutiveBrainstormDone >= threshold) {
+        await this.markGoalCompleted(
+          { source: "brainstorm", task: "no further work", directive: "" },
+          `brainstorm returned DONE ${this.consecutiveBrainstormDone}x in a row`
+        );
+        this.stopRequested = true;
+      }
+      return null;
+    }
     if (!brainstormed) return null;
+    this.consecutiveBrainstormDone = 0;
     return {
       source: "brainstorm",
       task: brainstormed,
       directive: this.buildDirective(goal, "brainstorm", brainstormed)
     };
   }
-  pickPendingTodo() {
+  pickPendingTodo(goal) {
     const todos = this.opts.agent.ctx.todos;
     if (!Array.isArray(todos)) return null;
-    return todos.find((t) => t.status === "pending") ?? null;
+    const attempts = goal.todoAttempts ?? {};
+    const ceiling = this.opts.todoMaxAttempts ?? 3;
+    for (const t of todos) {
+      if (t.status !== "pending") continue;
+      const used = attempts[t.id] ?? 0;
+      if (used >= ceiling) continue;
+      return t;
+    }
+    return null;
   }
   async pickGitTask() {
     let out;
@@ -5558,7 +5707,10 @@ ${lastFew}` : "No prior iterations yet.",
       "- One sentence, imperative form, under 200 chars.",
       "- No preamble, no explanation, no markdown \u2014 just the task line.",
       "- If recent iterations show repeated failures on the same target, pivot.",
-      "- If the goal appears fully accomplished, output exactly: DONE"
+      "- If the goal appears fully accomplished AND you can name a concrete",
+      "  artifact / test / output that proves it, output exactly: DONE",
+      "- Be conservative with DONE: if the recent journal contains failures",
+      "  or aborted entries, the goal is almost certainly NOT done."
     ].join("\n");
     try {
       const ctrl = new AbortController();
@@ -5570,9 +5722,11 @@ ${lastFew}` : "No prior iterations yet.",
         );
         if (result.status !== "done") return null;
         const text = (result.finalText ?? "").trim();
-        if (!text || text === "DONE") return null;
+        if (!text) return null;
+        if (/^DONE\.?$/i.test(text)) return BRAINSTORM_DONE;
         const firstLine = text.split("\n").find((l) => l.trim().length > 0)?.trim();
         if (!firstLine) return null;
+        if (/^DONE\.?$/i.test(firstLine)) return BRAINSTORM_DONE;
         return firstLine.slice(0, 240);
       } finally {
         clearTimeout(timer);
@@ -5582,19 +5736,82 @@ ${lastFew}` : "No prior iterations yet.",
     }
   }
   buildDirective(goal, source, task) {
+    const recentJournal = goal.journal.slice(-5).map((e) => `  #${e.iteration} [${e.status}] ${e.task}${e.note ? ` \u2014 ${e.note.slice(0, 80)}` : ""}`).join("\n");
     return [
-      "[ETERNAL AUTONOMY \u2014 iteration directive]",
+      "\u2550\u2550\u2550 ETERNAL AUTONOMY \u2014 iteration directive \u2550\u2550\u2550",
       "",
-      `Goal: ${goal.goal}`,
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations + 1}`,
       `Source: ${source}`,
       `Task: ${task}`,
       "",
-      "Execute this task end-to-end using the tools available to you. Make the",
-      "changes, run tests if relevant, and commit / push as appropriate. Do not",
-      "ask for confirmation \u2014 YOLO mode is active. When the task is done, stop;",
-      "the loop will pick the next action."
+      recentJournal ? `Recent journal (last 5):
+${recentJournal}` : "No prior iterations.",
+      "",
+      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+      "You are inside a long-running autonomous loop. Each iteration you",
+      "execute ONE concrete task that advances the Mission. No user is",
+      "available to clarify \u2014 make defensible decisions and move forward.",
+      "",
+      "1. EXECUTE END-TO-END",
+      "   \u2022 Use multiple tool calls freely. Emit `[continue]` on its own line",
+      "     to chain to the next internal step without returning.",
+      "   \u2022 When this iteration's Task is finished (real artifact / passing",
+      "     test / applied diff / clean output), emit `[done]` on its own line.",
+      "   \u2022 Do not stop on the first obstacle \u2014 try at least 3 distinct",
+      "     approaches before giving up. YOLO is active; no confirmations.",
+      "",
+      "2. UPDATE TODO STATE (when Source is `todo`)",
+      "   \u2022 Mark this todo `in_progress` via the todos tool before tool work.",
+      "   \u2022 Mark it `completed` on success, with a one-line outcome note.",
+      "   \u2022 If you cannot make progress after 2 distinct attempts, mark it",
+      "     `cancelled` with the obstacle. The loop will skip it next time.",
+      "",
+      "3. MISSION-COMPLETE PROTOCOL",
+      "   \u2022 If \u2014 and ONLY if \u2014 the OVERALL Mission (not just this Task) is",
+      "     verifiably accomplished, emit on its own line:",
+      "         [GOAL_COMPLETE]",
+      "     followed by a one-paragraph verification recipe (artifact path,",
+      "     test command, or 10-second reproduction). This halts the loop.",
+      "   \u2022 NEVER emit [GOAL_COMPLETE] on optimism, partial progress, or",
+      '     "looks fine". Required: a concrete artifact that proves it AND',
+      "     no recent journal failures contradicting completion.",
+      "   \u2022 If unsure, emit `[done]` instead and let the next iteration",
+      "     decide. The loop is patient; false completion is not.",
+      "",
+      "4. NO INTERACTIVITY",
+      "   \u2022 Do not ask questions, do not request confirmation, do not propose",
+      "     options. Pick the best path and execute. The user is asleep."
     ].join("\n");
   }
+  /**
+   * Exponential backoff for transient provider errors. `2^N * base`
+   * capped at `transientBackoffMaxMs`. Zero base disables backoff.
+   * Public-private to keep `runOneIteration` readable; the value is
+   * recomputed each call from the current retry count, so callers
+   * don't have to track state.
+   */
+  computeTransientBackoffMs() {
+    const base = this.opts.transientBackoffBaseMs ?? 2e3;
+    const cap = this.opts.transientBackoffMaxMs ?? 6e4;
+    if (base <= 0) return 0;
+    const exponent = Math.max(0, this.consecutiveTransientRetries - 1);
+    return Math.min(cap, base * Math.pow(2, exponent));
+  }
+  /**
+   * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
+   * so SIGINT / `/autonomy stop` can land in the middle of a long
+   * backoff instead of waiting up to a minute for the timer.
+   */
+  async sleepInterruptible(totalMs) {
+    const step = 250;
+    let remaining = totalMs;
+    while (remaining > 0 && !this.stopRequested) {
+      const chunk = Math.min(step, remaining);
+      await sleep(chunk);
+      remaining -= chunk;
+    }
+  }
   async appendIterationEntry(entry) {
     const current = await loadGoal(this.goalPath);
     if (!current) {
@@ -5603,6 +5820,39 @@ ${lastFew}` : "No prior iterations yet.",
     const updated = appendJournal(current, entry);
     await saveGoal(this.goalPath, updated);
   }
+  /**
+   * Persistent per-todo failure counter. Skipped silently when the goal
+   * file has been removed (graceful clear). Each non-success iteration
+   * against a todo source bumps the counter by 1; `pickPendingTodo` reads
+   * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
+   */
+  async bumpTodoAttempt(todoId) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    const attempts = { ...current.todoAttempts ?? {} };
+    attempts[todoId] = (attempts[todoId] ?? 0) + 1;
+    await saveGoal(this.goalPath, { ...current, todoAttempts: attempts });
+  }
+  /**
+   * Flip the mission to `completed` and journal it. Called from two
+   * paths: (a) `[GOAL_COMPLETE]` marker in a successful iteration's
+   * finalText, (b) `brainstorm` returning DONE consecutively past the
+   * configured threshold. Idempotent — re-entry is a no-op once the
+   * goal is already `completed`.
+   */
+  async markGoalCompleted(action, note) {
+    const current = await loadGoal(this.goalPath);
+    if (!current) return;
+    if (current.goalState === "completed") return;
+    const withFlag = { ...current, goalState: "completed" };
+    const withEntry = appendJournal(withFlag, {
+      source: action.source,
+      task: `MISSION COMPLETE \u2014 ${action.task}`.slice(0, 240),
+      status: "success",
+      note: note.slice(0, 240)
+    });
+    await saveGoal(this.goalPath, withEntry);
+  }
   async appendFailure(task, note) {
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
@@ -5617,6 +5867,142 @@ function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
+// src/execution/autonomy-prompt-contributor.ts
+function makeAutonomyPromptContributor(opts) {
+  return async (ctx) => {
+    if (ctx.subagent) return [];
+    if (!opts.enabled()) return [];
+    let goal;
+    try {
+      goal = await loadGoal(opts.goalPath);
+    } catch {
+      return [];
+    }
+    if (!goal) return [];
+    const missionState = goal.goalState ?? "active";
+    if (missionState !== "active") return [];
+    const tailSize = opts.journalTailSize ?? 5;
+    const journalTail = goal.journal.slice(-tailSize).map((e) => {
+      const note = e.note ? ` \u2014 ${e.note.slice(0, 80)}` : "";
+      return `  #${e.iteration} [${e.status}] ${e.task}${note}`;
+    });
+    const text = [
+      "## ETERNAL AUTONOMY \u2014 active mission",
+      "",
+      "You are inside a long-running autonomous loop. The user is asleep",
+      "and is not available to confirm decisions. Each turn you receive a",
+      "directive describing one concrete sub-task that advances the mission.",
+      "",
+      `Mission: ${goal.goal}`,
+      `Iteration: #${goal.iterations}`,
+      journalTail.length > 0 ? `Recent journal (last ${journalTail.length}):
+${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first iteration)",
+      "",
+      "### Loop control markers",
+      "Emit these on their own line in your final text \u2014 case-insensitive,",
+      "whitespace-tolerant, but they must occupy the entire line:",
+      "- `[continue]` \u2014 chain to the next internal step without returning.",
+      "- `[done]` \u2014 the current sub-task is finished; return to the engine.",
+      "- `[GOAL_COMPLETE]` \u2014 emit ONLY when the OVERALL mission is",
+      "  verifiably done. Must be followed by a one-paragraph verification",
+      "  recipe (artifact path, test command, or 10-second reproduction).",
+      "  The engine halts on this marker \u2014 false positives waste real",
+      "  human time. If unsure, emit `[done]` and let the next iteration",
+      "  decide.",
+      "",
+      "### Operating principles",
+      "- YOLO is active. Do NOT ask for confirmation, do NOT propose",
+      "  options. Pick the best path and execute it.",
+      "- Use tools freely; multiple calls per turn are normal and expected.",
+      "- When working on a todo, mark it `in_progress` via the todos tool",
+      "  before tool work and `completed` (or `cancelled` with a reason)",
+      "  when done. The loop reads todo state between iterations.",
+      "- If an approach fails twice in a row, pivot. Don't grind on the",
+      "  same wall \u2014 try a different angle, file a cancel on the todo, or",
+      "  surface the obstacle via `[done]` and let the next iteration",
+      "  re-plan."
+    ].join("\n");
+    return [
+      {
+        type: "text",
+        text,
+        cache_control: { type: "ephemeral" }
+      }
+    ];
+  };
+}
+
+// src/execution/goal-preamble.ts
+function buildGoalPreamble(goal) {
+  return [
+    "[GOAL \u2014 LOCKED IN. You will work on this until it is verifiably done.",
+    "The user granted you full autonomy. Read these constraints once, then act.",
+    "",
+    "YOUR GOAL:",
+    "---",
+    goal,
+    "---",
+    "",
+    "AUTHORITY YOU HAVE:",
+    "- Spawn as many subagents as the work needs (delegate / spawn_subagent).",
+    "  Parallel + recursive fan-out are both fine. There is no spawn budget.",
+    "- Use any provider/model per subagent \u2014 pick the right tool for each",
+    "  piece of work. Heavy reasoning model for planning, fast model for",
+    "  batch work, specialist model for domain code.",
+    "- Run unlimited tool calls and iterations. There is NO hidden budget.",
+    "  The Agent loop auto-extends every 100 iterations forever.",
+    "- Retry failed tools with different inputs, alternative paths, fresh",
+    "  subagents. Switch providers mid-run if one is rate-limited.",
+    "- Re-plan freely when an approach hits a dead end. You are not obliged",
+    "  to stick with the first plan you proposed.",
+    "",
+    'WHAT "DONE" MEANS \u2014 non-negotiable:',
+    "- You can name a concrete artifact (a passing test, a written file at",
+    "  a specific path, a fixed bug verified by re-running the failing case,",
+    "  a clean grep that previously had matches).",
+    "- You can tell the user HOW to verify it themselves in 10 seconds.",
+    '- You have NOT hedged. None of: "looks like it should work", "I',
+    '  believe this fixes it", "the changes appear correct".',
+    "",
+    "WHAT IS NOT DONE \u2014 never report any of these as completion:",
+    "- An error message you didn't recover from.",
+    '- An empty result, a 0-line file, a "no matches found" you accepted',
+    "  without questioning the search.",
+    '- "Should I continue?" / "Want me to also...?" / "Let me know if you',
+    '  want X." Those are hedges. The user already told you to finish the',
+    "  goal \u2014 just do it.",
+    "- Partial progress dressed up as success. Fixed 3 of 5 bugs = 60%",
+    "  done, not done.",
+    "- A subagent's failed/timeout/stopped TaskResult that you didn't",
+    "  respond to with a fresh attempt (different role, different model,",
+    "  tighter prompt).",
+    "",
+    "PERSISTENCE PROTOCOL:",
+    "- If blocked, try at least 3 different angles before reporting the",
+    "  problem to the user. Different tool inputs, different subagent",
+    "  roles, different providers, different decomposition of the task.",
+    "- If a tool fails, read its error, alter the input, try again. Do",
+    "  not just report the failure back.",
+    "- If a subagent returns useless output, respawn with a tighter prompt",
+    '  or a different role. Do not accept "I could not determine\u2026" as the',
+    "  final answer.",
+    "- Use `ask_subagent` for one-shot questions when you don't need a",
+    "  full delegated task.",
+    "",
+    "REPORTING:",
+    "- Stream short progress notes between major actions so the user can",
+    "  monitor. Do not go silent for 50 tool calls then dump a wall of",
+    "  text \u2014 but also do not narrate every tool call.",
+    "- Use the shared scratchpad (if available) to leave breadcrumbs",
+    "  subagents can read.",
+    "- Final response must include: (a) what was accomplished, (b) how",
+    "  to verify, (c) any caveats (residual TODOs, things the user",
+    "  should know about).",
+    "",
+    "BEGIN.]"
+  ].join("\n");
+}
+
 // src/coordination/director.ts
 init_atomic_write();
 
@@ -5875,40 +6261,12 @@ var FleetBus = class {
    * subagent teardown so the listeners don't outlive the run.
    */
   attach(subagentId, bus, taskId) {
-    const FORWARDED_TYPES = [
-      "tool.started",
-      "tool.executed",
-      "tool.progress",
-      "tool.confirm_needed",
-      "iteration.started",
-      "iteration.completed",
-      "provider.text_delta",
-      // Subagent extended-thinking output. Forwarded so the FleetPanel /
-      // /fleet log can surface "the planner is thinking…" instead of a
-      // silent gap between iteration.started and the first text_delta.
-      "provider.thinking_delta",
-      "provider.response",
-      "provider.retry",
-      "provider.error",
-      "session.started",
-      "session.ended",
-      "session.damaged",
-      "compaction.fired",
-      "compaction.failed",
-      "token.threshold",
-      // Subagent hit a soft budget limit — coordinator can extend or stop.
-      "budget.threshold_reached"
-    ];
-    const offs = [];
-    for (const t of FORWARDED_TYPES) {
-      offs.push(
-        bus.on(t, (payload) => {
-          this.emit({ subagentId, taskId, ts: Date.now(), type: t, payload });
-        })
-      );
-    }
+    const off = bus.onPattern("*", (type, payload) => {
+      if (type.startsWith("subagent.")) return;
+      this.emit({ subagentId, taskId, ts: Date.now(), type, payload });
+    });
     return () => {
-      for (const off of offs) off();
+      off();
     };
   }
   /** Subscribe to every event from one subagent. */
@@ -6073,7 +6431,7 @@ var BudgetThresholdSignal = class extends Error {
     this.decision = decision;
   }
 };
-var SubagentBudget = class {
+var SubagentBudget = class _SubagentBudget {
   limits;
   iterations = 0;
   toolCalls = 0;
@@ -6082,6 +6440,26 @@ var SubagentBudget = class {
   costUsd = 0;
   startTime = null;
   _onThreshold;
+  /**
+   * Tracks which budget kinds currently have an extension request
+   * in flight. While a kind is here, further `checkLimit` calls for the
+   * same kind are no-ops — without this dedup, every `recordIteration`
+   * after the limit is reached spawns a fresh decision Promise (until
+   * the first one lands and patches limits), flooding the FleetBus
+   * with redundant threshold events. Cleared in `checkLimitAsync`'s
+   * `finally`.
+   */
+  pendingExtensions = /* @__PURE__ */ new Set();
+  /**
+   * Hard cap on how long `checkLimitAsync` waits for the coordinator to
+   * respond before defaulting to 'stop'. Without this fallback an absent
+   * or hung listener (Director not built / event filter detached mid-run)
+   * leaves the budget over-limit and never enforces anything, since
+   * `checkLimit` returns synchronously via `void this.checkLimitAsync`.
+   * Hardcoded for now — most fleets set their own per-task timeout that
+   * dwarfs this anyway. 30 s matches the existing event-emit timeoutMs.
+   */
+  static DECISION_TIMEOUT_MS = 3e4;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used by `checkLimitAsync` to emit `budget.threshold_reached` events.
@@ -6124,56 +6502,92 @@ var SubagentBudget = class {
     if (kind === "timeout" || !this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
-    void this.checkLimitAsync(kind, used, limit);
+    const bus = this._events;
+    if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+      throw new BudgetExceededError(kind, limit, used);
+    }
+    if (this.pendingExtensions.has(kind)) return;
+    this.pendingExtensions.add(kind);
+    const decision = this.negotiateExtension(kind, used, limit);
+    throw new BudgetThresholdSignal(kind, limit, used, decision);
   }
   /**
-   * Async threshold negotiation with the coordinator. Fire-and-forget —
-   * any error thrown here becomes an unhandled rejection in the test environment
-   * because the runner's catch only handles the synchronous throw from `checkLimit`.
+   * Drive the threshold handler to a decision. Resolves with `'stop'`
+   * (signal the runner to abort) or `{ extend: ... }` (limits already
+   * patched in-place; the runner should not abort). Always releases the
+   * `pendingExtensions` slot in `finally`.
+   *
+   * The 'continue' return from a sync handler is treated as
+   * `{ extend: {} }` — keep going without patching, next overrun will
+   * fire a fresh signal.
    */
-  async checkLimitAsync(kind, used, limit) {
-    const result = this._onThreshold({
-      kind,
-      used,
-      limit,
-      // Inject a requestDecision helper the handler can call to emit the
-      // budget.threshold_reached event and wait for the coordinator's verdict.
-      // The runner wires this by injecting its EventBus into ctx.budget._events.
-      requestDecision: () => {
-        return new Promise((resolve2) => {
-          this._events?.emit("budget.threshold_reached", {
-            kind,
-            used,
-            limit,
-            timeoutMs: 3e4,
-            extend: (extra) => resolve2({ extend: extra }),
-            deny: () => resolve2("stop")
+  async negotiateExtension(kind, used, limit) {
+    try {
+      const result = this._onThreshold({
+        kind,
+        used,
+        limit,
+        // Inject a requestDecision helper the handler can call to emit the
+        // budget.threshold_reached event and wait for the coordinator's verdict.
+        // A hard fallback timer guarantees the promise eventually resolves
+        // even if no listener responds — without it, an absent/detached
+        // Director would leave the budget permanently in "asking" state.
+        requestDecision: () => {
+          const bus = this._events;
+          if (!bus || bus.listenerCount("budget.threshold_reached") === 0) {
+            return Promise.resolve("stop");
+          }
+          return new Promise((resolve2) => {
+            let resolved = false;
+            const respond = (d) => {
+              if (resolved) return;
+              resolved = true;
+              resolve2(d);
+            };
+            const fallback = setTimeout(
+              () => respond("stop"),
+              _SubagentBudget.DECISION_TIMEOUT_MS
+            );
+            bus.emit("budget.threshold_reached", {
+              kind,
+              used,
+              limit,
+              timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+              extend: (extra) => {
+                clearTimeout(fallback);
+                respond({ extend: extra });
+              },
+              deny: () => {
+                clearTimeout(fallback);
+                respond("stop");
+              }
+            });
           });
-        });
+        }
+      });
+      if (result === "throw") return "stop";
+      if (result === "continue") return { extend: {} };
+      const decision = await result;
+      if (decision === "stop") return "stop";
+      const ext = decision.extend;
+      if (ext.maxIterations !== void 0) {
+        this.limits.maxIterations = ext.maxIterations;
       }
-    });
-    if (result === "throw") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    if (result === "continue") {
-      return;
-    }
-    const decision = await result;
-    if (decision === "stop") {
-      throw new BudgetExceededError(kind, limit, used);
-    }
-    const ext = decision.extend;
-    if (ext.maxIterations !== void 0) {
-      this.limits.maxIterations = ext.maxIterations;
-    }
-    if (ext.maxToolCalls !== void 0) {
-      this.limits.maxToolCalls = ext.maxToolCalls;
-    }
-    if (ext.maxTokens !== void 0) {
-      this.limits.maxTokens = ext.maxTokens;
-    }
-    if (ext.maxCostUsd !== void 0) {
-      this.limits.maxCostUsd = ext.maxCostUsd;
+      if (ext.maxToolCalls !== void 0) {
+        this.limits.maxToolCalls = ext.maxToolCalls;
+      }
+      if (ext.maxTokens !== void 0) {
+        this.limits.maxTokens = ext.maxTokens;
+      }
+      if (ext.maxCostUsd !== void 0) {
+        this.limits.maxCostUsd = ext.maxCostUsd;
+      }
+      if (ext.timeoutMs !== void 0) {
+        this.limits.timeoutMs = ext.timeoutMs;
+      }
+      return decision;
+    } finally {
+      this.pendingExtensions.delete(kind);
     }
   }
   recordIteration() {
@@ -6456,6 +6870,19 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   setRunner(runner) {
     this.runner = runner;
   }
+  /**
+   * Change the in-flight dispatch ceiling at runtime. Lowering does NOT
+   * preempt running tasks — already-dispatched subagents finish their
+   * current task; only future dispatches respect the new cap. Raising
+   * immediately tries to fill the freed slots from the pending queue.
+   */
+  setMaxConcurrent(n) {
+    if (!Number.isFinite(n) || n < 1) {
+      throw new Error(`maxConcurrent must be a finite integer >= 1, got ${n}`);
+    }
+    this.config.maxConcurrent = Math.floor(n);
+    this.tryDispatchNext();
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
     if (this.subagents.has(id)) {
@@ -6715,14 +7142,65 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.recordCompletion(result);
   }
   async executeWithTimeout(runner, task, ctx, budget) {
-    const timeoutMs = budget.limits.timeoutMs;
-    if (timeoutMs === void 0) return runner(task, ctx);
+    const initialTimeoutMs = budget.limits.timeoutMs;
+    if (initialTimeoutMs === void 0) return runner(task, ctx);
+    const start = Date.now();
     let timer = null;
     const timeoutPromise = new Promise((_, reject) => {
-      timer = setTimeout(() => {
-        this.subagents.get(ctx.subagentId)?.abortController.abort();
-        reject(new BudgetExceededError("timeout", timeoutMs, Date.now()));
-      }, timeoutMs);
+      const armFor = (ms) => {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(async () => {
+          const elapsed = Date.now() - start;
+          const limit = budget.limits.timeoutMs ?? initialTimeoutMs;
+          if (!budget.onThreshold) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+            return;
+          }
+          try {
+            const result = budget.onThreshold({
+              kind: "timeout",
+              used: elapsed,
+              limit,
+              requestDecision: () => new Promise((resolveDecision) => {
+                budget._events?.emit("budget.threshold_reached", {
+                  kind: "timeout",
+                  used: elapsed,
+                  limit,
+                  timeoutMs: 3e4,
+                  extend: (extra) => resolveDecision({ extend: extra }),
+                  deny: () => resolveDecision("stop")
+                });
+              })
+            });
+            const decision = typeof result === "string" ? result : await result;
+            if (decision === "continue") {
+              armFor(Math.max(1e3, limit));
+              return;
+            }
+            if (decision === "throw" || decision === "stop") {
+              this.subagents.get(ctx.subagentId)?.abortController.abort();
+              reject(new BudgetExceededError("timeout", limit, elapsed));
+              return;
+            }
+            if (decision.extend.timeoutMs !== void 0) {
+              budget.limits.timeoutMs = decision.extend.timeoutMs;
+              const newLimit = decision.extend.timeoutMs;
+              const remaining = Math.max(1e3, newLimit - elapsed);
+              armFor(remaining);
+              return;
+            }
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(new BudgetExceededError("timeout", limit, elapsed));
+          } catch (err) {
+            this.subagents.get(ctx.subagentId)?.abortController.abort();
+            reject(
+              err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
+            );
+          }
+        }, ms);
+      };
+      armFor(initialTimeoutMs);
     });
     try {
       return await Promise.race([runner(task, ctx), timeoutPromise]);
@@ -7333,7 +7811,7 @@ var Director = class {
         return;
       }
       extendCounts.set(guardKey, prior + 1);
-      setTimeout(() => {
+      setImmediate(() => {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
@@ -7348,9 +7826,12 @@ var Director = class {
           case "cost":
             extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
             break;
+          case "timeout":
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            break;
         }
         payload.extend(extra);
-      }, Math.min(payload.timeoutMs, 3e4));
+      });
     });
   }
   /** Best-effort session-writer append. Swallows failures — the director
@@ -8145,6 +8626,7 @@ function makeAgentSubagentRunner(opts) {
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
+    ctx.budget.onThreshold = ({ requestDecision }) => requestDecision();
     let budgetError = null;
     const onBudgetError = (err) => {
       if (err instanceof BudgetThresholdSignal) {
@@ -11458,7 +11940,7 @@ function wireMetricsToEvents(events, sink) {
     events.on("token.threshold", (e) => sink.gauge("agent.tokens.used", e.used)),
     events.on("compaction.fired", (e) => {
       sink.counter("compaction.fired.total");
-      sink.histogram("compaction.reduction_tokens", e.before - e.after);
+      sink.histogram("compaction.reduction_tokens", e.report.before - e.report.after);
     }),
     events.on(
       "mcp.server.connected",
@@ -12231,6 +12713,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, EternalAutonomyEngine, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map