@wrongstack/cli 0.303.0 → 0.305.0

package/dist/{cli-main-37XO26GK.js → cli-main-W3T56YCY.js}

@@ -29,7 +29,7 @@ import {
 } from "./chunk-V3XH6XBJ.js";
 import {
   startCliHqConnection
-} from "./chunk-JW75HY4F.js";
+} from "./chunk-FKWHSFX4.js";
 import {
   advanceToNextTask,
   findSpec,
@@ -117,7 +117,7 @@ import { gatedEnhancerReasoning } from "@wrongstack/core/execution";
 import { TOKENS as TOKENS9 } from "@wrongstack/core/kernel";
 import { ToolRegistry as ToolRegistry2 } from "@wrongstack/core/registry";
 import { getSessionRegistry } from "@wrongstack/core/storage";
-import { startSharedHeapWatchdog, writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { startSharedHeapWatchdog, writeErr as writeErr3 } from "@wrongstack/core/utils";
 
 // src/auth-menu/panel-service.ts
 var ANSI_RE = /\u001b\[[0-9;]*m/g;
@@ -900,6 +900,12 @@ function bindSystemPromptBuilder(deps) {
       // full-shape interfaces; the helper just needs the
       // passthrough.
       memoryStore: deps.memoryStore,
+      // Thread the narrow domain-term adapter so the builder emits a
+      // compact `[Project Jargon Dictionary]` block. `deps.domainGlossary`
+      // is an optional closure over the resolved SAGE `memoryStore`
+      // that returns only entries tagged `domain-term`; when omitted
+      // (e.g. in tests or subagent prompts) the builder emits no block.
+      domainGlossary: deps.domainGlossary,
       // SAGE's turn middleware is the single memory-injection channel.
       // Disable the builder's static "# Relevant Memory" section so memories
       // are injected once, per-turn, relevance-scored — not duplicated here.
@@ -2904,6 +2910,38 @@ import {
 } from "@wrongstack/core/types";
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
 
+// src/services/dispatch-classifier.ts
+import { makeLLMClassifier } from "@wrongstack/core/coordination";
+function makeProviderClassifier(provider, model) {
+  return makeLLMClassifier(async (prompt) => {
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 15e3);
+    try {
+      const resp = await provider.complete(
+        {
+          model,
+          system: [
+            {
+              type: "text",
+              text: 'You are an agent router. Choose the single best agent for the task. Reply with ONLY a compact JSON object {"role":"...","reason":"..."}.'
+            }
+          ],
+          messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
+          maxTokens: 120,
+          temperature: 0
+        },
+        { signal: ctrl.signal }
+      );
+      const content = resp.content;
+      return Array.isArray(content) ? content[0]?.text ?? "" : "";
+    } catch {
+      return "";
+    } finally {
+      clearTimeout(timeout);
+    }
+  });
+}
+
 // src/fleet/host-acp.ts
 import {
   ACP_AGENT_COMMANDS,
@@ -3536,6 +3574,7 @@ function createHostStatusBroadcaster(input) {
 // src/fleet/host-learning.ts
 import {
   captureLearnedFromAgentOutputDetailed,
+  recordDirectiveOutcomes,
   recordSkillOutcome
 } from "@wrongstack/core/agent-catalog";
 import { TOKENS as TOKENS2 } from "@wrongstack/core/kernel";
@@ -3543,20 +3582,38 @@ function captureCompletedTaskLearningForHost(result, deps, subjects, onCaptured)
   const subject = subjects.get(result.subagentId);
   if (!subject) return;
   const logger = deps.container.safeResolve(TOKENS2.Logger);
-  if (subject.skills.length > 0) {
+  const graded = result.status !== "stopped";
+  const succeeded = result.status === "success";
+  if (graded && subject.skills.length > 0) {
     try {
-      recordSkillOutcome(
-        subject.role,
-        subject.skills,
-        result.status === "success",
-        deps.projectRoot
-      );
+      recordSkillOutcome(subject.role, subject.skills, succeeded, deps.projectRoot);
     } catch (error) {
-      logger?.debug?.(`skill affinity update failed for role "${subject.role}": ${describe(error)}`);
+      logger?.debug?.(
+        `skill affinity update failed for role "${subject.role}": ${describe(error)}`
+      );
     }
   }
   const finalText = typeof result.result === "string" ? result.result : result.partial?.text;
   if (!finalText) return;
+  if (graded) {
+    try {
+      const outcome = recordDirectiveOutcomes(subject.role, finalText, succeeded, deps.projectRoot);
+      if (outcome.attributed > 0) {
+        logger?.debug?.(
+          `directive outcomes: ${outcome.attributed} applied for role "${subject.role}" (${succeeded ? "success" : "failure"})`
+        );
+      }
+      for (const retired of outcome.quarantined) {
+        logger?.info?.(
+          `retired a directive for role "${subject.role}" after repeated failures: ${retired.slice(0, 120)}`
+        );
+      }
+    } catch (error) {
+      logger?.debug?.(
+        `directive outcome update failed for role "${subject.role}": ${describe(error)}`
+      );
+    }
+  }
   try {
     const capture = captureLearnedFromAgentOutputDetailed(
       finalText,
@@ -3636,6 +3693,84 @@ function applyFleetRootDefaults(opts) {
   }
 }
 
+// src/fleet/host-provider.ts
+import { makeProviderFromConfig, withCatalogCapabilities } from "@wrongstack/providers";
+async function buildHostSubagentProvider(deps, config, overrideId, model) {
+  const requestedProviderId = overrideId ?? config.provider;
+  const providerId = requestedProviderId === config.provider || config.providers?.[requestedProviderId] !== void 0 || deps.providerRegistry.has(requestedProviderId) ? requestedProviderId : config.provider;
+  const newCfg = config.providers?.[providerId] ?? {
+    type: providerId,
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl
+  };
+  const cfgWithType = {
+    ...newCfg,
+    type: providerId,
+    ...model ? { model } : {}
+  };
+  let provider = deps.providerRegistry.has(providerId) ? deps.providerRegistry.create(cfgWithType) : makeProviderFromConfig(providerId, cfgWithType);
+  if (deps.modelsRegistry) {
+    const resolvedModel = model ?? config.model;
+    provider = await withCatalogCapabilities(deps.modelsRegistry, providerId, provider, {
+      ...cfgWithType,
+      model: resolvedModel
+    });
+    await refreshRuntimeModelCatalog({
+      modelsRegistry: deps.modelsRegistry,
+      reason: `${providerId}/${resolvedModel}`
+    });
+    const mc = await resolveRuntimeMaxContext({
+      modelsRegistry: deps.modelsRegistry,
+      config,
+      provider,
+      runtimeProviderConfig: cfgWithType,
+      providerId,
+      modelId: resolvedModel
+    });
+    if (mc && mc > 0) provider.capabilities.maxContext = mc;
+  }
+  return provider;
+}
+async function resolveHostSubagentReasoningConfig(deps, providerId, modelId) {
+  if (!deps.modelsRegistry) return void 0;
+  try {
+    return (await deps.modelsRegistry.getModel(providerId, modelId))?.capabilities.reasoningConfig;
+  } catch {
+    return void 0;
+  }
+}
+function resolveHostSubagentModelSelection(liveConfig, effectiveCfg, matrixTarget) {
+  let effProvider = effectiveCfg.provider ?? matrixTarget?.provider ?? liveConfig.provider;
+  let effModel = effectiveCfg.model ?? matrixTarget?.model ?? liveConfig.model;
+  const modelPolicy = effectiveCfg.modelPolicy;
+  const closedModelPolicy = modelPolicy?.strict === true;
+  const allowedModels = modelPolicy?.allowed ?? [];
+  if (modelPolicy && !allowedModels.some((target) => target.provider === effProvider && target.model === effModel)) {
+    const firstAllowed = allowedModels[0];
+    if (!firstAllowed) throw new Error(`Agent "${effectiveCfg.role}" has no allowed models.`);
+    effProvider = firstAllowed.provider;
+    effModel = firstAllowed.model;
+  }
+  const fallbackProfile = modelPolicy ? void 0 : effectiveCfg.fallbackProfile ?? matrixTarget?.fallbackProfile;
+  const runtimeOverride = effectiveCfg.modelRuntime ?? matrixTarget?.modelRuntime;
+  const startupTargets = modelPolicy ? [
+    { provider: effProvider, model: effModel },
+    ...modelPolicy.fallbacks ?? [],
+    ...closedModelPolicy || effProvider === liveConfig.provider && effModel === liveConfig.model ? [] : [{ provider: liveConfig.provider, model: liveConfig.model }]
+  ] : [
+    { provider: effProvider, model: effModel },
+    ...effProvider === liveConfig.provider && effModel === liveConfig.model ? [] : [{ provider: liveConfig.provider, model: liveConfig.model }]
+  ];
+  return {
+    effProvider,
+    effModel,
+    fallbackProfile,
+    runtimeOverride,
+    closedModelPolicy,
+    startupTargets
+  };
+}
+
 // src/fleet/host-shadow-pass.ts
 async function runHostShadowPass(ctx, reason) {
   try {
@@ -3801,84 +3936,6 @@ function aggregateFleetUsage(completed) {
   return { rows, totals };
 }
 
-// src/fleet/host-provider.ts
-import { makeProviderFromConfig, withCatalogCapabilities } from "@wrongstack/providers";
-async function buildHostSubagentProvider(deps, config, overrideId, model) {
-  const requestedProviderId = overrideId ?? config.provider;
-  const providerId = requestedProviderId === config.provider || config.providers?.[requestedProviderId] !== void 0 || deps.providerRegistry.has(requestedProviderId) ? requestedProviderId : config.provider;
-  const newCfg = config.providers?.[providerId] ?? {
-    type: providerId,
-    apiKey: config.apiKey,
-    baseUrl: config.baseUrl
-  };
-  const cfgWithType = {
-    ...newCfg,
-    type: providerId,
-    ...model ? { model } : {}
-  };
-  let provider = deps.providerRegistry.has(providerId) ? deps.providerRegistry.create(cfgWithType) : makeProviderFromConfig(providerId, cfgWithType);
-  if (deps.modelsRegistry) {
-    const resolvedModel = model ?? config.model;
-    provider = await withCatalogCapabilities(deps.modelsRegistry, providerId, provider, {
-      ...cfgWithType,
-      model: resolvedModel
-    });
-    await refreshRuntimeModelCatalog({
-      modelsRegistry: deps.modelsRegistry,
-      reason: `${providerId}/${resolvedModel}`
-    });
-    const mc = await resolveRuntimeMaxContext({
-      modelsRegistry: deps.modelsRegistry,
-      config,
-      provider,
-      runtimeProviderConfig: cfgWithType,
-      providerId,
-      modelId: resolvedModel
-    });
-    if (mc && mc > 0) provider.capabilities.maxContext = mc;
-  }
-  return provider;
-}
-async function resolveHostSubagentReasoningConfig(deps, providerId, modelId) {
-  if (!deps.modelsRegistry) return void 0;
-  try {
-    return (await deps.modelsRegistry.getModel(providerId, modelId))?.capabilities.reasoningConfig;
-  } catch {
-    return void 0;
-  }
-}
-function resolveHostSubagentModelSelection(liveConfig, effectiveCfg, matrixTarget) {
-  let effProvider = effectiveCfg.provider ?? matrixTarget?.provider ?? liveConfig.provider;
-  let effModel = effectiveCfg.model ?? matrixTarget?.model ?? liveConfig.model;
-  const modelPolicy = effectiveCfg.modelPolicy;
-  const closedModelPolicy = modelPolicy?.strict === true;
-  const allowedModels = modelPolicy?.allowed ?? [];
-  if (modelPolicy && !allowedModels.some((target) => target.provider === effProvider && target.model === effModel)) {
-    const firstAllowed = allowedModels[0];
-    if (!firstAllowed) throw new Error(`Agent "${effectiveCfg.role}" has no allowed models.`);
-    effProvider = firstAllowed.provider;
-    effModel = firstAllowed.model;
-  }
-  const fallbackProfile = modelPolicy ? void 0 : effectiveCfg.fallbackProfile ?? matrixTarget?.fallbackProfile;
-  const runtimeOverride = effectiveCfg.modelRuntime ?? matrixTarget?.modelRuntime;
-  const startupTargets = modelPolicy ? [
-    { provider: effProvider, model: effModel },
-    ...modelPolicy.fallbacks ?? [],
-    ...closedModelPolicy || effProvider === liveConfig.provider && effModel === liveConfig.model ? [] : [{ provider: liveConfig.provider, model: liveConfig.model }]
-  ] : [
-    { provider: effProvider, model: effModel },
-    ...effProvider === liveConfig.provider && effModel === liveConfig.model ? [] : [{ provider: liveConfig.provider, model: liveConfig.model }]
-  ];
-  return {
-    effProvider,
-    effModel,
-    fallbackProfile,
-    runtimeOverride,
-    closedModelPolicy,
-    startupTargets
-  };
-}
-
 // src/fleet/host-subagent-factory.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync, statSync } from "node:fs";
@@ -3914,6 +3971,7 @@ import { AutoApprovePermissionPolicy } from "@wrongstack/core/security";
 
 // src/fleet/host-context.ts
 import {
+  DEFAULT_EAGER_SKILL_LIMIT,
   loadProjectSkillAugmentation,
   missingRequiredRuntimeTools,
   missingRuntimeCapabilities,
@@ -3924,7 +3982,8 @@ import {
 } from "@wrongstack/core/agent-catalog";
 import { TOKENS as TOKENS3 } from "@wrongstack/core/kernel";
 import { getSageRetrieval } from "@wrongstack/sage";
-var EAGER_SKILL_LIMIT = 3;
+var EAGER_SKILL_LIMIT = DEFAULT_EAGER_SKILL_LIMIT;
+var MIN_TRIMMED_BODY_CHARS = 800;
 async function resolveHostSubagentSkillResolution(deps, roster, subCfg, availableToolNames = []) {
   const role = subCfg.role;
   const rosterEntry = role ? roster[role] : void 0;
@@ -3940,10 +3999,11 @@ async function resolveHostSubagentSkillResolution(deps, roster, subCfg, availabl
   ];
   const skillNames = role ? rankRoleSkills(role, pool, deps.projectRoot, EAGER_SKILL_LIMIT) : pool.slice(0, EAGER_SKILL_LIMIT);
   if (skillNames.length === 0 || !deps.skillLoader) {
-    return { content: directContent ?? "", selected: [], dropped };
+    return { content: directContent ?? "", selected: [], dropped, trimmed: [] };
   }
   const resolved = [];
   const selected = [];
+  const trimmed = [];
   let usedChars = 0;
   const maxChars = 16e3;
   const maxCharsPerSkill = 4e3;
@@ -3972,10 +4032,12 @@ async function resolveHostSubagentSkillResolution(deps, roster, subCfg, availabl
         continue;
       }
       const augmentation = role ? loadProjectSkillAugmentation(role, skillName, deps.projectRoot) : "";
-      const entry = [
+      const compose = (bodyChars) => [
         `## Skill: ${skillName}`,
         "",
-        body.slice(0, maxCharsPerSkill),
+        body.length > bodyChars ? `${body.slice(0, bodyChars).trimEnd()}
+
+_(body trimmed)_` : body,
         ...augmentation ? [
           "",
           `### Project practice for \`${skillName}\``,
@@ -3985,9 +4047,16 @@ async function resolveHostSubagentSkillResolution(deps, roster, subCfg, availabl
           augmentation
         ] : []
       ].join("\n");
+      let entry = compose(maxCharsPerSkill);
       if (usedChars + entry.length > maxChars) {
-        dropped[skillName] = "budget";
-        continue;
+        const overhead = entry.length - Math.min(body.length, maxCharsPerSkill);
+        const room = maxChars - usedChars - overhead;
+        if (!augmentation || room < MIN_TRIMMED_BODY_CHARS) {
+          dropped[skillName] = "budget";
+          continue;
+        }
+        entry = compose(room);
+        trimmed.push(skillName);
       }
       resolved.push(entry);
       selected.push(skillName);
@@ -4010,7 +4079,7 @@ Apply these skills first for this assignment.
 
 ${resolved.join("\n\n---\n\n")}` : void 0
   ].filter((section) => Boolean(section));
-  return { content: sections.join("\n\n"), selected, dropped };
+  return { content: sections.join("\n\n"), selected, dropped, trimmed };
 }
 async function retrieveHostSubagentMemory(deps, getLeaderMode, subCfg, taskContext) {
   const memoryPort = deps.container.safeResolve(TOKENS3.MemoryStore);
@@ -4222,10 +4291,8 @@ function createParentSubagentSessionWriter(parentSession) {
     flush: () => parentSession.flush(),
     close: async () => {
     },
-    recordFileChange: () => {
-    },
-    recordSideEffect: () => {
-    },
+    recordFileChange: (input) => parentSession.recordFileChange(input),
+    recordSideEffect: (input) => parentSession.recordSideEffect(input),
     writeCheckpoint: async () => {
     },
     writeFileSnapshot: async () => {
@@ -4239,6 +4306,21 @@ function createParentSubagentSessionWriter(parentSession) {
     }
   };
 }
+function withParentFileSnapshots(subagentSession, parentSession) {
+  if (subagentSession === parentSession) return subagentSession;
+  return new Proxy(subagentSession, {
+    get(target, property, receiver) {
+      if (property === "recordFileChange") {
+        return (input) => {
+          target.recordFileChange(input);
+          parentSession.recordFileChange(input);
+        };
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
 
 // src/fleet/host-subagent-factory.ts
 function createHostSubagentFactory(config, host) {
@@ -4370,12 +4452,13 @@ ${audienceMemory.map((text) => `- ${text}`).join("\n")}`
       baseSystem.push({ type: "text", text: skillResolution.content });
     }
     const droppedSkills = Object.entries(skillResolution.dropped);
-    if (droppedSkills.length > 0) {
+    if (droppedSkills.length > 0 || skillResolution.trimmed.length > 0) {
       host.deps.events.emit("subagent.skills.dropped", {
         sessionId: host.deps.session.id,
         role: effectiveCfg.role,
         selected: skillResolution.selected,
-        dropped: Object.fromEntries(droppedSkills)
+        dropped: Object.fromEntries(droppedSkills),
+        ...skillResolution.trimmed.length > 0 ? { trimmed: skillResolution.trimmed } : {}
       });
     }
     const rawRolePrompt = effectiveCfg.systemPromptOverride ?? effectiveCfg.prompt ?? (effectiveCfg.role ? host.roster[effectiveCfg.role]?.prompt : void 0);
@@ -4391,12 +4474,15 @@ ${audienceMemory.map((text) => `- ${text}`).join("\n")}`
     }
     let subSession;
     if (host.sessionFactory) {
-      subSession = await host.sessionFactory.createSubagentSession({
-        subagentId: subagentName,
-        provider: effProvider,
-        model: effModel,
-        title: `subagent: ${subagentName}`
-      });
+      subSession = withParentFileSnapshots(
+        await host.sessionFactory.createSubagentSession({
+          subagentId: subagentName,
+          provider: effProvider,
+          model: effModel,
+          title: `subagent: ${subagentName}`
+        }),
+        host.deps.session
+      );
     } else {
       subSession = createParentSubagentSessionWriter(host.deps.session);
     }
@@ -4445,7 +4531,11 @@ ${audienceMemory.map((text) => `- ${text}`).join("\n")}`
       maxToolTimeoutMs: config.tools?.maxToolTimeoutMs ?? 3e5,
       perIterationOutputCapBytes: config.tools?.perIterationOutputCapBytes ?? 1e5,
       tracer: void 0,
-      requireKanbanGovernance: true
+      // Kanban tracks work; it does not gate it. Off unless the operator opts
+      // in — and then subagents inherit it, because a worker dispatched by
+      // `kanban_queue` already carries board/task/lease identity in ctx.meta
+      // and can satisfy the same gate its leader was held to.
+      requireKanbanGovernance: config.tools?.kanbanGovernance ?? false
     });
     const subagentConfigStore = host.deps.configStore;
     const pipelines = createDefaultPipelines();
@@ -4836,6 +4926,12 @@ var MultiAgentHost = class {
       // pass so director.fleetManager is never undefined
       brain: this.opts.brain,
       roster: this.roster,
+      // The dispatcher is two-stage by design — keyword heuristic, then a model
+      // to break the tie — but nothing ever supplied stage two here, so every
+      // description the keywords could not resolve fell through to the
+      // `executor` generalist. That is one half of why a 77-role roster was
+      // being served by a handful of agents.
+      dispatchClassifier: (task, candidates) => this.classifyDispatch(task, candidates),
       // Fire-and-forget report-back: when an assign_task completes with no
       // pending await, post the result to this session's leader via the
       // project mailbox (injected inline before the leader's next step).
@@ -5324,6 +5420,28 @@ var MultiAgentHost = class {
     }
     return this.learningOptimizer;
   }
+  /**
+   * Break a dispatch tie with a model when the keyword heuristic is ambiguous.
+   *
+   * Routes through the `dispatcher` model-matrix slot when one is configured —
+   * picking a role is a short classification, so it belongs on a cheap fast
+   * model rather than the leader's — and the session default otherwise.
+   * Returning `null` on any failure leaves the dispatcher on its heuristic
+   * result, so routing degrades rather than breaking a spawn.
+   */
+  async classifyDispatch(task, candidates) {
+    try {
+      const config = this.deps.configStore.get();
+      const target = resolveSubagentModelTarget2(config, "dispatcher");
+      const providerId = target?.provider ?? config.provider;
+      const model = target?.model ?? config.model;
+      if (!providerId || !model) return null;
+      const provider = await buildHostSubagentProvider(this.deps, config, providerId, model);
+      return await makeProviderClassifier(provider, model)(task, candidates);
+    } catch {
+      return null;
+    }
+  }
   /**
    * Resolve a model for the distillation pass. Uses the `memory-curator` slot
    * of the model matrix when one is configured — curating learned knowledge is
@@ -6417,6 +6535,58 @@ function setupDirectorAndAutonomy(deps) {
   };
 }
 
+// src/wiring/domain-glossary.ts
+import { getSageService } from "@wrongstack/sage";
+var DOMAIN_GLOSSARY_LIMIT = 16;
+function createDomainGlossaryAdapter(memoryStore) {
+  return {
+    async list(scope, limit) {
+      try {
+        const service = getSageService(memoryStore);
+        if (!service) return [];
+        if (scope !== "project-memory") return [];
+        const effectiveLimit = Math.min(
+          Math.max(1, limit ?? DOMAIN_GLOSSARY_LIMIT),
+          DOMAIN_GLOSSARY_LIMIT
+        );
+        const hits = await service.searchSage("domain-term", { limit: effectiveLimit });
+        return hits.map((hit) => sageToGlossaryEntry(hit));
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+function sageToGlossaryEntry(sage) {
+  const priority = sage.importance >= 0.9 ? "critical" : sage.importance >= 0.75 ? "high" : sage.importance >= 0.4 ? "medium" : "low";
+  return {
+    scope: "project-memory",
+    text: sage.text,
+    ts: sage.updatedAt || sage.createdAt,
+    type: "reference",
+    tags: sage.tags.slice(),
+    priority,
+    confidence: sage.confidence,
+    lastAccessed: sage.lastAccessedAt
+  };
+}
+
+// src/wiring/domain-terms-mirror.ts
+import { writeErr as writeErr2 } from "@wrongstack/core/utils";
+import { SageDomainTermExtractor } from "@wrongstack/sage";
+async function refreshDomainTermsMirror(options) {
+  try {
+    const extractor = new SageDomainTermExtractor();
+    return await extractor.writeDomainTermsFile(options.projectRoot, options.memoryStore);
+  } catch (err) {
+    writeErr2(
+      `[wrongstack] domain-terms mirror refresh failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+
 // src/wiring/eternal-command-handlers.ts
 import { EternalAutonomyEngine as EternalAutonomyEngine2, ParallelEternalEngine } from "@wrongstack/core/execution";
 function createEternalCommandHandlers(input) {
@@ -7750,7 +7920,20 @@ function createAgent(params) {
     tracer: params.tracer,
     logger,
     hookRunner: params.hookRunner,
-    requireKanbanGovernance: true
+    // Kanban tracks work; it does not gate it. When this was hard-wired `true`
+    // a mutating tool was refused until a managed card existed, carried a
+    // description and acceptance criteria, and had been started — so the
+    // session spent its effort on card ceremony instead of the work the card
+    // describes. Cards still advance and boards still mirror; path-scoped
+    // `boundary` policies (the actual access control) are unaffected and still
+    // enforced.
+    //
+    // It stays OFF by default, but is now an operator switch rather than a
+    // literal: `tools.kanbanGovernance: true` opts an installation in. The
+    // four hosts (this pipeline, mcp-serve, acp-server-agent, and the fleet
+    // subagent factory) must resolve it identically, or a subagent would run
+    // under a different contract than the leader that dispatched it.
+    requireKanbanGovernance: params.config.tools.kanbanGovernance ?? false
   };
   const toolExecutor = new ToolExecutor2(params.tools, toolExecutorOptions);
   void bootstrapMailboxBridgeAtStartup({
@@ -7771,6 +7954,7 @@ function createAgent(params) {
     events: params.events,
     pipelines: params.pipelines,
     context: params.context,
+    refreshSystemPrompt: true,
     maxIterations: params.config.tools.maxIterations,
     iterationTimeoutMs: params.config.tools.iterationTimeoutMs,
     executionStrategy: params.config.tools.defaultExecutionStrategy,
@@ -8262,7 +8446,7 @@ import {
   watchProviderConfig
 } from "@wrongstack/core/storage";
 import { withCatalogCapabilities as withCatalogCapabilities2 } from "@wrongstack/providers";
-import { getSageService } from "@wrongstack/sage";
+import { getSageService as getSageService2 } from "@wrongstack/sage";
 
 // src/wiring/fallback-gate.ts
 function createFallbackGate(_events) {
@@ -8401,7 +8585,7 @@ function setupProviderRuntime(deps) {
     })
   );
   if (cfg.features.memory && cfg.features.memoryConsolidation !== false) {
-    const consSage = getSageService(memoryStore);
+    const consSage = getSageService2(memoryStore);
     agent.extensions.register(
       new SessionMemoryConsolidator({
         memoryStore,
@@ -8818,88 +9002,11 @@ async function setupCodebaseIndexing(deps) {
 
 // src/wiring/sage.ts
 import {
-  createSageContextMonitorMiddleware,
-  createSageToolCallMiddleware,
-  createSageTurnMiddleware,
-  getSageRetrieval as getSageRetrieval2,
-  InjectionTracker
+  AUTO_HYGIENE_INTERVAL_MS,
+  _resetAutoHygieneThrottleForTesting,
+  sageHygieneOptionsFromConfig,
+  setupSage
 } from "@wrongstack/sage";
-var lastAutoHygieneAt = 0;
-var AUTO_HYGIENE_INTERVAL_MS = 60 * 6e4;
-function setupSage(deps) {
-  const cfg = deps.config.Sage;
-  const noop = async () => {
-  };
-  if (deps.config.features.memory === false) return noop;
-  if (cfg?.enabled === false) return noop;
-  if (!deps.memoryStore) return noop;
-  const memoryStore = deps.memoryStore;
-  const retrieval = getSageRetrieval2(memoryStore);
-  if (!retrieval) {
-    deps.logger.debug("sage middleware skipped: memory store does not support retrieval");
-    return noop;
-  }
-  const injectionTracker = new InjectionTracker();
-  if (cfg?.inject?.toolResults !== false) {
-    deps.pipelines.toolCall.use(
-      createSageToolCallMiddleware({
-        memory: retrieval,
-        maxHintsPerTool: cfg?.inject?.maxHintsPerTool,
-        maxCharsPerTool: cfg?.inject?.maxCharsPerTool,
-        taskAware: cfg?.inject?.taskAware,
-        minScore: cfg?.inject?.minScore,
-        minImportance: cfg?.inject?.minImportance,
-        relationFloor: cfg?.inject?.relationFloor,
-        repeatCooldownMs: cfg?.inject?.repeatCooldownMs,
-        verifyOnMutation: cfg?.hygiene?.autoOnFileChange,
-        triggers: cfg?.inject?.triggers,
-        tracker: injectionTracker,
-        events: deps.events,
-        getSessionId: deps.getSessionId
-      })
-    );
-  }
-  if (cfg?.inject?.turnContext === true) {
-    deps.pipelines.request.use(
-      createSageTurnMiddleware({
-        memory: retrieval,
-        maxMemories: cfg?.inject?.maxTurnMemories,
-        maxChars: cfg?.inject?.maxCharsPerTurn,
-        minScore: cfg?.inject?.minScore,
-        metadataWeight: cfg?.retrieval?.metadataWeight,
-        tracker: injectionTracker,
-        getSessionId: deps.getSessionId
-      })
-    );
-  }
-  deps.pipelines.request.use(
-    createSageContextMonitorMiddleware({
-      tracker: injectionTracker,
-      events: deps.events,
-      getSessionId: deps.getSessionId
-    })
-  );
-  return async () => {
-    await retrieval.flushPendingCounters?.();
-    if (cfg?.hygiene?.autoAfterSession === false) return;
-    const now = Date.now();
-    if (now - lastAutoHygieneAt < AUTO_HYGIENE_INTERVAL_MS) {
-      deps.logger.debug(
-        `sage auto-hygiene skipped: last run ${Math.round((now - lastAutoHygieneAt) / 1e3)}s ago (throttle: ${AUTO_HYGIENE_INTERVAL_MS / 1e3}s)`
-      );
-      return;
-    }
-    await memoryStore.hygiene?.({
-      retentionDays: cfg?.hygiene?.retentionDays,
-      sessionRetentionDays: cfg?.hygiene?.sessionRetentionDays,
-      archiveLowConfidenceAfterDays: cfg?.hygiene?.archiveLowConfidenceAfterDays,
-      archiveUnusedAfterDays: cfg?.hygiene?.archiveUnusedAfterDays,
-      unusedMinInjections: cfg?.hygiene?.unusedMinInjections,
-      purgeDeletedAfterDays: cfg?.hygiene?.purgeDeletedAfterDays
-    });
-    lastAutoHygieneAt = now;
-  };
-}
 
 // src/wiring/runtime-dispatch-state.ts
 async function prepareRuntimeDispatch(input) {
@@ -8909,7 +9016,8 @@ async function prepareRuntimeDispatch(input) {
     memoryStore: input.memoryStore,
     logger: input.logger,
     events: input.events,
-    getSessionId: () => input.agent.ctx.session.id
+    getSessionId: () => input.agent.ctx.session.id,
+    projectRoot: input.projectRoot
   });
   const disposeIndexing = await setupCodebaseIndexing({
     config: input.getConfig(),
@@ -8954,6 +9062,7 @@ async function prepareRuntimeDispatch(input) {
       owner,
       category: tool.category ?? "Other",
       enabled: !input.toolRegistry.isDisabled(tool.name),
+      exposure: input.toolRegistry.isDisabled(tool.name) ? "disabled" : input.toolRegistry.isExposedToProvider(tool.name) ? "direct" : "lazy",
       mutating: tool.mutating,
       permission: tool.permission,
       descMode: getToolDescriptionMode(input.toolRegistry, tool.name),
@@ -9688,38 +9797,6 @@ ${diff}`;
   return "chore: update";
 }
 
-// src/services/dispatch-classifier.ts
-import { makeLLMClassifier } from "@wrongstack/core/coordination";
-function makeProviderClassifier(provider, model) {
-  return makeLLMClassifier(async (prompt) => {
-    const ctrl = new AbortController();
-    const timeout = setTimeout(() => ctrl.abort(), 15e3);
-    try {
-      const resp = await provider.complete(
-        {
-          model,
-          system: [
-            {
-              type: "text",
-              text: 'You are an agent router. Choose the single best agent for the task. Reply with ONLY a compact JSON object {"role":"...","reason":"..."}.'
-            }
-          ],
-          messages: [{ role: "user", content: [{ type: "text", text: prompt }] }],
-          maxTokens: 120,
-          temperature: 0
-        },
-        { signal: ctrl.signal }
-      );
-      const content = resp.content;
-      return Array.isArray(content) ? content[0]?.text ?? "" : "";
-    } catch {
-      return "";
-    } finally {
-      clearTimeout(timeout);
-    }
-  });
-}
-
 // src/services/mcp-management.ts
 import {
   color as color8,
@@ -10681,10 +10758,17 @@ ${lines.join("\n")}`;
           const learned = loadProjectAgentLearned(role, projectRoot);
           const kn = loadRoleKnowledgeManifest(role, projectRoot);
           const developedSkills = listProjectSkillAugmentations(role, projectRoot);
+          const stats = getProjectAgentLearnStats(role, projectRoot);
           const lines = [`${color11.bold(role)} project identity:`];
           if (developedSkills.length > 0) {
             lines.push(`  skills developed: ${developedSkills.join(", ")}`);
           }
+          if (stats.entryCount > 0) {
+            const hitRate = stats.directiveHitRate === null ? "no directive exercised yet" : `${Math.round(stats.directiveHitRate * 100)}% hit rate over ${stats.appliedEntryCount} exercised`;
+            lines.push(
+              `  directives: ${stats.entryCount} buffered \xB7 ${hitRate} \xB7 ${stats.deadEntryCount} never used`
+            );
+          }
           if (cfg) lines.push(`  config: ${JSON.stringify(cfg)}`);
           if (kn)
             lines.push(
@@ -12886,6 +12970,7 @@ var SOURCE_LABELS = {
   "leader-after-task": "leader-after-task (post-tool summary)",
   contributor: "contributor",
   ledger: "completed-work ledger",
+  glossary: "project jargon dictionary",
   nextsteps: "next-steps gate",
   other: "other (untagged)"
 };
@@ -13697,6 +13782,8 @@ var KNOWN_TOP_LEVEL_KEYS = [
   "fallbackBridge",
   "fallbackProfiles",
   "fallbackAuto",
+  "fallbackMaxLastResortCandidates",
+  "fallbackStickiness",
   "hooks",
   "plugins",
   "pluginManager",
@@ -13842,6 +13929,37 @@ function diagnoseConfig(cfg, plugins = []) {
       }
     }
   }
+  if ("fallbackMaxLastResortCandidates" in fixed) {
+    const v = fixed["fallbackMaxLastResortCandidates"];
+    const n = coerceNumber(v);
+    if (n === void 0) {
+      delete fixed["fallbackMaxLastResortCandidates"];
+      findings.push({
+        path: "fallbackMaxLastResortCandidates",
+        problem: `expected a non-negative number, got ${JSON.stringify(v)}`,
+        severity: "error",
+        fix: "removed (built-in default of 12 applies)"
+      });
+    } else {
+      const clamped = Math.max(0, Math.floor(n));
+      if (clamped !== v) {
+        fixed["fallbackMaxLastResortCandidates"] = clamped;
+        findings.push({
+          path: "fallbackMaxLastResortCandidates",
+          problem: `expected a non-negative integer, got ${JSON.stringify(v)}`,
+          severity: "error",
+          fix: `set to ${clamped}`
+        });
+      } else if (clamped === 0) {
+        findings.push({
+          path: "fallbackMaxLastResortCandidates",
+          problem: "is 0 \u2014 last-resort auto-discovery append is disabled",
+          severity: "warning",
+          fix: "no change (explicit user choice)"
+        });
+      }
+    }
+  }
   if ("fleet" in fixed) {
     if (!isPlainObject(fixed["fleet"])) {
       findings.push({
@@ -14673,6 +14791,9 @@ function buildFallbackCommand(opts) {
     const favorites = config.favoriteModels ?? [];
     const bridge = config.fallbackBridge?.trim();
     const auto = config.fallbackAuto !== false;
+    const rawCap = config.fallbackMaxLastResortCandidates;
+    const capValue = typeof rawCap === "number" && Number.isFinite(rawCap) && rawCap >= 0 ? Math.floor(rawCap) : 12;
+    const capLabel = capValue === 0 ? color24.dim("disabled") : color24.green(String(capValue));
     const filteredReason = (ref) => refInactiveReason(ref, config);
     const lines = [
       `${color24.bold("WrongStack")} ${color24.dim("\u2014 Fallback chain")}`,
@@ -14710,6 +14831,7 @@ function buildFallbackCommand(opts) {
       "",
       `  ${color24.bold("auto")}  ${auto ? color24.green("on") : color24.dim("off")}  ${color24.dim("/fallback auto on|off")}`,
       `  ${color24.bold("favorites only")}  ${config.favoriteModelsOnly ? color24.green("on") : color24.dim("off")}  ${color24.dim("/fallback fav only on|off")}`,
+      `  ${color24.bold("last-resort cap")}  ${capLabel}  ${color24.dim("(max auto-discovered models appended, 0=disabled)")}`,
       "",
       `  ${color24.bold("profiles")} ${Object.keys(profiles).length ? "" : color24.dim("(none)")}`,
       ...Object.entries(profiles).sort(([a], [b]) => a.localeCompare(b)).flatMap(([name, chain]) => {
@@ -17298,7 +17420,6 @@ function buildIntakeCommand(opts) {
 import { color as color32 } from "@wrongstack/core/utils";
 import {
   addCheckToTask,
-  addColumn,
   addDependency,
   addGoalMetricToTask,
   addNoteToTask,
@@ -17324,7 +17445,6 @@ import {
   parseLinesIntoTasks,
   releaseTaskClaim,
   removeBoard,
-  removeColumn,
   removeTask,
   setTaskChain,
   splitTask,
@@ -17752,9 +17872,6 @@ var KANBAN_COMMAND_HELP = [
   "",
   "  /kanban task check add <boardId> <taskId> <desc>  Add success check",
   "",
-  "  /kanban column add <boardId> <title>    Add column",
-  "  /kanban column rm <boardId> <colId>     Remove column",
-  "",
   "  /kanban generate <description>     Auto-generate board from text",
   "  /kanban export <boardId>           Export board as markdown",
   "  /kanban graph export <boardId> [graphId]  Save board as SDD TaskGraph",
@@ -17930,9 +18047,6 @@ function buildKanbanCommand(opts) {
       if (cmd === "task" || cmd === "t") {
         return handleTaskSubcommand(opts, projectRoot, rest, showHelp);
       }
-      if (cmd === "column" || cmd === "col" || cmd === "c") {
-        return handleColumnSubcommand(projectRoot, rest, showHelp);
-      }
       return {
         message: unknownSubcommand(
           cmd,
@@ -18612,27 +18726,6 @@ ${summary}` };
   }
   return showHelp();
 }
-async function handleColumnSubcommand(projectRoot, args, showHelp) {
-  const [sub, boardId, ...rest] = args;
-  if (!sub || !boardId) return showHelp();
-  if (sub === "add") {
-    const title = rest.join(" ");
-    if (!title) return { message: color32.red("Usage: /kanban column add <boardId> <title>") };
-    const result = await addColumn(projectRoot, boardId, { title });
-    if (!result) return { message: color32.red(`Board not found: ${boardId}`) };
-    return { message: color32.green(`\u2705 Column added: ${result.column.title}`) };
-  }
-  if (sub === "rm" || sub === "remove" || sub === "delete") {
-    const colId = rest[0];
-    if (!colId) return { message: color32.red("Usage: /kanban column rm <boardId> <columnId>") };
-    const updated = await removeColumn(projectRoot, boardId, colId, {
-      moveTasksToColumnId: rest[1]
-    });
-    if (!updated) return { message: color32.red(`Column not found: ${colId}`) };
-    return { message: color32.green(`\u2705 Column removed: ${colId}`) };
-  }
-  return showHelp();
-}
 function extractSpawnedSubagentId(summary) {
   return summary.match(/Spawned subagent\s+([^\s]+)/)?.[1];
 }
@@ -18650,12 +18743,6 @@ function formatLifecycleDiagnosis(err, action) {
       if (field === "assignee") {
         return `\u274C /kanban task ${action} needs an assignee. Run \`/kanban task assign <boardId> <taskId> <agent>\` first.`;
       }
-      if (field === "dueDate") {
-        return `\u274C /kanban task ${action} needs a valid due date. Add one via the \`kanban.update_task\` tool action (patch.dueDate = "YYYY-MM-DD").`;
-      }
-      if (field === "labels") {
-        return `\u274C /kanban task ${action} needs at least one label. Add one via the \`kanban.update_task\` tool action (patch.labels = ["..."]).`;
-      }
       if (field === "childTaskIds") {
         return `\u274C /kanban task ${action} is an atomic parent with no persisted children. Decompose it via the kanban tool (\`split_atomic\`) before moving it forward.`;
       }
@@ -20253,7 +20340,11 @@ function formatSageShow(stats, memories) {
 
 // src/slash-commands/memory-triage.ts
 import { toErrorMessage as toErrorMessage17 } from "@wrongstack/core/utils";
-import { formatTriageReport, runTriage } from "@wrongstack/sage";
+import {
+  fileTriageProposals,
+  formatTriageReport,
+  runTriage
+} from "@wrongstack/sage";
 var DEFAULT_MAX_PHASE3 = 1e3;
 var DEFAULT_MAX_PHASE4_PAIRS = 50;
 async function runTriageCommand(opts, args) {
@@ -20450,41 +20541,7 @@ async function applyDispatch(Sage, report) {
   return lines.join("\n");
 }
 async function fileProposals(Sage, proposals) {
-  const inputs = [];
-  const failures = [];
-  let filed = 0;
-  for (const proposal of proposals) {
-    const input = {
-      text: proposal.memoryText,
-      targetMemoryId: proposal.memoryId,
-      reviewReason: proposal.reason,
-      suggestedAction: proposal.suggestedAction,
-      kind: "memory_review",
-      scope: "project",
-      importance: 0.5,
-      confidence: 0.9,
-      tags: ["triage"],
-      anchors: [],
-      sources: [{ type: "project_instruction" }]
-    };
-    inputs.push(input);
-    try {
-      await Sage.createCandidate(input);
-      filed++;
-    } catch (err) {
-      failures.push({
-        memoryId: proposal.memoryId,
-        error: toErrorMessage17(err)
-      });
-    }
-  }
-  return {
-    filed,
-    failed: failures.length,
-    total: proposals.length,
-    failures,
-    inputs
-  };
+  return fileTriageProposals(Sage, proposals);
 }
 
 // src/slash-commands/memory.ts
@@ -31404,7 +31461,7 @@ async function runInteractive(cliCtx) {
     activeMode
   });
   if (modeResult.kind === "exit") {
-    writeErr2(`${modeResult.message}
+    writeErr3(`${modeResult.message}
 `);
     await reader.close();
     return modeResult.code;
@@ -31425,6 +31482,15 @@ async function runInteractive(cliCtx) {
     container,
     modeStore,
     memoryStore,
+    // Provide a narrow domain-term adapter so the prompt builder emits a
+    // compact `[Project Jargon Dictionary]` block. Closes over the resolved
+    // SAGE `memoryStore` (a `MemoryPort`) and uses the typed
+    // `SageServiceLike` capability (NOT `@wrongstack/sage-mcp` — the
+    // in-process consumer rule from `packages/sage/docs/direct-icp-usage.md`).
+    // Returns only memories tagged `domain-term` via the capability's
+    // `searchSage` op, which performs the tag-filter at the SQL layer rather
+    // than scanning the whole corpus on every prompt build.
+    domainGlossary: createDomainGlossaryAdapter(memoryStore),
     skillLoader,
     sessionRef,
     autonomyModeRef,
@@ -31445,6 +31511,7 @@ async function runInteractive(cliCtx) {
     pathJoiner: { join: (a, b) => path31.join(a, b) },
     systemPromptBuilderToken: TOKENS9.SystemPromptBuilder
   });
+  await refreshDomainTermsMirror({ projectRoot, memoryStore });
   const toolRegistry = new ToolRegistry2();
   registerBuiltinTools({
     toolRegistry,
@@ -31540,7 +31607,26 @@ async function runInteractive(cliCtx) {
     }
   });
   const { context, planPath, session } = sessResult;
+  context.meta["promptOnlineAgents"] = onlineAgents;
   sessionRef.current = session;
+  const replayFlag = flags["replay"];
+  const recordFlag = flags["record"];
+  if (typeof replayFlag === "string" || recordFlag === true) {
+    const { bindReplayToContainer } = await import("./replay-XU6ZD7GM.js");
+    const mode = recordFlag === true ? "record" : "replay";
+    bindReplayToContainer({
+      container,
+      wpaths,
+      // Recording follows the live session across `/resume` and new-session
+      // swaps; replaying is pinned to the id the user named.
+      sessionId: typeof replayFlag === "string" ? replayFlag : () => sessionRef.current?.id ?? "",
+      mode,
+      logger
+    });
+    logger.info(
+      `replay: ProviderRunner bound in '${mode}' mode for session ${typeof replayFlag === "string" ? replayFlag : session.id}`
+    );
+  }
   const governanceHandle = await setupCliGovernance({
     projectRoot,
     projectId: wpaths.projectSlug,
@@ -32075,7 +32161,7 @@ async function runInteractive(cliCtx) {
     onEvent: evOn
   });
   const savedProviderCfg = config.providers?.[config.provider];
-  const { execute } = await import("./execution-MVOH6PAQ.js");
+  const { execute } = await import("./execution-YMBD7YWC.js");
   const stopHeapWatchdog = startSharedHeapWatchdog({
     collectStats: () => {
       const hqQueue = hqPublisherRef.current?.getQueueStats();
@@ -32126,6 +32212,11 @@ async function runInteractive(cliCtx) {
         events,
         slashRegistry,
         tokenCounter,
+        // Forward the boot sessionRef so `resumeSession` can repoint
+        // it when an in-process `/resume` swaps the active writer.
+        // Without this, provider-side `getSessionId` callbacks and the
+        // record-mode binding keep referring to the boot session.
+        sessionRef,
         activateSessionIdentity: activateSession,
         config,
         configStore,
@@ -32308,4 +32399,4 @@ export {
   CLI_VERSION,
   runInteractive
 };
-//# sourceMappingURL=cli-main-37XO26GK.js.map
+//# sourceMappingURL=cli-main-W3T56YCY.js.map