@wrongstack/core 0.302.2 → 0.305.0

package/dist/core/index.js

@@ -2177,12 +2177,11 @@ function redactHqValueInternal(value, options, preserveRawContentKeys) {
   });
   return { value: result.value, redacted: result.redacted };
 }
+function redactHqEventPayload(type, payload, options = {}) {
+  return redactHqValueInternal(payload, options, HQ_PROJECT_STATE_EVENT_TYPES.has(type));
+}
 function redactHqEvent(event, options = {}) {
-  const payload = redactHqValueInternal(
-    event.payload,
-    options,
-    HQ_PROJECT_STATE_EVENT_TYPES.has(event.type)
-  );
+  const payload = redactHqEventPayload(event.type, event.payload, options);
   const nextEvent = {
     ...event,
     payload: payload.value
@@ -2334,7 +2333,9 @@ function queuedFrameCoalesceKey(frame) {
   if (frame.type !== "client.event" || !frame.event.type.endsWith(".snapshot")) {
     return void 0;
   }
-  return [frame.event.type, frame.event.sessionId ?? "", frame.event.runId ?? ""].join("|");
+  const payload = frame.event.payload;
+  const chunk = typeof payload?.chunkIndex === "number" && Number.isFinite(payload.chunkIndex) ? String(payload.chunkIndex) : "";
+  return [frame.event.type, frame.event.sessionId ?? "", frame.event.runId ?? "", chunk].join("|");
 }
 function defaultSocketFactory(url) {
   const WebSocketCtor = globalThis.WebSocket;
@@ -2667,6 +2668,10 @@ var HqPublisher = class {
     if (bytes > this.maxQueuedBytes) {
       this.droppedFrames += 1;
       this.droppedBytes += bytes;
+      process.emitWarning(
+        `HQ telemetry frame of ${bytes} bytes exceeds the ${this.maxQueuedBytes}-byte offline queue cap and was dropped.`,
+        { code: "WRONGSTACK_HQ_FRAME_TOO_LARGE" }
+      );
       return;
     }
     if (coalesceKey !== void 0) {
@@ -4338,6 +4343,18 @@ function metadataReferencedByText(metadata, haystack) {
 }
 
 // src/utils/todos-format.ts
+function formatTodoForModel(todo) {
+  const binding = todo.kanbanBoardId && todo.kanbanTaskId ? ` <kanban ${todo.kanbanBoardId}/${todo.kanbanTaskId}>` : "";
+  const blocked = todo.blockedBy?.length ? ` [blocked by: ${todo.blockedBy.join("; ")}]` : "";
+  return `- [${todo.status}]${blocked} ${todo.content} (${todo.id})${binding}`;
+}
+function formatTodosForModel(todos, emptyLine = "- No active todos remain.") {
+  return todos.length ? todos.map(formatTodoForModel).join("\n") : emptyLine;
+}
+function hasKanbanBoundTodos(todos) {
+  if (!Array.isArray(todos)) return false;
+  return todos.some((todo) => Boolean(todo.kanbanBoardId && todo.kanbanTaskId));
+}
 function hasOpenTodos(todos) {
   if (!Array.isArray(todos) || todos.length === 0) return false;
   return todos.some((t2) => t2.status === "pending" || t2.status === "in_progress");
@@ -4620,6 +4637,12 @@ function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
 import * as path10 from "node:path";
 
 // src/core/conversation-state.ts
+function hasToolResultBlock(message) {
+  return message !== void 0 && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_result");
+}
+function hasToolUseBlock(message) {
+  return message?.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_use");
+}
 var ConversationState = class {
   ctx;
   listeners = /* @__PURE__ */ new Set();
@@ -4687,15 +4710,32 @@ var ConversationState = class {
    */
   overflowCount(arr) {
     let drop = Context.MAX_MESSAGES > 0 ? Math.max(0, arr.length - Context.MAX_MESSAGES) : 0;
-    if (Context.MAX_MESSAGE_TOKENS <= 0) return drop;
+    if (Context.MAX_MESSAGE_TOKENS <= 0) return this.protocolSafeDropCount(arr, drop);
     let total = 0;
     for (let i = drop; i < arr.length; i++) total += arr[i]?._estTokens ?? 0;
-    if (total <= Context.MAX_MESSAGE_TOKENS) return drop;
+    if (total <= Context.MAX_MESSAGE_TOKENS) return this.protocolSafeDropCount(arr, drop);
     while (drop < arr.length - 1 && total > Context.MAX_MESSAGE_TOKENS) {
       total -= arr[drop]?._estTokens ?? 0;
       drop++;
     }
-    return drop;
+    return this.protocolSafeDropCount(arr, drop);
+  }
+  /**
+   * Front eviction must not retain a `tool_result` after evicting the
+   * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
+   * at the retention cap, so an unsafe boundary would create a fresh orphan on
+   * nearly every append and make the request-time repair discard protocol
+   * history continuously.
+   *
+   * Move the boundary backward to retain the complete exchange for one more
+   * eviction cycle. Moving it forward would also drop non-protocol text/images
+   * that may share either message. The temporary one-message cap overshoot is
+   * the minimum lossless representation; once enough newer messages exist, the
+   * next eviction boundary naturally moves past both halves together.
+   */
+  protocolSafeDropCount(arr, drop) {
+    if (drop <= 0 || drop >= arr.length) return drop;
+    return hasToolResultBlock(arr[drop]) && hasToolUseBlock(arr[drop - 1]) ? drop - 1 : drop;
   }
   /**
    * Append a content block to the trailing user message's content array.
@@ -5103,6 +5143,28 @@ var Context = class _Context {
       return _Context.CONVERSATION_JOURNAL_MAX_BYTES + 1;
     }
   }
+  _journalDropCount = 0;
+  _journalDropWarnAt = 0;
+  /** Throttled notice that a conversation event never reached the journal. */
+  warnConversationJournalDrop(eventType) {
+    this._journalDropCount++;
+    const now = Date.now();
+    if (now - this._journalDropWarnAt < 5e3) return;
+    this._journalDropWarnAt = now;
+    const dropped = this._journalDropCount;
+    this._journalDropCount = 0;
+    console.warn(
+      JSON.stringify({
+        level: "error",
+        event: "session.conversation_journal_drop",
+        sessionId: this.session?.id,
+        eventType,
+        droppedEvents: dropped,
+        message: "Session writer is not draining; replay of this session will be incomplete.",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
   enqueueConversationJournal(event, writer) {
     const bytes = this.conversationJournalBytes(event);
     const shouldSnapshot = event.type === "messages_replaced" || this._conversationJournalQueue.length >= _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes + bytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES;
@@ -5120,18 +5182,21 @@ var Context = class _Context {
         this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - queued.bytes);
         this._conversationJournalQueue.splice(index, 1);
       }
-      if (snapshotBytes <= _Context.CONVERSATION_JOURNAL_MAX_BYTES) {
-        this._conversationJournalQueue.push({ event: snapshot, bytes: snapshotBytes, writer });
-        this._conversationJournalBytes += snapshotBytes;
-      }
+      this._conversationJournalQueue.push({ event: snapshot, bytes: snapshotBytes, writer });
+      this._conversationJournalBytes += snapshotBytes;
     } else {
       this._conversationJournalQueue.push({ event, bytes, writer });
       this._conversationJournalBytes += bytes;
     }
     while (this._conversationJournalQueue.length > _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES) {
-      const dropped = this._conversationJournalQueue.shift();
+      const index = this._conversationJournalQueue.findIndex(
+        (queued) => queued.event.type !== "messages_replaced"
+      );
+      if (index === -1) break;
+      const [dropped] = this._conversationJournalQueue.splice(index, 1);
       if (!dropped) break;
       this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - dropped.bytes);
+      this.warnConversationJournalDrop(dropped.event.type);
     }
     this.startConversationJournalDrain();
   }
@@ -5369,6 +5434,12 @@ var Context = class _Context {
   setCurrentKanbanTask(taskId, boardId) {
     this.currentKanbanTaskId = taskId;
     this.currentKanbanBoardId = boardId;
+    const existing = this.meta["kanban"] && typeof this.meta["kanban"] === "object" ? this.meta["kanban"] : {};
+    this.state.setMeta("kanban", {
+      ...existing,
+      ...taskId ? { taskId } : { taskId: void 0 },
+      ...boardId ? { boardId } : { boardId: void 0 }
+    });
   }
   /**
    * Record a comprehensive file event for the audit trail.
@@ -7087,6 +7158,9 @@ ${text}` : text;
         const responseProvider = providerBoundToRequest(req) ?? requestProvider;
         const responseResult = await handlers.response.processResponse(res, req, responseProvider);
         await refreshProviderContextLimit(responseProvider, req.model, { probe: false });
+        if (responseResult.finalText) {
+          a.ctx.meta["lastAgentOutput"] = responseResult.finalText;
+        }
         if (responseResult.aborted) {
           return {
             status: "aborted",
@@ -7211,7 +7285,7 @@ ${text}` : text;
           if (a.ctx.agentId === "leader" && a.tools.get("todo") !== void 0 && hasOpenTodos(a.ctx.todos) && todoReconcileSteers < 2) {
             todoReconcileSteers++;
             queueLoopSteer(
-              "[todo-reconciliation] The live todo/Kanban list still has open work, but you tried to end the turn without reconciling it. Call the `todo` tool now with the complete current list. Mark work you actually finished as completed, put the one item you are actively working on in_progress, and leave the rest pending. If the current item is genuinely unfinished, continue doing the work before answering; do not merely repeat the previous final response or emit <nextsteps>."
+              "[todo-reconciliation] The live todo/Kanban list still has open work, but you tried to end the turn without reconciling it. Call the `todo` tool now with the complete current list. Mark work you actually finished as completed, put the one item you are actively working on in_progress, and leave the rest pending. If the current item is genuinely unfinished, continue doing the work before answering; do not merely repeat the previous final response or emit <nextsteps>.\nCanonical live list:\n" + formatTodosForModel(a.ctx.todos) + (hasKanbanBoundTodos(a.ctx.todos) ? "\nEach <kanban board/task> binding must be resent verbatim as `kanbanBoardId`/`kanbanTaskId`; a row without it is not applied to its card." : "")
             );
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
@@ -7432,12 +7506,15 @@ function buildLiveNextStepsGateBlock(ctx) {
   const todoSnapshot = openTodos.slice(0, MAX_TODO_SNAPSHOT_ITEMS).map((todo) => {
     const normalized = todo.content.replace(/\s+/g, " ").trim();
     const content = normalized.length > MAX_TODO_SNAPSHOT_CONTENT ? `${normalized.slice(0, MAX_TODO_SNAPSHOT_CONTENT - 1)}\u2026` : normalized;
-    return `- [${todo.status}] ${content}`;
+    return formatTodoForModel({ ...todo, content });
   });
   const omitted = openTodos.length - todoSnapshot.length;
   if (omitted > 0) todoSnapshot.push(`- \u2026and ${omitted} more open todo(s)`);
   const todoReconciliation = ctx.tools?.some((tool) => tool.name === "todo") ? [
-    "Before ending the turn, you MUST call the `todo` tool with the complete current list to reconcile actual progress: finished items completed, exactly one actively worked item in_progress, and untouched items pending. A prose claim that work is done does not update the Todo/Kanban state."
+    "Before ending the turn, you MUST call the `todo` tool with the complete current list to reconcile actual progress: finished items completed, exactly one actively worked item in_progress, and untouched items pending. A prose claim that work is done does not update the Todo/Kanban state.",
+    ...hasKanbanBoundTodos(openTodos) ? [
+      "Rows below carry a <kanban board/task> binding. Pass those exact ids back as `kanbanBoardId`/`kanbanTaskId` on every row you resend; a row that arrives without its binding is not applied to its card."
+    ] : []
   ] : [];
   return {
     type: "text",
@@ -8153,6 +8230,7 @@ var Agent = class {
   /** Resolved loop-detector settings (see `tools.loopDetection`). */
   loopDetection;
   autonomousContinue;
+  refreshSystemPrompt;
   tracer;
   extensions;
   _toolHandler;
@@ -8182,6 +8260,7 @@ var Agent = class {
     this.autoExtendLimit = init.autoExtendLimit ?? true;
     this.loopDetection = resolveLoopDetection(init.loopDetection);
     this.autonomousContinue = init.autonomousContinue ?? false;
+    this.refreshSystemPrompt = init.refreshSystemPrompt ?? false;
     this.tracer = init.tracer;
     this.extensions = init.extensions ?? new ExtensionRegistry();
     this._logger = this.container.resolve(TOKENS.Logger).child({ sessionId: this.ctx.session.id });
@@ -8259,6 +8338,7 @@ var Agent = class {
         context: { phase: "concurrency-guard" }
       });
     }
+    let newInputHash;
     const inputText = typeof userInput === "string" ? userInput : userInput?.prompt ?? "";
     if (inputText.length > 0) {
       const hash2 = createHash7("sha256").update(inputText).digest("hex");
@@ -8268,7 +8348,7 @@ var Agent = class {
           iterations: 0
         };
       }
-      this._lastInputHash = hash2;
+      newInputHash = hash2;
     }
     this._runInProgress = true;
     const controller = new RunController({ parentSignal: opts.signal });
@@ -8285,16 +8365,33 @@ var Agent = class {
     });
     this.ctx.tools = this.tools.listForProvider();
     this.ctx.catalogTools = this.tools.list();
-    const span = this.tracer?.startSpan("agent.run", {
-      "agent.model": opts.model ?? this.ctx.model,
-      "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
-    });
-    const { blocks, text } = normalizeInput(userInput);
-    const inputPayload = { content: blocks, text, ctx: this.ctx };
-    await this.extensions.runBeforeRun(this.ctx, inputPayload);
     const runStartedAt = Date.now();
     const runStartedIso = new Date(runStartedAt).toISOString();
+    let span;
     try {
+      if (this.refreshSystemPrompt) {
+        const builder = this.container.safeResolve(TOKENS.SystemPromptBuilder);
+        if (builder) {
+          const onlineAgents = Array.isArray(this.ctx.meta["promptOnlineAgents"]) ? this.ctx.meta["promptOnlineAgents"] : void 0;
+          this.ctx.systemPrompt = await builder.build({
+            cwd: this.ctx.cwd,
+            projectRoot: this.ctx.projectRoot,
+            tools: this.ctx.tools,
+            catalogTools: this.ctx.catalogTools,
+            provider: this.ctx.provider.id,
+            model: opts.model ?? this.ctx.model,
+            onlineAgents
+          });
+        }
+      }
+      span = this.tracer?.startSpan("agent.run", {
+        "agent.model": opts.model ?? this.ctx.model,
+        "agent.executionStrategy": opts.executionStrategy ?? this.executionStrategy
+      });
+      const { blocks, text } = normalizeInput(userInput);
+      const inputPayload = { content: blocks, text, ctx: this.ctx };
+      await this.extensions.runBeforeRun(this.ctx, inputPayload);
+      this._lastInputHash = newInputHash;
       this.events.emit("agent.run.started", {
         sessionId,
         ctx: this.ctx,
@@ -8762,12 +8859,97 @@ var FallbackProfileManager = class {
     return this.resolveRefs([ref], exclude);
   }
   /**
-   * Resolve every usable configured target as an uncapped last-resort chain.
+   * Resolve every usable configured target as a bounded last-resort chain.
    * Normal smart defaults stay bounded; callers append this only after the
-   * preferred chain and only when automatic fallback is enabled.
+   * preferred chain and only when automatic fallback is enabled. The cap
+   * ({@link MAX_LAST_RESORT_CANDIDATES}) prevents a config with many providers
+   * from producing a degenerate chain of doomed requests during a systemic
+   * outage — by this point the smart default, bridge, and default profile
+   * have already failed.
    */
   resolveAllConfigured(exclude) {
-    return this.smartDefault(exclude, Number.POSITIVE_INFINITY);
+    return this.smartDefault(exclude, this.lastResortCap());
+  }
+  /**
+   * Effective cap for the last-resort append. Reads the user-configurable
+   * {@link Config.fallbackMaxLastResortCandidates} when set and valid;
+   * otherwise falls back to the compiled-in default
+   * {@link MAX_LAST_RESORT_CANDIDATES}.
+   */
+  lastResortCap() {
+    const configured = this.config.fallbackMaxLastResortCandidates;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 0) {
+      return Math.floor(configured);
+    }
+    return MAX_LAST_RESORT_CANDIDATES;
+  }
+  /**
+   * Build the complete fallback candidate chain shared by the agent-loop
+   * extension and the one-shot orchestrator. Centralizes the bridge → primary →
+   * selected → default-profile → all-configured ladder and the fromExplicitSource
+   * gate so both consumers produce identical ordering and depth semantics.
+   *
+   * Layering (each step deduped against all prior):
+   *  1. Bridge (emergency continuity route).
+   *  2. Configured primary, when the live context drifted from it.
+   *  3. The selected chain (explicit refs → named profile → smart default),
+   *     via {@link resolveEffective}.
+   *  4. The "default" profile — extra depth, ONLY when the chain was auto-derived.
+   *  5. Every other configured provider — last resort, ONLY when the chain was
+   *     auto-derived AND `effectiveFallbackAuto` is true.
+   *
+   * Returns the empty chain when `closedWorld` is true and no explicit
+   * refs/profile resolved — a model allowlist never leaks to unlisted models.
+   *
+   * @internal caller-aware options (primary, closedWorld) are accepted because
+   *   the agent loop has context the manager does not own; the resolution
+   *   pipeline itself is identical for both callers.
+   */
+  resolveCandidates(current, opts = {}) {
+    const configuredPrimary = opts.primary ?? {
+      providerId: this.config.provider,
+      model: this.config.model
+    };
+    const configFallbackAuto = this.config.fallbackAuto;
+    const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
+    const explicitRefs = opts.fallbackModels ?? this.config.fallbackModels;
+    const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && this.resolveRefs(explicitRefs, current).length > 0;
+    const profileUsable = opts.fallbackProfile !== void 0 && this.hasProfile(opts.fallbackProfile) && this.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
+    const fromExplicitSource = explicitUsable || profileUsable;
+    const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? this.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? this.resolve(opts.fallbackProfile, { exclude: current }) : FREEZER_EMPTY : this.resolveEffective({
+      fallbackModels: explicitRefs,
+      fallbackProfile: opts.fallbackProfile,
+      fallbackAuto: effectiveFallbackAuto,
+      exclude: current
+    });
+    const candidates = [];
+    if (opts.closedWorld) {
+      candidates.push(...selectedChain);
+    } else {
+      candidates.push(...this.resolveBridge(current));
+      if (!(configuredPrimary.providerId === current.providerId && configuredPrimary.model === current.model)) {
+        candidates.push({
+          providerId: configuredPrimary.providerId,
+          model: configuredPrimary.model,
+          providerSwitched: configuredPrimary.providerId !== current.providerId
+        });
+      }
+      candidates.push(...selectedChain);
+      if (!fromExplicitSource && effectiveFallbackAuto && opts.fallbackProfile !== "default") {
+        candidates.push(...this.resolve("default", { exclude: current }));
+      }
+      if (!fromExplicitSource && effectiveFallbackAuto) {
+        const cap = this.lastResortCap();
+        if (cap > 0) {
+          const usedKeys = new Set(
+            candidates.map((c) => `${c.providerId}/${c.model}`)
+          );
+          const lastResort = this.smartDefault(current, Number.POSITIVE_INFINITY).filter((c) => !usedKeys.has(`${c.providerId}/${c.model}`)).slice(0, cap);
+          candidates.push(...lastResort);
+        }
+      }
+    }
+    return dedupeChain(candidates, current);
   }
   // ── Provider availability (read-only) ──────────────────────────────────
   checkProvider(providerId) {
@@ -8891,7 +9073,20 @@ var FallbackProfileManager = class {
     );
   }
 };
+var MAX_LAST_RESORT_CANDIDATES = 12;
 var FREEZER_EMPTY = Object.freeze([]);
+function dedupeChain(entries, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const currentKey = `${current.providerId}/${current.model}`;
+  return Object.freeze(
+    entries.filter((entry) => {
+      const key = `${entry.providerId}/${entry.model}`;
+      if (key === currentKey || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    })
+  );
+}
 
 // src/core/fallback-model.ts
 function fallbackProfileChain(config, profileName) {
@@ -8940,56 +9135,12 @@ function sameTarget(a, b) {
 }
 function fallbackCandidates(config, current, opts = {}) {
   const mgr = opts.sharedManager ?? new FallbackProfileManager(config);
-  const configuredPrimary = opts.primary ?? primaryTarget(config);
-  const configFallbackAuto = config.fallbackAuto;
-  const effectiveFallbackAuto = configFallbackAuto !== void 0 && configFallbackAuto !== null ? configFallbackAuto : !opts.closedWorld;
-  const explicitRefs = opts.fallbackModels ?? config.fallbackModels;
-  const explicitUsable = explicitRefs !== void 0 && explicitRefs.length > 0 && mgr.resolveRefs(explicitRefs, current).length > 0;
-  const profileUsable = opts.fallbackProfile !== void 0 && mgr.hasProfile(opts.fallbackProfile) && mgr.resolve(opts.fallbackProfile, { exclude: current }).length > 0;
-  const fromExplicitSource = explicitUsable || profileUsable;
-  const selectedChain = opts.closedWorld ? explicitRefs && explicitRefs.length > 0 ? mgr.resolveRefs(explicitRefs, current) : opts.fallbackProfile ? mgr.resolve(opts.fallbackProfile, { exclude: current }) : Object.freeze([]) : mgr.resolveEffective({
-    fallbackModels: explicitRefs,
+  return mgr.resolveCandidates(current, {
+    fallbackModels: opts.fallbackModels,
     fallbackProfile: opts.fallbackProfile,
-    fallbackAuto: effectiveFallbackAuto,
-    exclude: current
+    primary: opts.primary ?? primaryTarget(config),
+    closedWorld: opts.closedWorld
   });
-  const candidates = [];
-  if (opts.closedWorld) {
-    candidates.push(...selectedChain);
-    const seen2 = /* @__PURE__ */ new Set();
-    return Object.freeze(
-      candidates.filter((entry) => {
-        const key = `${entry.providerId}/${entry.model}`;
-        if (key === `${current.providerId}/${current.model}` || seen2.has(key)) return false;
-        seen2.add(key);
-        return true;
-      })
-    );
-  }
-  candidates.push(...mgr.resolveBridge(current));
-  if (!sameTarget(configuredPrimary, current)) {
-    candidates.push({
-      providerId: configuredPrimary.providerId,
-      model: configuredPrimary.model,
-      providerSwitched: configuredPrimary.providerId !== current.providerId
-    });
-  }
-  candidates.push(...selectedChain);
-  if (!fromExplicitSource && opts.fallbackProfile !== "default") {
-    candidates.push(...mgr.resolve("default", { exclude: current }));
-  }
-  if (!fromExplicitSource && effectiveFallbackAuto) {
-    candidates.push(...mgr.resolveAllConfigured(current));
-  }
-  const seen = /* @__PURE__ */ new Set();
-  return Object.freeze(
-    candidates.filter((entry) => {
-      const key = `${entry.providerId}/${entry.model}`;
-      if (key === `${current.providerId}/${current.model}` || seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    })
-  );
 }
 var primaryTarget = (cfg) => ({ providerId: cfg.provider, model: cfg.model });
 function maxContextOf(provider) {
@@ -10491,7 +10642,7 @@ async function buildEnvironment(ctx, env) {
   ]);
   const tier = env.tier;
   const lines = ["## Environment"];
-  if (tier === "minimal") {
+  if (tier === "minimal" || tier === "aggressive") {
     lines.push(`- Git: ${git} | Date: ${today}`);
   } else {
     lines.push(`- Operating system: ${platform2}`);
@@ -10499,38 +10650,26 @@ async function buildEnvironment(ctx, env) {
       lines.push(`- Shell: ${shell}`);
       lines.push(`- Node.js: ${node}`);
     }
-    if (tier === "off" || tier === "medium" || tier === "aggressive") {
+    if (tier === "off" || tier === "medium") {
       lines.push(`- Detected languages: ${langs}`);
     }
     lines.push(`- Git status: ${git}`);
     lines.push(`- Today's date: ${today}`);
-    if (tier === "aggressive") {
-      if (ctx.provider || ctx.model) {
-        lines.push(
-          `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
-        );
-      }
-      if (modelCapabilities) {
-        lines.push(
-          `- Context window: ${modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
-        );
-      }
-    }
-    if (tier !== "aggressive" && modelCapabilities) {
+    if (modelCapabilities) {
       lines.push(
         `- Context window: ${modelCapabilities.maxContextTokens.toLocaleString()} tokens max`
       );
     }
-    if (tier !== "aggressive" && (ctx.provider || ctx.model)) {
+    if (ctx.provider || ctx.model) {
       lines.push(
         `- Running on: ${ctx.provider ?? "<unknown provider>"}/${ctx.model ?? "<unknown model>"}`
       );
     }
-    if (tier !== "aggressive" && env.modeId && env.modeId !== "default") {
+    if (env.modeId && env.modeId !== "default") {
       lines.push(`- Mode: ${env.modeId}`);
     }
   }
-  if (ctx.tools.some((tool) => tool.name === "bash") && effShell !== "posix" && tier !== "minimal") {
+  if (ctx.tools.some((tool) => tool.name === "bash") && effShell !== "posix" && tier !== "minimal" && tier !== "aggressive") {
     const guide = shellGuidanceBlock(effShell, tier === "light" ? "short" : "full");
     if (guide) lines.push("", guide);
   }
@@ -10553,6 +10692,70 @@ async function buildEnvironment(ctx, env) {
   return text;
 }
 
+// src/core/system-prompt-glossary.ts
+function findDomainGlossaryEntries(memory) {
+  return safeList(memory, { limit: 200 }).then((rows) => rows ?? []).then(
+    (rows) => rows.filter(
+      (r) => Array.isArray(r?.tags) && r.tags.includes("domain-term")
+    )
+  );
+}
+async function safeList(memory, opts) {
+  try {
+    const rows = await memory.list("project-memory", opts.limit);
+    if (!Array.isArray(rows) || rows.length === 0) return null;
+    return rows;
+  } catch {
+    return null;
+  }
+}
+var GLOSSARY_HEADING = "# Project Jargon Dictionary (auto-mined from SAGE; update via SageDomainTermExtractor)";
+async function renderDomainGlossary(ctx, memory, options = {}) {
+  if (!memory) return null;
+  const maxEntries = options.maxEntries ?? 12;
+  const maxEntryChars = options.maxEntryChars ?? 80;
+  const entries = await findDomainGlossaryEntries(memory);
+  if (entries.length === 0) return "";
+  const sorted = [...entries].sort((a, b) => {
+    const dc = (b.confidence ?? 0) - (a.confidence ?? 0);
+    if (dc !== 0) return dc;
+    return b.ts.localeCompare(a.ts);
+  });
+  const lines = [GLOSSARY_HEADING, ""];
+  let emitted = 0;
+  for (const entry of sorted) {
+    if (emitted >= maxEntries) break;
+    const { term, definition } = parseTermEntry(entry.text);
+    if (!term) continue;
+    const def = (definition || "").slice(0, maxEntryChars).trim();
+    lines.push(def ? `- **${term}** \u2014 ${def}` : `- **${term}**`);
+    emitted += 1;
+  }
+  if (emitted === 0) return "";
+  lines.push("");
+  lines.push(
+    `_Source: <${ctx.projectRoot}>/.wrongstack/domain-terms.md (auto-generated; do not edit by hand)._`
+  );
+  lines.push(
+    '_Lookup tag: `domain-term` (search: `memory_search({ query: "domain-term", scope: "project-memory" })`)._'
+  );
+  return lines.join("\n");
+}
+function parseTermEntry(text) {
+  const trimmed = text.trim();
+  const separators = [" \u2014 ", " \u2013 ", " - ", " -- "];
+  for (const sep of separators) {
+    const idx = trimmed.indexOf(sep);
+    if (idx > 0) {
+      return {
+        term: trimmed.slice(0, idx).trim(),
+        definition: trimmed.slice(idx + sep.length).trim()
+      };
+    }
+  }
+  return { term: trimmed, definition: "" };
+}
+
 // src/skills/limits.ts
 var SKILL_LIMITS = {
   /**
@@ -10819,7 +11022,7 @@ function renderOnlineAgents(agents, tier, cache) {
     return { text: cache.text, cache };
   }
   const totalCount = agents.length;
-  if (tier === "minimal" || tier === "light") {
+  if (tier === "minimal" || tier === "light" || tier === "aggressive") {
     const text2 = ` (${totalCount} agent${totalCount !== 1 ? "s" : ""} online)`;
     return { text: text2, cache: { hash: hash2, text: text2 } };
   }
@@ -10844,8 +11047,8 @@ ${agentList}`;
 async function buildMemoryAndSkills(mem) {
   const parts = [];
   let skillBodyCache = mem.skillBodyCache;
-  const memoryCount = mem.tier === "minimal" || mem.tier === "light" ? 3 : 5;
-  const compactMemory = mem.tier === "minimal";
+  const memoryCount = mem.tier === "minimal" || mem.tier === "light" || mem.tier === "aggressive" ? 3 : 5;
+  const compactMemory = mem.tier === "minimal" || mem.tier === "aggressive";
   if (mem.memoryStore && mem.injectMemory !== false) {
     try {
       if (mem.memoryStore.scoreRelevant) {
@@ -11026,7 +11229,7 @@ var DefaultSystemPromptBuilder = class {
   }
   /**
    * Returns the max tool description length for the current tier.
-   * Per the design doc: off=80, minimal=40, light=50, medium=60, aggressive=70.
+   * The aggressive tier has the shortest descriptions; off keeps the most detail.
    */
   toolDescLimit() {
     switch (this.tier) {
@@ -11037,7 +11240,7 @@ var DefaultSystemPromptBuilder = class {
       case "medium":
         return 50;
       case "aggressive":
-        return 60;
+        return 20;
       default:
         return 70;
     }
@@ -11149,6 +11352,12 @@ var DefaultSystemPromptBuilder = class {
         }
       }
     }
+    if (this.opts.domainGlossary) {
+      const glossary = await renderDomainGlossary(ctx, this.opts.domainGlossary);
+      if (glossary) {
+        volatile.push(tagBlock({ type: "text", text: glossary }, "glossary"));
+      }
+    }
     if (!ctx.subagent) {
       session.push(
         tagBlock(
@@ -11306,8 +11515,8 @@ ${hint.trim()}`);
         return Array.isArray(role) ? role.filter((r) => typeof r === "string") : [];
       })();
       const roleList = enumValues.length > 0 ? enumValues.join(", ") : "(no roster configured)";
-      if (this.tier === "minimal") {
-      } else if (this.tier === "light" || this.tier === "medium" || this.tier === "aggressive") {
+      if (this.tier === "minimal" || this.tier === "aggressive") {
+      } else if (this.tier === "light" || this.tier === "medium") {
         const delegation = section("tool.delegation.compact", {
           roleList
         });
@@ -11343,7 +11552,7 @@ ${hint.trim()}`);
       }
     }
     const hasGitTool = tools.some((t2) => t2.name === "git");
-    if (hasGitTool && this.tier !== "minimal" && this.tier !== "light") {
+    if (hasGitTool && this.tier !== "minimal" && this.tier !== "light" && this.tier !== "aggressive") {
       const commitHygiene = section("tool.commit.hygiene");
       if (commitHygiene) lines.push(commitHygiene);
     }
@@ -11360,7 +11569,7 @@ ${hint.trim()}`);
     }
     const hasContextManager = tools.some((t2) => t2.name === "context_manager");
     if (hasContextManager) {
-      if (this.tier === "minimal" || this.tier === "light") {
+      if (this.tier === "minimal" || this.tier === "light" || this.tier === "aggressive") {
       } else if (this.tier === "medium") {
         const contextManagement = section("tool.context.management.compact");
         if (contextManagement) lines.push(contextManagement);
@@ -11413,11 +11622,11 @@ ${hint.trim()}`);
     return result.text;
   }
   async buildMode() {
-    if (this.opts.modePrompt) return this.opts.modePrompt;
-    if (!this.opts.modeStore) return "";
-    const mode = await this.opts.modeStore.getActiveMode();
-    if (!mode?.prompt) return "";
-    return mode.prompt;
+    if (this.opts.modeStore) {
+      const mode = await this.opts.modeStore.getActiveMode();
+      if (mode?.prompt) return mode.prompt;
+    }
+    return this.opts.modePrompt ?? "";
   }
 };
 export {