@wrongstack/core 0.273.0 → 0.273.1

package/dist/index.js

@@ -8260,6 +8260,34 @@ var DefaultSessionReader = class {
       ids = filtered.map((s) => s.id);
     }
     const hits = [];
+    const streaming = this.store.searchEvents?.bind(this.store);
+    if (streaming) {
+      for (const id of ids) {
+        const matched = await streaming(
+          id,
+          (ev) => {
+            if (allowedTypes && !allowedTypes.has(ev.type)) return false;
+            const text = eventText(ev);
+            if (text === null) return false;
+            return matcher(text) !== null;
+          },
+          { limit: limit - hits.length }
+        );
+        for (const m of matched) {
+          const text = expectDefined(eventText(m.event));
+          const hit = expectDefined(matcher(text));
+          hits.push({
+            sessionId: id,
+            eventIndex: m.eventIndex,
+            ts: m.ts,
+            type: m.event.type,
+            snippet: snippetOf(text, hit.start, hit.end)
+          });
+          if (hits.length >= limit) return hits;
+        }
+      }
+      return hits;
+    }
     for (const id of ids) {
       let data;
       try {
@@ -8798,6 +8826,91 @@ var DefaultSessionStore = class _DefaultSessionStore {
       }
     }
   }
+  /**
+   * Streaming search over a session's JSONL. Walks the file once, parses
+   * each event lazily, and yields only the events that match `predicate`.
+   * Stops as soon as `opts.limit` matches are collected.
+   *
+   * Why this exists: `load()` parses the entire file into memory and
+   * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
+   * needs to know which events contain matching text — a per-line
+   * predicate is enough. The full parse work (and the `_loadCache` poll)
+   * is wasted in that case.
+   *
+   * Memory: O(hits) regardless of file size. Disk: one linear scan,
+   * terminated at `limit` if the caller asked for one.
+   *
+   * Errors: missing file yields []. Corrupt lines are skipped (same
+   * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
+   */
+  async searchEvents(id, predicate, opts) {
+    const file = this.sessionPath(id, ".jsonl");
+    const limit = opts?.limit;
+    const signal = opts?.signal;
+    const out = [];
+    let stat16;
+    try {
+      stat16 = await fsp3.stat(file);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    if (stat16.size === 0) return [];
+    let fh;
+    try {
+      fh = await fsp3.open(file, "r");
+      const CHUNK = 64 * 1024;
+      const buf = Buffer.alloc(CHUNK);
+      let leftover = "";
+      let eventIndex = 0;
+      for (let position = 0; ; position += buf.byteLength) {
+        if (signal?.aborted) {
+          const reason = signal.reason ?? new DOMException("Aborted", "AbortError");
+          throw reason;
+        }
+        const { bytesRead } = await fh.read(buf, 0, CHUNK, position);
+        if (bytesRead === 0) break;
+        const text = leftover + buf.subarray(0, bytesRead).toString("utf8");
+        const parts = text.split("\n");
+        leftover = parts.pop() ?? "";
+        for (const line of parts) {
+          if (!line) continue;
+          let ev;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed === null || typeof parsed !== "object" || typeof parsed.type !== "string" || typeof parsed.ts !== "string") {
+              continue;
+            }
+            ev = parsed;
+          } catch {
+            continue;
+          }
+          if (predicate(ev, eventIndex, ev.ts)) {
+            out.push({ event: ev, eventIndex, ts: ev.ts });
+            if (limit !== void 0 && out.length >= limit) {
+              return out;
+            }
+          }
+          eventIndex++;
+        }
+      }
+      if (leftover.trim()) {
+        try {
+          const parsed = JSON.parse(leftover);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            const ev = parsed;
+            if (predicate(ev, eventIndex, ev.ts)) {
+              out.push({ event: ev, eventIndex, ts: ev.ts });
+            }
+          }
+        } catch {
+        }
+      }
+      return out;
+    } finally {
+      if (fh) await fh.close().catch(() => void 0);
+    }
+  }
   async list(limit = 20) {
     try {
       await ensureDir(this.dir);
@@ -11139,7 +11252,8 @@ var BEHAVIOR_DEFAULTS = {
     hardThreshold: 0.9,
     autoCompact: true,
     preserveK: DEFAULT_CONTEXT_CONFIG.preserveK,
-    eliseThreshold: DEFAULT_CONTEXT_CONFIG.eliseThreshold
+    eliseThreshold: DEFAULT_CONTEXT_CONFIG.eliseThreshold,
+    strategy: "hybrid"
   },
   tools: {
     defaultExecutionStrategy: DEFAULT_TOOLS_CONFIG.defaultExecutionStrategy,
@@ -11162,6 +11276,13 @@ var BEHAVIOR_DEFAULTS = {
     allowOutsideProjectRoot: true
   },
   mcpServers: {},
+  fallbackAuto: true,
+  maxConcurrent: 4,
+  yolo: false,
+  nextPrediction: false,
+  hints: true,
+  debugStream: false,
+  configScope: "global",
   indexing: {
     onSessionStart: true,
     onEdit: true,
@@ -11169,8 +11290,55 @@ var BEHAVIOR_DEFAULTS = {
     debounceMs: 400
   },
   session: { ...DEFAULT_SESSION_LOGGING_CONFIG },
-  autonomy: { autoProceedDelayMs: DEFAULT_AUTONOMY_CONFIG.autoProceedDelayMs }
+  autonomy: {
+    defaultMode: "off",
+    autoProceedDelayMs: DEFAULT_AUTONOMY_CONFIG.autoProceedDelayMs,
+    autoProceedMaxIterations: 50,
+    autonomyNextPrompt: "auto {{suggestion}}",
+    terminalTitleAnimation: true,
+    yolo: false,
+    streamFleet: true,
+    chime: false,
+    confirmExit: true,
+    mouseMode: false,
+    enhance: true,
+    enhanceDelayMs: 6e4,
+    enhanceLanguage: "original",
+    statuslineMode: "detailed",
+    thinkingWord: DEFAULT_TUI_THINKING_WORD
+  },
+  circuitBreaker: { ...DEFAULT_CIRCUIT_BREAKER_CONFIG },
+  modelRuntime: {
+    reasoning: { mode: "auto", effort: "high", preserve: false },
+    cache: {}
+  }
 };
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneJsonValue(value) {
+  return structuredClone(value);
+}
+function fillMissingDefaults(target, defaults) {
+  const value = cloneJsonValue(target);
+  const changed = fillMissingDefaultsInPlace(value, defaults);
+  return { value, changed };
+}
+function fillMissingDefaultsInPlace(target, defaults) {
+  let changed = false;
+  for (const [key, defaultValue] of Object.entries(defaults)) {
+    if (!Object.prototype.hasOwnProperty.call(target, key)) {
+      target[key] = cloneJsonValue(defaultValue);
+      changed = true;
+      continue;
+    }
+    const current = target[key];
+    if (isPlainRecord(current) && isPlainRecord(defaultValue)) {
+      changed = fillMissingDefaultsInPlace(current, defaultValue) || changed;
+    }
+  }
+  return changed;
+}
 function envBool(v) {
   return !/^(0|false|no|off)$/i.test(v.trim());
 }
@@ -11222,27 +11390,139 @@ var defaultIndexing = {
   watchExternal: true,
   debounceMs: 400
 };
-var IN_PROJECT_FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "version",
+  "model",
+  "cwd",
+  "context",
+  "tools",
+  "features",
+  "autonomy",
+  "indexing",
+  "session",
+  "log",
+  "launch",
+  "nextPrediction",
+  "hints",
+  "debugStream",
+  "configScope",
+  "maxConcurrent",
+  "fallbackModels",
+  "fallbackAuto",
+  "models",
+  "modelMatrix",
+  "circuitBreaker",
+  "adaptiveConcurrency",
+  "modelRuntime"
+]);
+var KNOWN_DENIED_IN_PROJECT = [
+  { key: "provider", reason: "Provider id override; can intercept prompts/responses." },
+  { key: "apiKey", reason: "Overrides user API key; exfiltrates prompts." },
+  { key: "baseUrl", reason: "Redirects provider endpoint; leaks real API key." },
+  { key: "providers", reason: "Per-provider apiKey/baseUrl/oauthConfig; same redirect/exfil." },
+  { key: "mcpServers", reason: "Arbitrary command/args/env spawned at boot (RCE)." },
+  { key: "hooks", reason: "Shell command arrays on lifecycle events (RCE)." },
+  { key: "plugins", reason: "Dynamic npm package load at boot (RCE)." },
+  { key: "sync", reason: "Carries githubToken credential and target repo." },
+  { key: "yolo", reason: "Disables all permission confirmation prompts." },
+  { key: "extensions", reason: "Per-plugin config can carry command/credential fields." },
+  { key: "hq", reason: "Carries HQ client token credential and endpoint URL." }
+];
+var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "version",
   "provider",
+  "model",
   "apiKey",
   "baseUrl",
+  "maxConcurrent",
   "providers",
+  "models",
+  "modelMatrix",
+  "context",
+  "tools",
   "mcpServers",
+  "fallbackModels",
+  "fallbackAuto",
   "hooks",
   "plugins",
-  "sync",
+  "log",
+  "features",
   "yolo",
+  "nextPrediction",
+  "cwd",
+  "autonomy",
+  "hints",
+  "debugStream",
+  "configScope",
+  "indexing",
+  "circuitBreaker",
+  "adaptiveConcurrency",
+  "launch",
+  "session",
+  "modelRuntime",
+  "hq",
+  "sync",
   "extensions"
 ]);
+function assertInProjectAllowListComplete() {
+  const missingFromBoth = [];
+  for (const key of KNOWN_CONFIG_TOP_LEVEL_KEYS) {
+    if (IN_PROJECT_ALLOWED_KEYS.has(key)) continue;
+    const denied = KNOWN_DENIED_IN_PROJECT.find((d) => d.key === key);
+    if (!denied) missingFromBoth.push(key);
+  }
+  const staleDenials = KNOWN_DENIED_IN_PROJECT.filter((d) => !KNOWN_CONFIG_TOP_LEVEL_KEYS.has(d.key)).map((d) => d.key);
+  const duplicate = KNOWN_DENIED_IN_PROJECT.filter((d) => IN_PROJECT_ALLOWED_KEYS.has(d.key)).map((d) => d.key);
+  const problems = [];
+  if (missingFromBoth.length > 0) {
+    problems.push(
+      `new Config field(s) not classified as allowed or denied for in-project config: ` + missingFromBoth.join(", ") + ". Add each to IN_PROJECT_ALLOWED_KEYS (if safe) or KNOWN_DENIED_IN_PROJECT (with a reason)."
+    );
+  }
+  if (staleDenials.length > 0) {
+    problems.push(
+      `KNOWN_DENIED_IN_PROJECT references keys that no longer exist on Config: ` + staleDenials.join(", ") + ". Remove them or restore the field on Config."
+    );
+  }
+  if (duplicate.length > 0) {
+    problems.push(
+      `field(s) appear in BOTH IN_PROJECT_ALLOWED_KEYS and KNOWN_DENIED_IN_PROJECT: ` + duplicate.join(", ") + ". The allow-list wins at runtime; remove from one of the two."
+    );
+  }
+  if (problems.length > 0) {
+    throw new Error(
+      `stripUnsafeInProjectFields drift check failed:
+  - ${problems.join("\n  - ")}`
+    );
+  }
+}
+var driftChecked = false;
 function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => console.warn(msg)) {
+  if (!driftChecked) {
+    assertInProjectAllowListComplete();
+    driftChecked = true;
+  }
   const stripped = [];
   const out = {};
   for (const [k, v] of Object.entries(inProject)) {
-    if (IN_PROJECT_FORBIDDEN_KEYS.has(k)) {
-      stripped.push(k);
+    if (IN_PROJECT_ALLOWED_KEYS.has(k)) {
+      out[k] = v;
       continue;
     }
-    out[k] = v;
+    stripped.push(k);
+  }
+  const outTools = out["tools"];
+  if (outTools && typeof outTools === "object") {
+    const execCfg = outTools["exec"];
+    if (execCfg && typeof execCfg === "object" && "allow" in execCfg) {
+      const clonedExec = { ...execCfg };
+      delete clonedExec["allow"];
+      out["tools"] = {
+        ...outTools,
+        exec: clonedExec
+      };
+      stripped.push("tools.exec.allow");
+    }
   }
   if (stripped.length > 0) {
     warn(
@@ -11251,7 +11531,7 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
         event: "config.in_project_unsafe_fields_ignored",
         path: sourcePath,
         ignoredKeys: stripped,
-        message: `Ignored ${stripped.length} unsafe field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. These can only be set in your personal ~/.wrongstack/config.json, not in a project-committed file.`,
+        message: `Ignored ${stripped.length} field(s) from the repo-committed config "${sourcePath}": ${stripped.join(", ")}. Only a small allow-list of benign preferences (model, context, tools limits, features, \u2026) may be set by <project>/.wrongstack/config.json. Everything else must live in your personal ~/.wrongstack/config.json.`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       })
     );
@@ -11295,6 +11575,7 @@ var DefaultConfigLoader = class {
   }
   async load(opts = {}) {
     let cfg = { ...BEHAVIOR_DEFAULTS };
+    await this.ensureGlobalDefaults();
     const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
     const [global, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
@@ -11359,6 +11640,80 @@ var DefaultConfigLoader = class {
     }
     return Object.freeze(cfg);
   }
+  async ensureGlobalDefaults() {
+    const fp = this.paths.globalConfig;
+    const t0 = Date.now();
+    try {
+      await withFileLock(fp, async () => {
+        let parsed;
+        try {
+          const raw = await fsp3.readFile(fp, "utf8");
+          const result = safeParse(raw);
+          if (!result.ok || !isPlainRecord(result.value)) {
+            return;
+          }
+          parsed = result.value;
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            this.events?.emit("storage.error", {
+              sessionId: "~config~",
+              store: "config",
+              filePath: fp,
+              operation: "ensure_defaults",
+              outcome: "failure",
+              error: storageErrorString(err),
+              recoverable: false,
+              durationMs: Date.now() - t0,
+              ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+            });
+            console.warn(JSON.stringify({
+              level: "warn",
+              event: "config.defaults_read_failed",
+              path: fp,
+              message: toErrorMessage(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }));
+            return;
+          }
+          parsed = {};
+        }
+        const { value, changed } = fillMissingDefaults(
+          parsed,
+          BEHAVIOR_DEFAULTS
+        );
+        if (!changed) return;
+        await atomicWrite(fp, JSON.stringify(value, null, 2), { mode: 384 });
+        this.events?.emit("storage.write", {
+          sessionId: "~config~",
+          store: "config",
+          filePath: fp,
+          operation: "ensure_defaults",
+          outcome: "success",
+          durationMs: Date.now() - t0,
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
+      });
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "ensure_defaults",
+        outcome: "failure",
+        error: storageErrorString(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "config.defaults_write_failed",
+        path: fp,
+        message: toErrorMessage(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    }
+  }
   /**
    * Persist a sync config to ~/.wrongstack/sync.json, with the token encrypted
    * by the vault (if provided). The file is isolated from the main config
@@ -14395,6 +14750,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         level,
         tokens,
         load,
+        hardThreshold: adaptiveThresholds.hard,
         budget,
         signals: { repeatedReadCount: repetition }
       });
@@ -14442,6 +14798,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     }
   }
   async compact(ctx, aggressive, pressure) {
+    let postCompactionOverflow = null;
     try {
       const report = await this.compactor.compact(ctx, { aggressive });
       this.recordAttempt(pressure.level, pressure.tokens, report);
@@ -14471,6 +14828,38 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         ...report.collapsedDigest ? { digest: truncateDigest(report.collapsedDigest) } : {}
       });
       ctx.clearFileTracking();
+      const afterTokens = report.fullRequestTokensAfter ?? report.after;
+      const afterLoad = this._maxContext > 0 ? afterTokens / this._maxContext : 0;
+      const stillHard = afterLoad >= pressure.hardThreshold;
+      const fatal = stillHard && (this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard");
+      if (stillHard) {
+        const error = new Error(
+          `Auto-compaction left context above the hard threshold after ${pressure.level} compaction`
+        );
+        this.events?.emit("compaction.failed", {
+          err: error,
+          aggressive,
+          level: pressure.level,
+          tokens: afterTokens,
+          maxContext: this._maxContext,
+          budget: computeContextWindowBudget(ctx, afterTokens, this._maxContext),
+          signals: pressure.signals,
+          load: afterLoad,
+          fatal
+        });
+        if (fatal) {
+          postCompactionOverflow = new AgentError({
+            message: `Auto-compaction did not reduce context below hard threshold`,
+            code: ERROR_CODES.AGENT_CONTEXT_OVERFLOW,
+            recoverable: true,
+            context: {
+              level: pressure.level,
+              tokens: afterTokens,
+              maxContext: this._maxContext
+            }
+          });
+        }
+      }
     } 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";
@@ -14499,6 +14888,7 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         });
       }
     }
+    if (postCompactionOverflow) throw postCompactionOverflow;
   }
 };
 function computeContextWindowBudget(ctx, inputTokens, maxContext) {
@@ -32905,6 +33295,10 @@ var AGENT_REAP_MS = 3e4;
 var AGENT_SWEEP_INTERVAL_MS = 1e4;
 var PARTIAL_TEXT_CAP = 1200;
 var PARTIAL_FLUSH_THROTTLE_MS = 300;
+function clampPct(pct) {
+  if (!Number.isFinite(pct)) return 0;
+  return Math.max(0, Math.min(100, pct));
+}
 var AgentStatusTracker = class {
   events;
   registry;
@@ -33056,7 +33450,7 @@ var AgentStatusTracker = class {
       this.events.onPattern("ctx.pct", (_e, payload) => {
         const p = payload;
         if (typeof p?.load === "number" && Number.isFinite(p.load)) {
-          this.leaderCtxPct = Math.round(p.load * 100);
+          this.leaderCtxPct = clampPct(Math.round(p.load * 100));
           this.flush();
         }
       })
@@ -33098,7 +33492,7 @@ var AgentStatusTracker = class {
         const p = payload;
         if (!p?.subagentId) return;
         const entry = touch(p.subagentId);
-        if (typeof p.load === "number") entry.ctxPct = Math.round(p.load * 100);
+        if (typeof p.load === "number") entry.ctxPct = clampPct(Math.round(p.load * 100));
         this.flush();
       })
     );
@@ -33259,7 +33653,7 @@ var AgentStatusTracker = class {
     const providerMax = c.provider?.capabilities?.maxContext;
     const maxContext = typeof metaLimit === "number" && metaLimit > 0 ? metaLimit : typeof providerMax === "number" && providerMax > 0 ? providerMax : void 0;
     if (typeof c.lastRequestTokens === "number" && c.lastRequestTokens > 0 && maxContext !== void 0) {
-      this.leaderCtxPct = Math.round(c.lastRequestTokens / maxContext * 100);
+      this.leaderCtxPct = clampPct(Math.round(c.lastRequestTokens / maxContext * 100));
     }
   }
 };
@@ -38647,6 +39041,9 @@ var DefaultMailbox = class {
     await withFileLock(this.filePath, async () => {
       await fsp3.appendFile(this.filePath, line, "utf8");
       this._pushToCache(msg);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._messageCacheMtime = mtime;
+      this._messageCacheSize = size;
     });
     return msg;
   }
@@ -38725,7 +39122,8 @@ var DefaultMailbox = class {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
         await fsp3.writeFile(this.filePath, serialized, "utf8");
       }
-      this._setMessageCache(all);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache(all, mtime, size);
     });
     return updated;
   }
@@ -38782,7 +39180,8 @@ var DefaultMailbox = class {
   async clearAll() {
     await withFileLock(this.filePath, async () => {
       await fsp3.writeFile(this.filePath, "", "utf8");
-      this._setMessageCache([]);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache([], mtime, size);
     });
   }
   async purgeStale(opts) {
@@ -38815,7 +39214,8 @@ var DefaultMailbox = class {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
         await fsp3.writeFile(this.filePath, content, "utf8");
       }
-      this._setMessageCache(kept);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache(kept, mtime, size);
     });
     return {
       completedPurged,
@@ -38894,6 +39294,23 @@ var DefaultMailbox = class {
     }
     return messages;
   }
+  /**
+   * Stat the mailbox file under the assumption that we are holding the
+   * file lock, and that a write to the file has just completed. Returns
+   * the (mtimeMs, size) pair, or (-1, -1) if the file does not exist
+   * (e.g. ackMany/purgeStale on a session that has never sent a message).
+   */
+  async _statUnderLockOrAbsent() {
+    try {
+      const st = await fsp3.stat(this.filePath);
+      return { mtime: st.mtimeMs, size: st.size };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { mtime: -1, size: -1 };
+      }
+      throw err;
+    }
+  }
   async _readAllCached() {
     try {
       const st = await fsp3.stat(this.filePath);
@@ -38933,16 +39350,8 @@ var DefaultMailbox = class {
     }
     this._messageCache = messages;
     this._buildIndexes(messages);
-    if (mtime !== void 0 && size !== void 0) {
-      this._messageCacheMtime = mtime;
-      this._messageCacheSize = size;
-      return;
-    }
-    void fsp3.stat(this.filePath).then((st) => {
-      this._messageCacheMtime = st.mtimeMs;
-      this._messageCacheSize = st.size;
-    }).catch(() => {
-    });
+    this._messageCacheMtime = mtime;
+    this._messageCacheSize = size;
   }
   _pushToCache(msg) {
     if (this._messageCache === null) return;
@@ -44009,17 +44418,71 @@ function createAgentLoopHandler(a, handlers) {
     const msgCount = a.ctx.messages.length;
     const maxContext = currentMaxContext();
     if (_lastCompactionMsgCount === msgCount && _lastCompactionWasNoop && _lastCompactionMaxContext === maxContext && maxContext > 0) {
-      return;
+      return false;
     }
+    const beforeMessages = a.ctx.messages;
+    const beforeMsgCount = a.ctx.messages.length;
     await a.pipelines.contextWindow.run(a.ctx);
-    _lastCompactionMsgCount = msgCount;
+    _lastCompactionMsgCount = a.ctx.messages.length;
     _lastCompactionMaxContext = maxContext;
-    const stashed = a.ctx.lastRequestTokens;
-    const tokens = typeof stashed === "number" && stashed > 0 ? stashed : 0;
+    const changed = a.ctx.messages !== beforeMessages || a.ctx.messages.length !== beforeMsgCount;
+    const tokens = refreshContextRequestTokenStash({ force: changed });
     const load = maxContext > 0 ? tokens / maxContext : 0;
     _lastCompactionWasNoop = tokens > 0 && load < 0.5;
+    if (changed) {
+      _lastEmittedMsgCount = -1;
+      _lastEmittedToolCount = -1;
+      _lastEmittedMaxContext = -1;
+    }
+    return changed;
   }
   const calibrationKey = (model = a.ctx.model) => `${a.ctx.provider?.id ?? "unknown"}/${model}`;
+  function stashRequestTokens(req) {
+    const preFlight = estimateRequestTokens(
+      req.messages,
+      req.system,
+      req.tools ?? [],
+      calibrationKey(req.model)
+    );
+    a.ctx.lastRequestTokens = preFlight.total;
+    _lastPreFlightMsgCount = req.messages.length;
+    a.ctx.meta["lastRequestTokensAt"] = {
+      msgCount: req.messages.length,
+      toolCount: (req.tools ?? []).length
+    };
+    return preFlight;
+  }
+  function refreshContextRequestTokenStash(opts = {}) {
+    const msgCount = a.ctx.messages.length;
+    const toolCount = (a.ctx.tools ?? []).length;
+    const stashed = a.ctx.lastRequestTokens;
+    const stashedAt = a.ctx.meta?.["lastRequestTokensAt"];
+    if (!opts.force && typeof stashed === "number" && stashed > 0 && typeof stashedAt === "object" && stashedAt !== null) {
+      const meta = stashedAt;
+      if (meta.msgCount === msgCount && (typeof meta.toolCount !== "number" || meta.toolCount === toolCount)) {
+        return stashed;
+      }
+    }
+    const refreshed = estimateRequestTokens(
+      a.ctx.messages,
+      a.ctx.systemPrompt,
+      a.ctx.tools ?? [],
+      calibrationKey()
+    ).total;
+    a.ctx.lastRequestTokens = refreshed;
+    _lastPreFlightMsgCount = msgCount;
+    a.ctx.meta["lastRequestTokensAt"] = { msgCount, toolCount };
+    return refreshed;
+  }
+  async function buildRequestWithPreflightCompaction(opts) {
+    let req = await handlers.response.buildAndRunRequestPipeline(opts);
+    let preFlight = stashRequestTokens(req);
+    if (await compactContextIfNeeded()) {
+      req = await handlers.response.buildAndRunRequestPipeline(opts);
+      preFlight = stashRequestTokens(req);
+    }
+    return { req, preFlight };
+  }
   function emitContextPct() {
     const msgCount = a.ctx.messages.length;
     const toolCount = (a.ctx.tools ?? []).length;
@@ -44053,7 +44516,9 @@ function createAgentLoopHandler(a, handlers) {
       );
       total = est.total;
     }
-    a.events.emit("ctx.pct", { load: total / maxContext, tokens: total, maxContext });
+    const rawLoad = maxContext > 0 ? total / maxContext : 0;
+    const load = Math.max(0, Math.min(1, rawLoad));
+    a.events.emit("ctx.pct", { load, rawLoad, tokens: total, maxContext });
   }
   function currentMaxContext() {
     const metaLimit = a.ctx.meta?.["effectiveMaxContext"];
@@ -44219,19 +44684,7 @@ function createAgentLoopHandler(a, handlers) {
           const reason = `interrupted: ${mailboxResult.interruptReason ?? "operator request"}`;
           return { status: "aborted", iterations, abortReason: reason, finalText };
         }
-        const req = await handlers.response.buildAndRunRequestPipeline(opts);
-        const preFlight = estimateRequestTokens(
-          req.messages,
-          req.system,
-          req.tools ?? [],
-          calibrationKey(req.model)
-        );
-        a.ctx.lastRequestTokens = preFlight.total;
-        _lastPreFlightMsgCount = req.messages.length;
-        a.ctx.meta["lastRequestTokensAt"] = {
-          msgCount: req.messages.length,
-          toolCount: (req.tools ?? []).length
-        };
+        const { req, preFlight } = await buildRequestWithPreflightCompaction(opts);
         await a.ctx.session.append({
           type: "llm_request",
           ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -44343,10 +44796,10 @@ function createAgentLoopHandler(a, handlers) {
           toolLoopCount = 0;
         }
         if (toolUses.length === 0) {
+          await compactContextIfNeeded();
           emitContextPct();
           a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
           if (autonomousContinue && responseResult.directive === "continue") {
-            await compactContextIfNeeded();
             await a.extensions.runAfterIteration(a.ctx, i);
             continue;
           }
@@ -44364,15 +44817,15 @@ function createAgentLoopHandler(a, handlers) {
           throw toolErr;
         }
         if (autonomousContinue && consumeAutonomousContinue(a.ctx)) {
+          await compactContextIfNeeded();
           emitContextPct();
           a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
-          await compactContextIfNeeded();
           await a.extensions.runAfterIteration(a.ctx, i);
           continue;
         }
+        await compactContextIfNeeded();
         emitContextPct();
         a.events.emit("iteration.completed", { ctx: a.ctx, index: i });
-        await compactContextIfNeeded();
         await a.extensions.runAfterIteration(a.ctx, i);
         if (autonomousContinue && responseResult.directive === "continue") {
           continue;
@@ -45486,6 +45939,52 @@ fresh suggestions via \`/suggest\`.`;
 
 // src/core/system-prompt-builder.ts
 var LAYER_1_IDENTITY = PROMPT;
+function effectiveShell(platform2, wrongstackShell) {
+  if (platform2 !== "win32") return "posix";
+  const v = wrongstackShell?.trim().toLowerCase();
+  if (v === "powershell" || v === "powershell.exe") return "powershell";
+  if (v === "pwsh" || v === "pwsh.exe") return "pwsh";
+  if (v === "cmd" || v === "cmd.exe") return "cmd";
+  return "cmd";
+}
+var SHELL_DISPLAY = {
+  pwsh: "pwsh (PowerShell 7+) \u2014 write PowerShell syntax, not bash",
+  powershell: "powershell (Windows PowerShell 5.1) \u2014 write PowerShell syntax, not bash",
+  cmd: "cmd.exe (Command Prompt) \u2014 write cmd syntax, not bash"
+};
+function shellGuidanceBlock(shell, detail) {
+  if (shell === "posix") return "";
+  if (shell === "cmd") {
+    if (detail === "short") {
+      return "- Shell syntax: cmd.exe \u2014 use `%VAR%`, `2>nul`, `dir`/`type`/`del`/`where` (NOT bash `$VAR`, `/dev/null`, `ls`/`cat`/`rm`).";
+    }
+    return [
+      "## Shell \u2014 cmd.exe",
+      "The `bash` tool runs **cmd.exe** on this machine. Write cmd syntax, not bash/POSIX:",
+      "- Env vars: `%NAME%` (NOT `$NAME`); set with `set NAME=value`.",
+      "- Discard output: `2>nul` / `>nul` (NOT `2>/dev/null`).",
+      "- No `ls`/`cat`/`rm`/`which`/`head` \u2014 use `dir`/`type`/`del`/`where` and `more`.",
+      "- Chain with `&&` / `||` / `&`. Prefer the dedicated read/grep/glob tools over shell file ops."
+    ].join("\n");
+  }
+  if (detail === "short") {
+    return "- Shell syntax: PowerShell \u2014 use `$env:VAR`, `2>$null`, `Get-Content`/`Select-Object` (NOT bash `$VAR`, `/dev/null`, `cat`/`head`).";
+  }
+  const chain = shell === "pwsh" ? "- Chain with `&&` / `||` (supported in PowerShell 7)." : "- `&&` / `||` are NOT available in Windows PowerShell 5.1 \u2014 separate commands with `;` (and check `$LASTEXITCODE`).";
+  return [
+    `## Shell \u2014 PowerShell${shell === "pwsh" ? " 7+ (pwsh)" : " 5.1 (powershell)"}`,
+    "The `bash` tool runs **PowerShell** on this machine. Write PowerShell syntax, not bash/POSIX:",
+    "- Env vars: read `$env:NAME`, set `$env:NAME = 'value'` (NOT `$NAME`, `%NAME%`, or `export`).",
+    "- Discard output: `... 2>$null` or `$null = ...` (NOT `2>/dev/null`).",
+    "- No bash builtins \u2014 use cmdlets: `head -n N`\u2192`Select-Object -First N`, `tail`\u2192`-Last N`, `cat`\u2192`Get-Content`, `which x`\u2192`Get-Command x`, `rm -rf p`\u2192`Remove-Item -Recurse -Force p`, `touch f`\u2192`New-Item -ItemType File f`. Prefer the grep/glob tools over `Select-String`.",
+    "- Read a line window of a file: `Get-Content path | Select-Object -Skip N -First M` (the `sed -n` / `head|tail` equivalent).",
+    "- Pipes work normally; `rg`/`git`/`node` and other native exes run as-is \u2014 only the *shell builtins* differ. (`rg --files src | rg pattern` is fine.)",
+    '- Call exes whose path has spaces via the call operator: `& "C:\\Program Files\\app.exe" args`.',
+    "- Multi-line literals: single-quoted here-string `@'\u2026'@` with the closing `'@` at column 0.",
+    "- Non-interactive only: no `Read-Host`/`Get-Credential`/`pause`; add `-Confirm:$false` to destructive cmdlets.",
+    chain
+  ].join("\n");
+}
 var DefaultSystemPromptBuilder = class {
   constructor(opts = {}) {
     this.opts = opts;
@@ -46059,7 +46558,8 @@ ${agentList}`;
     if (cached) return cached;
     const today = this.opts.todayIso ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const platform2 = `${os6.platform()} ${os6.release()}`;
-    const shell = process.env.SHELL ?? process.env.ComSpec ?? "unknown";
+    const effShell = effectiveShell(os6.platform(), process.env["WRONGSTACK_SHELL"]);
+    const shell = effShell === "posix" ? process.env.SHELL ?? process.env.ComSpec ?? "unknown" : SHELL_DISPLAY[effShell];
     const node = process.version;
     const isGit = await this.dirExists(path3.join(ctx.projectRoot, ".git"));
     const [git, langs] = await Promise.all([
@@ -46107,6 +46607,10 @@ ${agentList}`;
         lines.push(`- Mode: ${this.opts.modeId}`);
       }
     }
+    if (effShell !== "posix" && tier !== "minimal") {
+      const guide = shellGuidanceBlock(effShell, tier === "light" ? "short" : "full");
+      if (guide) lines.push("", guide);
+    }
     if (this.skillCache) {
       lines.push(
         "",
@@ -47422,7 +47926,6 @@ var PhaseGraphBuilder = class _PhaseGraphBuilder {
       const phase = phaseArray[i];
       if (!phase) continue;
       phase.nextPhases = i < phaseArray.length - 1 ? [phaseArray[i + 1]?.id ?? ""] : [];
-      phase.dependsOn = i > 0 ? [phaseArray[i - 1]?.id ?? ""] : [];
     }
     const graph = {
       id: graphId,
@@ -47526,6 +48029,7 @@ var PhaseOrchestrator = class {
   async start() {
     this.stopped = false;
     this.paused = false;
+    this.normalizeForResume();
     this.graph.startedAt = Date.now();
     this.graph.updatedAt = Date.now();
     let readyPhases = this.getReadyPhases();
@@ -47548,6 +48052,30 @@ var PhaseOrchestrator = class {
       this.tickInterval = setInterval(() => this.tick(), 1e3);
     }
   }
+  /**
+   * Make a (possibly resumed) graph runnable. A graph loaded from disk after an
+   * interrupted run can carry transient state from the dead process: phases left
+   * `running` and tasks left `in_progress`. The scheduler only starts `pending`
+   * phases (getReadyPhases) and only runs `pending` tasks (getExecutableTasks),
+   * so without this a resumed phase/task would stall forever. Reset that
+   * transient state to `pending`; terminal phases (completed/failed/skipped) and
+   * already-completed tasks are untouched, so completed work is never re-run.
+   * For a freshly built graph this is a no-op.
+   */
+  normalizeForResume() {
+    this.graph.activePhaseIds = [];
+    for (const phase of this.graph.phases.values()) {
+      if (phase.status === "running") {
+        phase.status = "pending";
+        phase.updatedAt = Date.now();
+      }
+      if (phase.status === "pending") {
+        for (const task of phase.taskGraph.nodes.values()) {
+          if (task.status === "in_progress") task.status = "pending";
+        }
+      }
+    }
+  }
   /** Wait for all pending phase merges, dependency-ordered and globally serialized. */
   async drainMerges() {
     await Promise.allSettled([...this.phaseMergePromise.values()]);
@@ -47754,6 +48282,24 @@ var PhaseOrchestrator = class {
     this.ctx.onPhaseFail?.(phase, new Error(error));
     await this.keepWorktreeForReview(phase);
   }
+  /**
+   * A phase whose tasks all succeeded was marked `completed` and queued for
+   * merge, but the merge back into the base branch failed. Its work is NOT
+   * integrated, so correct the graph: move the phase out of `completedPhaseIds`
+   * into `failedPhaseIds` and flip its status to `failed`. Without this the
+   * persisted graph (and the board) would claim the phase succeeded while a
+   * `phase.failed` event fired — an inconsistency that hides un-merged work.
+   * Idempotent: safe to call more than once for the same phase.
+   */
+  markPhaseMergeFailed(phase, error) {
+    if (phase.status !== "failed") {
+      this.graph.completedPhaseIds = this.graph.completedPhaseIds.filter((id) => id !== phase.id);
+      this.updatePhaseStatus(phase, "failed");
+    }
+    if (!this.graph.failedPhaseIds.includes(phase.id)) this.graph.failedPhaseIds.push(phase.id);
+    this.emit("phase.failed", { phaseId: phase.id, name: phase.name, error });
+    this.ctx.onPhaseFail?.(phase, new Error(error));
+  }
   /** Trim long verifier output so it fits cleanly in an event/error message. */
   truncate(text, max = 500) {
     const t2 = text.trim();
@@ -47785,7 +48331,7 @@ var PhaseOrchestrator = class {
           message: msg,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         }));
-        this.emit("phase.failed", { phaseId: phase.id, name: phase.name, error: msg });
+        this.markPhaseMergeFailed(phase, msg);
       });
       await this.mergeQueue;
     })();
@@ -47830,11 +48376,7 @@ var PhaseOrchestrator = class {
         worktreeDir: handle.dir,
         error: toErrorMessage(err)
       });
-      this.emit("phase.failed", {
-        phaseId: phase.id,
-        name: phase.name,
-        error: `worktree merge failed: ${toErrorMessage(err)}`
-      });
+      this.markPhaseMergeFailed(phase, `worktree merge failed: ${toErrorMessage(err)}`);
     }
   }
   async shouldAttemptConflictResolution(phase, info) {
@@ -47986,7 +48528,7 @@ var PhaseOrchestrator = class {
         const dep = this.graph.phases.get(depId);
         return dep?.status === "completed" || dep?.status === "skipped" || dep?.status === "failed";
       });
-      if (depsDone || phase.parallelizable) {
+      if (depsDone) {
         ready.push(phase);
       }
     }
@@ -48364,8 +48906,8 @@ var AutoPhaseRunner = class {
     }
     this.maxRunTimer?.unref?.();
     if (this.opts.events) {
-      const events = this.opts.events;
-      const onUntyped = events.on;
+      const bus = this.opts.events;
+      const onUntyped = (event, handler) => bus.on(event, handler);
       this.unsubscribeCompleted = onUntyped("graph.completed", this.graphCompletedHandler);
       this.unsubscribeFailed = onUntyped("graph.failed", this.graphFailedHandler);
     }