supipowers 1.5.3 → 2.0.0

package/src/storage/plans.ts

@@ -1,16 +1,15 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { normalizeLineEndings } from "../text.js";
-import type { Plan, PlanTask, TaskComplexity } from "../types.js";
+import type { Plan, PlanTask, TaskComplexity, WorkspaceTarget } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
 
 function getPlansDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "plans");
+  return getProjectStatePath(paths, cwd, "plans");
 }
 
-/** List all saved plans */
-export function listPlans(paths: PlatformPaths, cwd: string): string[] {
-  const dir = getPlansDir(paths, cwd);
+function listPlanFiles(dir: string): string[] {
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir)
@@ -19,6 +18,16 @@ export function listPlans(paths: PlatformPaths, cwd: string): string[] {
     .reverse();
 }
 
+/** List all saved plans */
+export function listPlans(paths: PlatformPaths, cwd: string): string[] {
+  return listPlanFiles(getPlansDir(paths, cwd));
+}
+
+/** List all saved plans for a specific workspace target. */
+export function listTargetPlans(paths: PlatformPaths, target: WorkspaceTarget): string[] {
+  return listPlanFiles(getProjectTargetStatePath(paths, target, "plans"));
+}
+
 /** Read a plan file by name */
 export function readPlanFile(paths: PlatformPaths, cwd: string, name: string): string | null {
   const filePath = path.join(getPlansDir(paths, cwd), name);

package/src/storage/qa-sessions.ts

@@ -1,14 +1,20 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { E2eSessionLedger } from "../qa/types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
+import type { E2eSessionLedger } from "../qa/types.js";
+
+function getSessionsDir(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string {
+  if (target) {
+    return getProjectTargetStatePath(paths, target, "qa-sessions");
+  }
 
-function getSessionsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "qa-sessions");
+  return getProjectStatePath(paths, cwd, "qa-sessions");
 }
 
-export function getSessionDir(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getSessionsDir(paths, cwd), sessionId);
+export function getSessionDir(paths: PlatformPaths, cwd: string, sessionId: string, target?: WorkspaceTarget): string {
+  return path.join(getSessionsDir(paths, cwd, target), sessionId);
 }
 
 /** Generate a unique QA session ID */
@@ -21,8 +27,8 @@ export function generateSessionId(): string {
 }
 
 /** Create a new QA session */
-export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger): void {
-  const sessionDir = getSessionDir(paths, cwd, ledger.id);
+export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger, target?: WorkspaceTarget): void {
+  const sessionDir = getSessionDir(paths, cwd, ledger.id, target);
   fs.mkdirSync(sessionDir, { recursive: true });
   fs.writeFileSync(
     path.join(sessionDir, "ledger.json"),
@@ -31,8 +37,8 @@ export function createSession(paths: PlatformPaths, cwd: string, ledger: E2eSess
 }
 
 /** Load a QA session ledger */
-export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string): E2eSessionLedger | null {
-  const filePath = path.join(getSessionDir(paths, cwd, sessionId), "ledger.json");
+export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  const filePath = path.join(getSessionDir(paths, cwd, sessionId, target), "ledger.json");
   if (!fs.existsSync(filePath)) return null;
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf-8"));
@@ -42,14 +48,14 @@ export function loadSession(paths: PlatformPaths, cwd: string, sessionId: string
 }
 
 /** Update a QA session ledger */
-export function updateSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger): void {
-  const filePath = path.join(getSessionDir(paths, cwd, ledger.id), "ledger.json");
+export function updateSession(paths: PlatformPaths, cwd: string, ledger: E2eSessionLedger, target?: WorkspaceTarget): void {
+  const filePath = path.join(getSessionDir(paths, cwd, ledger.id, target), "ledger.json");
   fs.writeFileSync(filePath, JSON.stringify(ledger, null, 2) + "\n");
 }
 
 /** List all QA sessions, newest first */
-export function listSessions(paths: PlatformPaths, cwd: string): string[] {
-  const dir = getSessionsDir(paths, cwd);
+export function listSessions(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): string[] {
+  const dir = getSessionsDir(paths, cwd, target);
   if (!fs.existsSync(dir)) return [];
   return fs
     .readdirSync(dir)
@@ -59,9 +65,9 @@ export function listSessions(paths: PlatformPaths, cwd: string): string[] {
 }
 
 /** Find the latest session with incomplete phases */
-export function findActiveSession(paths: PlatformPaths, cwd: string): E2eSessionLedger | null {
-  for (const sessionId of listSessions(paths, cwd)) {
-    const ledger = loadSession(paths, cwd, sessionId);
+export function findActiveSession(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  for (const sessionId of listSessions(paths, cwd, target)) {
+    const ledger = loadSession(paths, cwd, sessionId, target);
     if (!ledger) continue;
     const allCompleted = Object.values(ledger.phases).every(
       (p) => p.status === "completed",
@@ -72,9 +78,9 @@ export function findActiveSession(paths: PlatformPaths, cwd: string): E2eSession
 }
 
 /** Find the latest session with failed test results */
-export function findSessionWithFailures(paths: PlatformPaths, cwd: string): E2eSessionLedger | null {
-  for (const sessionId of listSessions(paths, cwd)) {
-    const ledger = loadSession(paths, cwd, sessionId);
+export function findSessionWithFailures(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget): E2eSessionLedger | null {
+  for (const sessionId of listSessions(paths, cwd, target)) {
+    const ledger = loadSession(paths, cwd, sessionId, target);
     if (!ledger) continue;
     if (ledger.results.some((r) => r.status === "fail")) return ledger;
   }

package/src/storage/reliability-metrics.ts

@@ -0,0 +1,180 @@
+// src/storage/reliability-metrics.ts
+//
+// Local-first reliability metrics. Each AI-heavy command appends one
+// ReliabilityRecord per attempt to .omp/supipowers/reliability/events.jsonl.
+// /supi:status and /supi:doctor read these records to surface concrete
+// numbers (parse-success rate, blocked rate, retries-per-run, fallback
+// counts) instead of vibes.
+//
+// Storage format: append-only JSONL. One record per line. Robust to partial
+// writes — readers skip malformed lines rather than aborting.
+//
+// Non-goals:
+//   - Hosted telemetry (records never leave the project)
+//   - Streaming queries (everything is in-memory after read)
+//   - Cross-cwd aggregation in a single read (callers pass the cwd they want)
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { PlatformPaths } from "../platform/types.js";
+import { getProjectStatePath } from "../workspace/state-paths.js";
+import type { ReliabilityOutcome, ReliabilityRecord, ReliabilitySummary } from "../types.js";
+
+const EVENTS_FILE = "events.jsonl";
+const RELIABILITY_DIR = "reliability";
+
+function getReliabilityDir(paths: PlatformPaths, cwd: string): string {
+  return getProjectStatePath(paths, cwd, RELIABILITY_DIR);
+}
+
+function getEventsPath(paths: PlatformPaths, cwd: string): string {
+  return path.join(getReliabilityDir(paths, cwd), EVENTS_FILE);
+}
+
+/**
+ * Append a single reliability record. Best-effort: failures are swallowed
+ * because metrics must never crash the workflow they observe.
+ */
+export function appendReliabilityRecord(
+  paths: PlatformPaths,
+  cwd: string,
+  record: ReliabilityRecord,
+): void {
+  try {
+    fs.mkdirSync(getReliabilityDir(paths, cwd), { recursive: true });
+    fs.appendFileSync(getEventsPath(paths, cwd), JSON.stringify(record) + "\n");
+  } catch {
+    // Swallow — metrics observability must not break the workflow.
+  }
+}
+
+/**
+ * Read all reliability records for the given cwd. Malformed lines are
+ * skipped silently (best-effort recovery). Returns an empty array when the
+ * file does not exist yet.
+ */
+export function readReliabilityRecords(paths: PlatformPaths, cwd: string): ReliabilityRecord[] {
+  const file = getEventsPath(paths, cwd);
+  if (!fs.existsSync(file)) return [];
+  const records: ReliabilityRecord[] = [];
+  let raw: string;
+  try {
+    raw = fs.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line) as ReliabilityRecord;
+      // Minimal shape check — drop records missing the required fields.
+      if (
+        typeof parsed?.ts === "string" &&
+        typeof parsed.command === "string" &&
+        typeof parsed.outcome === "string" &&
+        typeof parsed.attempts === "number"
+      ) {
+        records.push(parsed);
+      }
+    } catch {
+      // Skip malformed line.
+    }
+  }
+  return records;
+}
+
+const ZERO_OUTCOME_COUNTS: Record<ReliabilityOutcome, number> = {
+  ok: 0,
+  blocked: 0,
+  "retry-exhausted": 0,
+  fallback: 0,
+  "agent-error": 0,
+};
+
+/**
+ * Aggregate records into per-command summaries. Returns one summary per
+ * distinct `command` that appears in `records`, sorted by command name.
+ */
+export function summarizeReliabilityRecords(records: ReliabilityRecord[]): ReliabilitySummary[] {
+  const buckets = new Map<string, ReliabilityRecord[]>();
+  for (const record of records) {
+    const list = buckets.get(record.command) ?? [];
+    list.push(record);
+    buckets.set(record.command, list);
+  }
+
+  const summaries: ReliabilitySummary[] = [];
+  for (const [command, list] of buckets) {
+    const byOutcome = { ...ZERO_OUTCOME_COUNTS };
+    let attemptsTotal = 0;
+    let lastRecordedAt: string | null = null;
+    for (const r of list) {
+      byOutcome[r.outcome] = (byOutcome[r.outcome] ?? 0) + 1;
+      attemptsTotal += r.attempts;
+      if (!lastRecordedAt || r.ts > lastRecordedAt) lastRecordedAt = r.ts;
+    }
+    summaries.push({
+      command,
+      total: list.length,
+      byOutcome,
+      avgAttempts: list.length > 0 ? attemptsTotal / list.length : 0,
+      lastRecordedAt,
+    });
+  }
+
+  summaries.sort((a, b) => a.command.localeCompare(b.command));
+  return summaries;
+}
+
+/**
+ * Convenience: load + summarize in one call.
+ */
+export function loadReliabilitySummaries(
+  paths: PlatformPaths,
+  cwd: string,
+): ReliabilitySummary[] {
+  return summarizeReliabilityRecords(readReliabilityRecords(paths, cwd));
+}
+
+const RELIABILITY_OUTCOMES: ReliabilityOutcome[] = [
+  "ok",
+  "blocked",
+  "retry-exhausted",
+  "fallback",
+  "agent-error",
+];
+
+/**
+ * Render a concise, aligned reliability section suitable for TUI output.
+ * When no records exist yet, returns a single non-alarming empty-state line.
+ */
+export function formatReliabilitySection(summaries: ReliabilitySummary[]): string[] {
+  if (summaries.length === 0) {
+    return ["Reliability: no records yet (metrics appear after AI-heavy commands run)."];
+  }
+
+  const total = summaries.reduce((n, s) => n + s.total, 0);
+  const nameWidth = Math.max(...summaries.map((s) => s.command.length));
+  const colWidths: Record<ReliabilityOutcome, number> = { ...ZERO_OUTCOME_COUNTS };
+  for (const s of summaries) {
+    for (const outcome of RELIABILITY_OUTCOMES) {
+      const w = String(s.byOutcome[outcome] ?? 0).length;
+      if (w > colWidths[outcome]) colWidths[outcome] = w;
+    }
+  }
+  for (const outcome of RELIABILITY_OUTCOMES) {
+    if (colWidths[outcome] < 1) colWidths[outcome] = 1;
+  }
+
+  const lines: string[] = [`Reliability (last ${total} record${total === 1 ? "" : "s"})`];
+  for (const s of summaries) {
+    const name = s.command.padEnd(nameWidth);
+    const counts = RELIABILITY_OUTCOMES
+      .map((o) => `${o} ${String(s.byOutcome[o] ?? 0).padStart(colWidths[o])}`)
+      .join(" ");
+    const avg = s.avgAttempts.toFixed(1);
+    const last = s.lastRecordedAt ? s.lastRecordedAt.slice(0, 10) : "\u2014";
+    lines.push(`${name}  ${counts}   avg-attempts ${avg}   last ${last}`);
+  }
+  return lines;
+}

package/src/storage/reports.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { GateResult, GateStatus, ReviewReport } from "../types.js";
 import type { PlatformPaths } from "../platform/types.js";
+import type { GateResult, GateStatus, ReviewReport, WorkspaceTarget } from "../types.js";
+import { getProjectTargetStatePath } from "../workspace/state-paths.js";
 
-function getReportsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, "reports");
+function getReportsDir(paths: PlatformPaths, target: WorkspaceTarget): string {
+  return getProjectTargetStatePath(paths, target, "reports");
 }
 
 function isGateStatus(value: unknown): value is GateStatus {
@@ -43,8 +44,8 @@ function isReviewReport(value: unknown): value is ReviewReport {
 }
 
 /** Save a review report */
-export function saveReviewReport(paths: PlatformPaths, cwd: string, report: ReviewReport): string {
-  const dir = getReportsDir(paths, cwd);
+export function saveReviewReport(paths: PlatformPaths, target: WorkspaceTarget, report: ReviewReport): string {
+  const dir = getReportsDir(paths, target);
   fs.mkdirSync(dir, { recursive: true });
   const filename = `review-${report.timestamp.slice(0, 10)}.json`;
   const filePath = path.join(dir, filename);
@@ -53,8 +54,8 @@ export function saveReviewReport(paths: PlatformPaths, cwd: string, report: Revi
 }
 
 /** Load the latest review report */
-export function loadLatestReport(paths: PlatformPaths, cwd: string): ReviewReport | null {
-  const dir = getReportsDir(paths, cwd);
+export function loadLatestReport(paths: PlatformPaths, target: WorkspaceTarget): ReviewReport | null {
+  const dir = getReportsDir(paths, target);
   if (!fs.existsSync(dir)) return null;
 
   const files = fs

package/src/storage/review-sessions.ts

@@ -1,15 +1,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { PlatformPaths } from "../platform/types.js";
-import type { ReviewSession } from "../types.js";
 import { isReviewSession } from "../review/types.js";
+import type { ReviewSession, WorkspaceTarget } from "../types.js";
+import { getProjectStatePath, getProjectTargetStatePath } from "../workspace/state-paths.js";
 
 const SESSIONS_DIR = "reviews";
 const ITERATIONS_DIR = "iterations";
 const AGENTS_DIR = "agents";
 
-function getSessionsDir(paths: PlatformPaths, cwd: string): string {
-  return paths.project(cwd, SESSIONS_DIR);
+function getSessionsDir(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget | null): string {
+  return target
+    ? getProjectTargetStatePath(paths, target, SESSIONS_DIR)
+    : getProjectStatePath(paths, cwd, SESSIONS_DIR);
 }
 
 function ensureLayout(sessionDir: string): void {
@@ -17,8 +20,13 @@ function ensureLayout(sessionDir: string): void {
   fs.mkdirSync(path.join(sessionDir, AGENTS_DIR), { recursive: true });
 }
 
-function getLedgerPath(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getReviewSessionDir(paths, cwd, sessionId), "session.json");
+function getLedgerPath(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): string {
+  return path.join(getReviewSessionDir(paths, cwd, sessionId, target), "session.json");
 }
 
 function resolveArtifactPath(sessionDir: string, relativePath: string): string {
@@ -35,8 +43,13 @@ function resolveArtifactPath(sessionDir: string, relativePath: string): string {
   return resolved;
 }
 
-export function getReviewSessionDir(paths: PlatformPaths, cwd: string, sessionId: string): string {
-  return path.join(getSessionsDir(paths, cwd), sessionId);
+export function getReviewSessionDir(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): string {
+  return path.join(getSessionsDir(paths, cwd, target), sessionId);
 }
 
 export function generateReviewSessionId(now = new Date()): string {
@@ -47,14 +60,24 @@ export function generateReviewSessionId(now = new Date()): string {
   return `review-${date}-${time}-${suffix}`;
 }
 
-export function createReviewSession(paths: PlatformPaths, cwd: string, session: ReviewSession): void {
-  const sessionDir = getReviewSessionDir(paths, cwd, session.id);
+export function createReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  session: ReviewSession,
+  target?: WorkspaceTarget | null,
+): void {
+  const sessionDir = getReviewSessionDir(paths, cwd, session.id, target);
   ensureLayout(sessionDir);
-  fs.writeFileSync(getLedgerPath(paths, cwd, session.id), `${JSON.stringify(session, null, 2)}\n`);
+  fs.writeFileSync(getLedgerPath(paths, cwd, session.id, target), `${JSON.stringify(session, null, 2)}\n`);
 }
 
-export function loadReviewSession(paths: PlatformPaths, cwd: string, sessionId: string): ReviewSession | null {
-  const ledgerPath = getLedgerPath(paths, cwd, sessionId);
+export function loadReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  target?: WorkspaceTarget | null,
+): ReviewSession | null {
+  const ledgerPath = getLedgerPath(paths, cwd, sessionId, target);
   if (!fs.existsSync(ledgerPath)) {
     return null;
   }
@@ -67,15 +90,20 @@ export function loadReviewSession(paths: PlatformPaths, cwd: string, sessionId:
   }
 }
 
-export function updateReviewSession(paths: PlatformPaths, cwd: string, session: ReviewSession): void {
+export function updateReviewSession(
+  paths: PlatformPaths,
+  cwd: string,
+  session: ReviewSession,
+  target?: WorkspaceTarget | null,
+): void {
   session.updatedAt = new Date().toISOString();
-  const sessionDir = getReviewSessionDir(paths, cwd, session.id);
+  const sessionDir = getReviewSessionDir(paths, cwd, session.id, target);
   ensureLayout(sessionDir);
-  fs.writeFileSync(getLedgerPath(paths, cwd, session.id), `${JSON.stringify(session, null, 2)}\n`);
+  fs.writeFileSync(getLedgerPath(paths, cwd, session.id, target), `${JSON.stringify(session, null, 2)}\n`);
 }
 
-export function listReviewSessions(paths: PlatformPaths, cwd: string): string[] {
-  const sessionsDir = getSessionsDir(paths, cwd);
+export function listReviewSessions(paths: PlatformPaths, cwd: string, target?: WorkspaceTarget | null): string[] {
+  const sessionsDir = getSessionsDir(paths, cwd, target);
   if (!fs.existsSync(sessionsDir)) {
     return [];
   }
@@ -93,8 +121,9 @@ export function writeReviewArtifact(
   sessionId: string,
   relativePath: string,
   payload: unknown,
+  target?: WorkspaceTarget | null,
 ): string {
-  const sessionDir = getReviewSessionDir(paths, cwd, sessionId);
+  const sessionDir = getReviewSessionDir(paths, cwd, sessionId, target);
   ensureLayout(sessionDir);
   const artifactPath = resolveArtifactPath(sessionDir, relativePath);
   fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
@@ -106,8 +135,14 @@ export function writeReviewArtifact(
   return artifactPath;
 }
 
-export function readReviewArtifact(paths: PlatformPaths, cwd: string, sessionId: string, relativePath: string): string | null {
-  const sessionDir = getReviewSessionDir(paths, cwd, sessionId);
+export function readReviewArtifact(
+  paths: PlatformPaths,
+  cwd: string,
+  sessionId: string,
+  relativePath: string,
+  target?: WorkspaceTarget | null,
+): string | null {
+  const sessionDir = getReviewSessionDir(paths, cwd, sessionId, target);
   const artifactPath = resolveArtifactPath(sessionDir, relativePath);
   if (!fs.existsSync(artifactPath)) {
     return null;

package/src/tool-catalog/active-tool-controller.ts

@@ -0,0 +1,164 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+import { getMetricsStore, getSessionId } from "../context-mode/hooks.js";
+import { getProjectStateDir } from "../workspace/state-paths.js";
+import type { Platform } from "../platform/types.js";
+import { normalizeSystemPromptBlocks, systemPromptText } from "../platform/system-prompt.js";
+import type { McpRegistry } from "../mcp/types.js";
+import type { SupipowersConfig } from "../types.js";
+import { planActiveTools } from "./active-tool-planner.js";
+import { detectContextMode } from "../context-mode/detector.js";
+import { getShadowedNativeTools } from "../context-mode/routing.js";
+
+export interface ActiveToolControllerDeps {
+  loadMcpRegistryForCwd(cwd: string): McpRegistry;
+  consumePendingTags(): string[];
+}
+
+type BeforeAgentStartEventLike = {
+  prompt?: string;
+  systemPrompt?: string | string[];
+};
+
+type BeforeAgentStartContextLike = {
+  cwd?: string;
+  getSystemPrompt?: () => unknown;
+  getContextUsage?: () => {
+    tokens?: number | null;
+    contextWindow?: number | null;
+    percent?: number | null;
+  } | null;
+};
+
+export function registerActiveToolController(
+  platform: Platform,
+  config: SupipowersConfig,
+  _deps: ActiveToolControllerDeps,
+): void {
+  if (!config.contextMode.enabled || !config.contextMode.lazyTools.enabled) return;
+
+  platform.on("before_agent_start", async (
+    event: BeforeAgentStartEventLike,
+    ctx: BeforeAgentStartContextLike = {},
+  ) => {
+    if (typeof platform.getAllTools !== "function") return undefined;
+    if (typeof platform.setActiveTools !== "function") return undefined;
+    if (typeof ctx.getSystemPrompt !== "function") return undefined;
+
+    const cwd = typeof ctx.cwd === "string" && ctx.cwd.length > 0 ? ctx.cwd : process.cwd();
+    let registry: McpRegistry = { schemaVersion: 1, servers: {} };
+    try {
+      registry = _deps.loadMcpRegistryForCwd(cwd);
+    } catch (error) {
+      (platform as any).logger?.warn?.("supi-lazy-tools: failed to load MCP registry", error);
+    }
+
+    let pendingTags: string[] = [];
+    try {
+      pendingTags = _deps.consumePendingTags();
+    } catch (error) {
+      (platform as any).logger?.warn?.("supi-lazy-tools: failed to consume MCP tags", error);
+    }
+
+    let plan;
+    try {
+      plan = planActiveTools({
+        prompt: event.prompt ?? "",
+        currentActive: platform.getActiveTools(),
+        allTools: platform.getAllTools(),
+        lazyTools: config.contextMode.lazyTools,
+        mcpServers: registry.servers,
+        pendingTags,
+        cacheHandlesEnabled: config.contextMode.cacheHandles.enabled,
+      });
+    } catch (error) {
+      (platform as any).logger?.warn?.("supi-lazy-tools: active-tool planning failed", error);
+      return { systemPrompt: normalizeSystemPromptBlocks(event.systemPrompt) };
+    }
+
+    // Hide native tools fully shadowed by an active ctx_* replacement.
+    // Without this, the LLM sees Search/Find/Fetch in the tool catalog and
+    // routinely tries them, only to receive routing-block errors. Filtering
+    // here removes them from the system prompt that OMP rebuilds below.
+    if (config.contextMode.enforceRouting) {
+      const status = detectContextMode(plan.activeTools);
+      const shadowed = new Set(getShadowedNativeTools(status));
+      if (shadowed.size > 0) {
+        plan.activeTools = plan.activeTools.filter((tool) => !shadowed.has(tool));
+      }
+    }
+
+    if (plan.activeTools.length === 0 || arraysEqual(plan.activeTools, platform.getActiveTools())) {
+      return undefined;
+    }
+
+    try {
+      await platform.setActiveTools(plan.activeTools);
+    } catch (error) {
+      (platform as any).logger?.warn?.("supi-lazy-tools: setActiveTools failed", error);
+      return { systemPrompt: normalizeSystemPromptBlocks(event.systemPrompt) };
+    }
+
+    const rebuiltPrompt = ctx.getSystemPrompt();
+    const rebuiltPromptBlocks = normalizeSystemPromptBlocks(rebuiltPrompt);
+    recordLazyToolsMetric({
+      platform,
+      cwd,
+      beforePrompt: systemPromptText(event.systemPrompt),
+      afterPrompt: systemPromptText(rebuiltPrompt),
+      activeTools: plan.activeTools,
+      contextUsage: ctx.getContextUsage?.() ?? null,
+    });
+
+    return { systemPrompt: rebuiltPromptBlocks };
+  });
+}
+
+function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  return a.every((value, index) => value === b[index]);
+}
+
+
+function recordLazyToolsMetric(opts: {
+  platform: Platform;
+  cwd: string;
+  beforePrompt: string;
+  afterPrompt: string;
+  activeTools: string[];
+  contextUsage: { tokens?: number | null; contextWindow?: number | null; percent?: number | null } | null;
+}): void {
+  const store = getMetricsStore();
+  if (!store) return;
+
+  try {
+    const projectSlug = basename(getProjectStateDir(opts.platform.paths, opts.cwd));
+    const sortedActiveTools = [...opts.activeTools].sort();
+    const sourceHash = createHash("sha256")
+      .update(projectSlug)
+      .update("\0")
+      .update(sortedActiveTools.join("\0"))
+      .digest("hex");
+
+    store.record({
+      session_id: getSessionId(),
+      ts: Date.now(),
+      layer: "L7",
+      tool: "(system)",
+      processor: "lazy-tools",
+      before_bytes: byteLength(opts.beforePrompt),
+      after_bytes: byteLength(opts.afterPrompt),
+      cache_hit: 0,
+      unique_source_hash: sourceHash,
+      context_tokens: opts.contextUsage?.tokens ?? null,
+      context_window: opts.contextUsage?.contextWindow ?? null,
+      context_percent: opts.contextUsage?.percent ?? null,
+    });
+  } catch (error) {
+    (opts.platform as any).logger?.warn?.("supi-lazy-tools: metrics record failed", error);
+  }
+}
+
+function byteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}