bosun 0.40.5 → 0.40.6

package/.env.example

@@ -196,6 +196,19 @@ VOICE_FALLBACK_MODE=browser
 # Executor used by voice tool delegations for complex requests
 VOICE_DELEGATE_EXECUTOR=codex-sdk
 
+# ─── Context Shredding / Live Tool Compaction ───────────────────────────────
+# Traditional shredding trims older context turns. Live tool compaction runs
+# earlier: it summarizes large, noisy command outputs before they ever land in
+# the active turn, while preserving a `bosun --tool-log <id>` retrieval path.
+# CONTEXT_SHREDDING_ENABLED=true
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_ENABLED=false
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MODE=auto
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_CHARS=4000
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_TARGET_CHARS=1800
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_SAVINGS_PCT=15
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_RUNTIME_MS=2000
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_BLOCK_STRUCTURED_OUTPUT=true
+# CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_ALLOW_COMMANDS=grep,rg,find,findstr,select-string,ag,ack,sift,fd,where,which,ls,dir,tree,git,go,npm,pnpm,yarn,npx,bun,node,python,python3,pytest,pip,pip3,poetry,docker,kubectl,helm,terraform,ansible,ansible-playbook,journalctl,tail,get-content,cargo,gradle,maven,mvn,javac,tsc,jest,vitest,deno,make,cmake,bazel,buck,nx,turbo,rush,composer,bundle
 # ─── Desktop Portal ────────────────────────────────────────────────────────
 # Auto-start bosun daemon when the desktop portal launches (default: true)
 # BOSUN_DESKTOP_AUTO_START_DAEMON=true

package/agent/agent-pool.mjs

@@ -44,6 +44,7 @@ import { fileURLToPath } from "node:url";
 import { loadConfig } from "../config/config.mjs";
 import { resolveRepoRoot, resolveAgentRepoRoot } from "../config/repo-root.mjs";
 import { resolveCodexProfileRuntime } from "../shell/codex-model-profiles.mjs";
+import { resolveCopilotCliLaunchConfig } from "../shell/copilot-shell.mjs";
 import { getGitHubToken } from "../github/github-auth-manager.mjs";
 import {
   isTransientStreamError,
@@ -489,6 +490,10 @@ function shouldFallbackForSdkError(error) {
   if (!error) return false;
   const message = String(error).toLowerCase();
   if (!message) return false;
+  if (message.includes("protocol version mismatch")) return true;
+  if (message.includes("sdk expects version") && message.includes("server reports version")) {
+    return true;
+  }
   // SDK not installed / not found
   if (message.includes("not available")) return true;
   // Missing finish_reason (incomplete response)
@@ -808,6 +813,10 @@ function shouldApplySdkCooldown(error) {
   if (!error) return false;
   const message = String(error).toLowerCase();
   if (!message) return false;
+  if (message.includes("protocol version mismatch")) return true;
+  if (message.includes("sdk expects version") && message.includes("server reports version")) {
+    return true;
+  }
   if (message.includes("timeout")) return true;
   if (message.includes("rate limit") || message.includes("429")) return true;
   if (message.includes("service unavailable") || message.includes("503")) {
@@ -1448,22 +1457,22 @@ async function launchCopilotThread(prompt, cwd, timeoutMs, extra = {}) {
             console.warn(`${TAG} copilot MCP config write failed (non-fatal): ${mcpErr.message}`);
           }
         }
-        const cliArgs = buildPoolCopilotCliArgs(mcpConfigPath);
+        const cliLaunch = resolveCopilotCliLaunchConfig({
+          env: runtimeEnv,
+          repoRoot: REPO_ROOT,
+          cliArgs: buildPoolCopilotCliArgs(mcpConfigPath),
+        });
         clientOpts = {
           cwd,
           env: clientEnv,
-          cliArgs,
+          cliArgs: cliLaunch.cliArgs,
           useStdio: true,
         };
         if (token) {
           clientOpts.githubToken = token;
           clientOpts.token = token;
         }
-        const cliPath =
-          process.env.COPILOT_CLI_PATH ||
-          process.env.GITHUB_COPILOT_CLI_PATH ||
-          undefined;
-        if (cliPath) clientOpts.cliPath = cliPath;
+        if (cliLaunch.cliPath) clientOpts.cliPath = cliLaunch.cliPath;
       }
       client = new CopilotClientClass(clientOpts);
       await client.start();

package/agent/agent-supervisor.mjs

@@ -901,6 +901,16 @@ export class AgentSupervisor {
     const progress = signals.sessionProgress;
     const analysis = signals.sessionAnalysis;
     const anomalies = signals.activeAnomalies || [];
+    const includesAny = (text, needles) => needles.some((needle) => text.includes(needle));
+    const includesOrdered = (text, parts) => {
+      let cursor = 0;
+      for (const part of parts) {
+        const idx = text.indexOf(part, cursor);
+        if (idx === -1) return false;
+        cursor = idx + part.length;
+      }
+      return true;
+    };
 
     // ── Agent completely dead ──
     if (
@@ -914,7 +924,13 @@ export class AgentSupervisor {
     // ── External errors (check first — these aren't the agent's fault) ──
     if (context.error || signals.error) {
       const errText = context.error || signals.error || "";
-      if (/429|rate.?limit|too many requests|quota exceeded/i.test(errText)) {
+      const errLower = String(errText).toLowerCase();
+      if (
+        errLower.includes("429") ||
+        includesOrdered(errLower, ["rate", "limit"]) ||
+        errLower.includes("too many requests") ||
+        errLower.includes("quota exceeded")
+      ) {
         // Check for flood
         if (signals.errorPatterns?.length >= 3) {
           const recent = signals.errorPatterns.slice(-5);
@@ -923,47 +939,83 @@ export class AgentSupervisor {
         }
         return SITUATION.RATE_LIMITED;
       }
-      if (/ECONNREFUSED|ETIMEDOUT|500|502|503|fetch failed/i.test(errText)) {
+      if (
+        includesAny(errLower, ["econnrefused", "etimedout", "fetch failed"]) ||
+        includesAny(errLower, [" 500", "500 ", "500internal", "500internalservererror"]) ||
+        includesAny(errLower, [" 502", "502 ", "502badgateway", "502bad gateway"]) ||
+        errLower.includes(" 503")
+      ) {
         return SITUATION.API_ERROR;
       }
-      if (/context.*(too long|exceeded|overflow)|max.*token/i.test(errText) ||
-          /context_length_exceeded|prompt_too_long|prompt.*too.*long/i.test(errText) ||
-          /This model's maximum context length/i.test(errText) ||
-          /token_budget.*exceeded|token.*budget/i.test(errText) ||
-          /turn_limit_reached|conversation.*too.*long/i.test(errText) ||
-          /string_above_max_length|maximum.*number.*tokens/i.test(errText)) {
+      if (
+        (errLower.includes("context") && includesAny(errLower, ["too long", "exceeded", "overflow"])) ||
+        includesOrdered(errLower, ["max", "token"]) ||
+        includesAny(errLower, ["context_length_exceeded", "prompt_too_long", "this model's maximum context length", "turn_limit_reached", "string_above_max_length"]) ||
+        includesOrdered(errLower, ["prompt", "too", "long"]) ||
+        includesOrdered(errLower, ["token_budget", "exceeded"]) ||
+        includesOrdered(errLower, ["token", "budget"]) ||
+        includesOrdered(errLower, ["conversation", "too", "long"]) ||
+        includesOrdered(errLower, ["maximum", "number", "tokens"])
+      ) {
         return SITUATION.TOKEN_OVERFLOW;
       }
-      if (/model.*not.*supported|model.*error|invalid.*model|model.*not.*found|model.*deprecated/i.test(errText)) {
+      if (
+        includesOrdered(errLower, ["model", "not", "supported"]) ||
+        includesOrdered(errLower, ["model", "error"]) ||
+        includesOrdered(errLower, ["invalid", "model"]) ||
+        includesOrdered(errLower, ["model", "not", "found"]) ||
+        includesOrdered(errLower, ["model", "deprecated"])
+      ) {
         return SITUATION.MODEL_ERROR;
       }
       // ── Auth failures — MUST come BEFORE session_expired (which has 'unauthorized')
-      if (/invalid.?api.?key|authentication_error|permission_error/i.test(errText) ||
-          /401 Unauthorized|403 Forbidden/i.test(errText) ||
-          /billing_hard_limit|insufficient_quota/i.test(errText) ||
-          /invalid.*credentials|access.?denied|not.?authorized/i.test(errText)) {
+      if (
+        includesAny(errLower, ["invalid api key", "invalid-api-key", "invalid_api_key", "authentication_error", "permission_error", "401 unauthorized", "403 forbidden", "billing_hard_limit", "insufficient_quota"]) ||
+        includesOrdered(errLower, ["invalid", "credentials"]) ||
+        includesOrdered(errLower, ["access", "denied"]) ||
+        includesOrdered(errLower, ["not", "authorized"])
+      ) {
         return SITUATION.AUTH_FAILURE;
       }
       // ── Session expired (after auth check since 'unauthorized' overlaps)
-      if (/session.*expired|thread.*not.*found/i.test(errText) ||
-          /invalid.*session|invalid.*token/i.test(errText)) {
+      if (
+        includesOrdered(errLower, ["session", "expired"]) ||
+        includesOrdered(errLower, ["thread", "not", "found"]) ||
+        includesOrdered(errLower, ["invalid", "session"]) ||
+        includesOrdered(errLower, ["invalid", "token"])
+      ) {
         return SITUATION.SESSION_EXPIRED;
       }
       // ── Content policy (safety filter)
-      if (/content_policy|content.?filter|safety_system|safety.*filter/i.test(errText) ||
-          /flagged.*content|output.*blocked|response.*blocked/i.test(errText)) {
+      if (
+        includesAny(errLower, ["content_policy", "content filter", "content-filter", "content_filter", "safety_system"]) ||
+        includesOrdered(errLower, ["safety", "filter"]) ||
+        includesOrdered(errLower, ["flagged", "content"]) ||
+        includesOrdered(errLower, ["output", "blocked"]) ||
+        includesOrdered(errLower, ["response", "blocked"])
+      ) {
         return SITUATION.CONTENT_POLICY;
       }
       // ── Codex sandbox/CLI errors
-      if (/sandbox.*fail|bwrap.*error|bubblewrap/i.test(errText) ||
-          /EPERM.*operation.*not.*permitted/i.test(errText) ||
-          /writable_roots|namespace.*error/i.test(errText) ||
-          /codex.*(segfault|killed|crash)/i.test(errText)) {
+      if (
+        includesOrdered(errLower, ["sandbox", "fail"]) ||
+        includesOrdered(errLower, ["bwrap", "error"]) ||
+        errLower.includes("bubblewrap") ||
+        includesOrdered(errLower, ["eperm", "operation", "not", "permitted"]) ||
+        errLower.includes("writable_roots") ||
+        includesOrdered(errLower, ["namespace", "error"]) ||
+        (errLower.includes("codex") && includesAny(errLower, ["segfault", "killed", "crash"]))
+      ) {
         return SITUATION.CODEX_SANDBOX;
       }
       // ── Invalid config (catch-all for config-related errors)
-      if (/config.*invalid|config.*missing|misconfigured/i.test(errText) ||
-          /OPENAI_API_KEY.*not.*set|ANTHROPIC_API_KEY.*not.*set/i.test(errText)) {
+      if (
+        includesOrdered(errLower, ["config", "invalid"]) ||
+        includesOrdered(errLower, ["config", "missing"]) ||
+        errLower.includes("misconfigured") ||
+        includesOrdered(errLower, ["openai_api_key", "not", "set"]) ||
+        includesOrdered(errLower, ["anthropic_api_key", "not", "set"])
+      ) {
         return SITUATION.INVALID_CONFIG;
       }
     }
@@ -1009,11 +1061,11 @@ export class AgentSupervisor {
     // ── Build/test/lint failures from context ──
     if (context.error) {
       const err = context.error.toLowerCase();
-      if (/pre-push hook.*fail/i.test(err)) return SITUATION.PRE_PUSH_FAILURE;
-      if (/git push.*fail|rejected.*push/i.test(err)) return SITUATION.PUSH_FAILURE;
-      if (/go build.*fail|compilation error|cannot find/i.test(err)) return SITUATION.BUILD_FAILURE;
-      if (/FAIL\s+\S+|test.*fail/i.test(err)) return SITUATION.TEST_FAILURE;
-      if (/golangci-lint|lint.*error/i.test(err)) return SITUATION.LINT_FAILURE;
+      if (includesOrdered(err, ["pre-push hook", "fail"])) return SITUATION.PRE_PUSH_FAILURE;
+      if (includesOrdered(err, ["git push", "fail"]) || includesOrdered(err, ["rejected", "push"])) return SITUATION.PUSH_FAILURE;
+      if (includesOrdered(err, ["go build", "fail"]) || err.includes("compilation error") || err.includes("cannot find")) return SITUATION.BUILD_FAILURE;
+      if ((err.includes("fail") && err.includes("test")) || err.includes("fail ")) return SITUATION.TEST_FAILURE;
+      if (err.includes("golangci-lint") || includesOrdered(err, ["lint", "error"])) return SITUATION.LINT_FAILURE;
       if (/merge conflict|CONFLICT/i.test(err)) return SITUATION.GIT_CONFLICT;
     }
 
@@ -1234,3 +1286,4 @@ export class AgentSupervisor {
 export function createAgentSupervisor(opts) {
   return new AgentSupervisor(opts);
 }
+

package/agent/autofix.mjs

@@ -93,7 +93,6 @@ export function extractErrors(logText) {
   const atLineHeader = /^At\s+([A-Za-z]:\\[^\n:]+\.ps1):(\d+)\s+char:(\d+)/;
 
   // Pattern C: TerminatingError(X): "message"
-  const terminatingPattern = /TerminatingError\(([^)]+)\):\s*"(.+?)"/;
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -147,16 +146,24 @@ export function extractErrors(logText) {
     }
 
     // ── Check Pattern C (TerminatingError) ──────────────────────────
-    let matchD = line.match(terminatingPattern);
-    if (matchD) {
-      addError({
-        errorType: "TerminatingError",
-        file: "unknown",
-        line: 0,
-        column: null,
-        message: `${matchD[1]}: ${matchD[2].trim()}`,
-        signature: `TerminatingError:${matchD[1]}`,
-      });
+    const marker = "TerminatingError(";
+    const markerPos = line.indexOf(marker);
+    if (markerPos !== -1) {
+      const typeStart = markerPos + marker.length;
+      const typeEnd = line.indexOf(")", typeStart);
+      const colonPos = typeEnd >= 0 ? line.indexOf(":", typeEnd + 1) : -1;
+      const errorType = typeEnd >= 0 ? line.slice(typeStart, typeEnd).trim() : "";
+      const detail = colonPos >= 0 ? line.slice(colonPos + 1).trim().replace(/^"|"$/g, "") : "";
+      if (errorType && detail) {
+        addError({
+          errorType: "TerminatingError",
+          file: "unknown",
+          line: 0,
+          column: null,
+          message: `${errorType}: ${detail}`,
+          signature: `TerminatingError:${errorType}`,
+        });
+      }
     }
   }
 
@@ -185,18 +192,22 @@ function parseLineBlock(lines, startIdx) {
   }
 
   // Capture code line: " NNN |  code..."
-  if (i < lines.length && /^\s*\d+\s*\|/.test(lines[i])) {
-    const codeMatch = lines[i].match(/^\s*\d+\s*\|\s*(.*)$/);
-    if (codeMatch) codeLine = codeMatch[1].trim();
-    i++;
+  if (i < lines.length) {
+    const raw = String(lines[i] || "");
+    const sep = raw.indexOf("|");
+    if (sep !== -1 && /^\s*\d+\s*$/.test(raw.slice(0, sep))) {
+      codeLine = raw.slice(sep + 1).trim();
+      i++;
+    }
   }
 
   // Skip underline and intermediate "| ..." lines, capture last "| message" line
   let lastPipeMessage = "";
   while (i < lines.length) {
-    const pipeMatch = lines[i].match(/^\s*\|\s*(.*)$/);
-    if (!pipeMatch) break;
-    const content = pipeMatch[1].trim();
+    const raw = String(lines[i] || "");
+    const sep = raw.indexOf("|");
+    if (sep === -1 || raw.slice(0, sep).trim().length > 0) break;
+    const content = raw.slice(sep + 1).trim();
     // Skip underline-only lines (~~~~) and empty lines
     if (content && !/^~+$/.test(content)) {
       lastPipeMessage = content;
@@ -225,29 +236,32 @@ function parsePlusBlock(lines, startIdx) {
   let i = startIdx;
 
   // First "+ " line is usually the code
-  if (i < lines.length && /^\s*\+\s*/.test(lines[i])) {
-    const codeMatch = lines[i].match(/^\s*\+\s*(.*)$/);
-    if (codeMatch) {
-      const content = codeMatch[1].trim();
+  if (i < lines.length) {
+    const raw = String(lines[i] || "").trimStart();
+    if (raw.startsWith("+")) {
+      const content = raw.slice(1).trim();
       if (!/^~+$/.test(content)) codeLine = content;
+      i++;
     }
-    i++;
   }
 
   // Subsequent "+ " lines — skip underlines, capture error type + message
-  while (i < lines.length && /^\s*\+\s*/.test(lines[i])) {
-    const plusMatch = lines[i].match(/^\s*\+\s*(.*)$/);
-    if (plusMatch) {
-      const content = plusMatch[1].trim();
-      if (/^~+$/.test(content)) {
-        i++;
-        continue;
-      }
-      // Check for "ErrorType: message"
-      const errMatch = content.match(/^(\w[\w.-]+):\s*(.+)$/);
-      if (errMatch) {
-        errorType = errMatch[1];
-        message = errMatch[2].trim();
+  while (i < lines.length) {
+    const raw = String(lines[i] || "").trimStart();
+    if (!raw.startsWith("+")) break;
+    const content = raw.slice(1).trim();
+    if (/^~+$/.test(content)) {
+      i++;
+      continue;
+    }
+    // Check for "ErrorType: message"
+    const colonPos = content.indexOf(":");
+    if (colonPos > 0 && colonPos < content.length - 1) {
+      const maybeType = content.slice(0, colonPos).trim();
+      const maybeMessage = content.slice(colonPos + 1).trim();
+      if (/^\w[\w.-]+$/.test(maybeType) && maybeMessage) {
+        errorType = maybeType;
+        message = maybeMessage;
       }
     }
     i++;

package/agent/fleet-coordinator.mjs

@@ -160,7 +160,7 @@ export function normalizeGitUrl(url) {
   s = s.replace(/\.git$/, "");
 
   // Strip trailing slashes
-  s = s.replace(/\/+$/, "");
+  while (s.endsWith("/")) s = s.slice(0, -1);
 
   return s.toLowerCase();
 }
@@ -857,3 +857,4 @@ export function formatFleetSummary() {
 
   return lines.join("\n");
 }
+

package/agent/hook-profiles.mjs

@@ -187,7 +187,7 @@ function normalizeOverrideCommands(rawValue) {
     return [];
   }
   const commands = raw
-    .split(/\s*;;\s*|\r?\n/)
+    .split(/\r?\n/).flatMap((part) => part.split(";;"))
     .map((part) => part.trim())
     .filter(Boolean);
   return commands;

package/bosun.schema.json

@@ -1199,6 +1199,56 @@
           "default": 1,
           "description": "Turns during which the full user prompt is preserved."
         },
+        "liveToolCompactionEnabled": {
+          "type": "boolean",
+          "default": false,
+          "description": "Enable command-aware live compaction of large tool outputs before they are stored in the active turn."
+        },
+        "liveToolCompactionMode": {
+          "type": "string",
+          "enum": ["off", "auto", "aggressive"],
+          "default": "auto",
+          "description": "off disables live compaction, auto compacts only when pressure or signal justify it, and aggressive favors stronger reduction for noisy command families."
+        },
+        "liveToolCompactionMinChars": {
+          "type": "integer",
+          "minimum": 500,
+          "maximum": 500000,
+          "default": 4000,
+          "description": "Minimum output size before live compaction is considered."
+        },
+        "liveToolCompactionTargetChars": {
+          "type": "integer",
+          "minimum": 200,
+          "maximum": 50000,
+          "default": 1800,
+          "description": "Target upper bound for compacted live command output before retrieval hints and metadata."
+        },
+        "liveToolCompactionMinSavingsPct": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 95,
+          "default": 15,
+          "description": "Discard compacted output if it does not save at least this much space."
+        },
+        "liveToolCompactionMinRuntimeMs": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 3600000,
+          "default": 2000,
+          "description": "When command duration metadata is present, require at least this runtime before compacting in auto mode."
+        },
+        "liveToolCompactionBlockStructured": {
+          "type": "boolean",
+          "default": true,
+          "description": "Avoid live compaction for likely JSON or other structured outputs where exact bytes matter more than size."
+        },
+        "liveToolCompactionAllowCommands": {
+          "type": "array",
+          "items": { "type": "string" },
+          "default": ["grep", "rg", "find", "git", "go", "npm", "pnpm", "yarn", "node", "python", "python3", "pytest", "docker", "kubectl", "cargo", "gradle", "maven", "mvn", "javac", "tsc", "jest", "vitest", "deno"],
+          "description": "Command or tool families eligible for live compaction."
+        },
         "perType": {
           "type": "object",
           "description": "Per-interaction-type config overrides. Keys: task, manual, primary, chat, voice, flow.",
@@ -1237,3 +1287,4 @@
     }
   }
 }
+

package/config/context-shredding-config.mjs

@@ -97,6 +97,14 @@ export const CONTENT_TYPES = Object.freeze([
  * @property {boolean} compressToolOutputs  - Enable tool output compression
  * @property {boolean} compressAgentMessages - Enable agent message compression
  * @property {boolean} compressUserMessages - Enable user message compression
+ * @property {boolean} liveToolCompactionEnabled - Enable command-aware live compaction before history shredding
+ * @property {string}  liveToolCompactionMode - off|auto|aggressive smart mode for live compaction
+ * @property {number}  liveToolCompactionMinChars - Minimum output chars before live compaction is considered
+ * @property {number}  liveToolCompactionTargetChars - Target maximum chars for live-compacted outputs
+ * @property {number}  liveToolCompactionMinSavingsPct - Minimum savings percentage required to keep a compacted result
+ * @property {number}  liveToolCompactionMinRuntimeMs - Minimum runtime before live compaction is allowed when duration metadata exists
+ * @property {boolean} liveToolCompactionBlockStructured - Disable live compaction for likely structured outputs
+ * @property {string[]} liveToolCompactionAllowCommands - Command/tool allowlist for live compaction
  * @property {Object}  perType             - Per interaction-type overrides (keyed by INTERACTION_TYPES)
  * @property {Object}  perAgent            - Per agent-type overrides (keyed by AGENT_TYPES)
  */
@@ -138,6 +146,25 @@ export const DEFAULT_SHREDDING_CONFIG = Object.freeze({
   msgMinCompressChars: 120,
   userMsgFullTurns: 1,     // only the current turn keeps the full user prompt
 
+  // ── Live command/tool compaction ─────────────────────────────
+  liveToolCompactionEnabled: false,
+  liveToolCompactionMode: "auto",
+  liveToolCompactionMinChars: 4000,
+  liveToolCompactionTargetChars: 1800,
+  liveToolCompactionMinSavingsPct: 15,
+  liveToolCompactionMinRuntimeMs: 2000,
+  liveToolCompactionBlockStructured: true,
+  liveToolCompactionAllowCommands: [
+    "grep", "rg", "find", "findstr", "select-string", "ag", "ack", "sift",
+    "fd", "where", "which", "ls", "dir", "tree", "git", "go", "npm",
+    "pnpm", "yarn", "npx", "bun", "node", "python", "python3", "pytest",
+    "pip", "pip3", "poetry", "docker", "kubectl", "helm", "terraform",
+    "ansible", "ansible-playbook", "journalctl", "tail", "get-content",
+    "cargo", "gradle", "maven", "mvn", "javac", "tsc", "jest", "vitest",
+    "deno", "make", "cmake", "bazel", "buck", "nx", "turbo", "rush",
+    "composer", "bundle",
+  ],
+
   // ── Per-type overrides (empty = use base config) ─────────────
   /** @type {Record<string, Partial<ShreddingConfig>>} */
   perType: {},
@@ -301,6 +328,38 @@ export function loadContextShreddingConfig() {
   const userFull = parseEnvInt(env[`${ENV_PREFIX}USER_MSG_FULL_TURNS`], 0, 10);
   if (userFull != null) cfg.userMsgFullTurns = userFull;
 
+  // ── Live command/tool compaction ─────────────────────────────
+  const liveToolCompactionEnabled = parseEnvBool(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_ENABLED`]);
+  if (liveToolCompactionEnabled != null) cfg.liveToolCompactionEnabled = liveToolCompactionEnabled;
+
+  const liveToolCompactionMode = String(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_MODE`] || "").trim().toLowerCase();
+  if (["off", "auto", "aggressive"].includes(liveToolCompactionMode)) {
+    cfg.liveToolCompactionMode = liveToolCompactionMode;
+  }
+
+  const liveToolCompactionMinChars = parseEnvInt(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_MIN_CHARS`], 500, 500000);
+  if (liveToolCompactionMinChars != null) cfg.liveToolCompactionMinChars = liveToolCompactionMinChars;
+
+  const liveToolCompactionTargetChars = parseEnvInt(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_TARGET_CHARS`], 200, 50000);
+  if (liveToolCompactionTargetChars != null) cfg.liveToolCompactionTargetChars = liveToolCompactionTargetChars;
+
+  const liveToolCompactionMinSavingsPct = parseEnvInt(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_MIN_SAVINGS_PCT`], 0, 95);
+  if (liveToolCompactionMinSavingsPct != null) cfg.liveToolCompactionMinSavingsPct = liveToolCompactionMinSavingsPct;
+
+  const liveToolCompactionMinRuntimeMs = parseEnvInt(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_MIN_RUNTIME_MS`], 0, 60 * 60 * 1000);
+  if (liveToolCompactionMinRuntimeMs != null) cfg.liveToolCompactionMinRuntimeMs = liveToolCompactionMinRuntimeMs;
+
+  const liveToolCompactionBlockStructured = parseEnvBool(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_BLOCK_STRUCTURED_OUTPUT`]);
+  if (liveToolCompactionBlockStructured != null) cfg.liveToolCompactionBlockStructured = liveToolCompactionBlockStructured;
+
+  const liveToolCompactionAllowCommands = String(env[`${ENV_PREFIX}LIVE_TOOL_COMPACTION_ALLOW_COMMANDS`] || "").trim();
+  if (liveToolCompactionAllowCommands) {
+    cfg.liveToolCompactionAllowCommands = liveToolCompactionAllowCommands
+      .split(",")
+      .map((value) => value.trim().toLowerCase())
+      .filter(Boolean);
+  }
+
   // ── Per-type JSON profiles ────────────────────────────────────
   const profilesEnv = env[`${ENV_PREFIX}PROFILES`];
   if (profilesEnv) {
@@ -450,6 +509,14 @@ function configToOptions(cfg) {
     msgTier1MaxAge: cfg.msgTier1MaxAge,
     msgMinCompressChars: cfg.msgMinCompressChars,
     userMsgFullTurns: cfg.userMsgFullTurns,
+    liveToolCompactionEnabled: cfg.liveToolCompactionEnabled,
+    liveToolCompactionMode: cfg.liveToolCompactionMode,
+    liveToolCompactionMinChars: cfg.liveToolCompactionMinChars,
+    liveToolCompactionTargetChars: cfg.liveToolCompactionTargetChars,
+    liveToolCompactionMinSavingsPct: cfg.liveToolCompactionMinSavingsPct,
+    liveToolCompactionMinRuntimeMs: cfg.liveToolCompactionMinRuntimeMs,
+    liveToolCompactionBlockStructured: cfg.liveToolCompactionBlockStructured,
+    liveToolCompactionAllowCommands: [...(cfg.liveToolCompactionAllowCommands || [])],
   };
 }
 
@@ -677,6 +744,82 @@ export const CONTEXT_SHREDDING_ENV_DEFS = [
     description: "Turns during which the full user prompt is preserved. After this, only a short summary is kept.",
     advanced: true,
   },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_ENABLED",
+    label: "Live Tool Compaction",
+    type: "boolean",
+    default: false,
+    description: "Enable command-aware compaction of large tool outputs before they are stored in the active turn. Falls back to raw output on low confidence or unsafe shapes.",
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MODE",
+    label: "Live Compaction Mode",
+    type: "select",
+    default: "auto",
+    options: ["off", "auto", "aggressive"],
+    description: "off disables live compaction, auto compacts only when pressure or signal justify it, and aggressive favors stronger reduction for noisy command families.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_CHARS",
+    label: "Live Compaction Minimum Size",
+    type: "number",
+    default: 4000,
+    min: 500,
+    max: 500000,
+    unit: "chars",
+    description: "Minimum output size before live compaction is considered.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_TARGET_CHARS",
+    label: "Live Compaction Target Size",
+    type: "number",
+    default: 1800,
+    min: 200,
+    max: 50000,
+    unit: "chars",
+    description: "Target upper bound for compacted live command output before retrieval hints and metadata.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_SAVINGS_PCT",
+    label: "Live Compaction Min Savings",
+    type: "number",
+    default: 15,
+    min: 0,
+    max: 95,
+    unit: "%",
+    description: "Discard compacted output if it does not save at least this much space.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_MIN_RUNTIME_MS",
+    label: "Live Compaction Min Runtime",
+    type: "number",
+    default: 2000,
+    min: 0,
+    max: 3600000,
+    unit: "ms",
+    description: "When command duration metadata is present, require at least this runtime before compacting in auto mode.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_BLOCK_STRUCTURED_OUTPUT",
+    label: "Skip Structured Output",
+    type: "boolean",
+    default: true,
+    description: "Avoid live compaction for likely JSON or other structured outputs where exact bytes matter more than size.",
+    advanced: true,
+  },
+  {
+    key: "CONTEXT_SHREDDING_LIVE_TOOL_COMPACTION_ALLOW_COMMANDS",
+    label: "Live Compaction Allowlist",
+    type: "text",
+    default: "grep,rg,find,findstr,select-string,ag,ack,sift,fd,where,which,ls,dir,tree,git,go,npm,pnpm,yarn,npx,bun,node,python,python3,pytest,pip,pip3,poetry,docker,kubectl,helm,terraform,ansible,ansible-playbook,journalctl,tail,get-content,cargo,gradle,maven,mvn,javac,tsc,jest,vitest,deno,make,cmake,bazel,buck,nx,turbo,rush,composer,bundle",
+    description: "Comma-separated command or tool families eligible for live compaction. Commands outside the allowlist pass through untouched.",
+    advanced: true,
+  },
   {
     key: "CONTEXT_SHREDDING_PROFILES",
     label: "Per-Type Profiles (JSON)",