supipowers 1.5.3 → 2.0.0

package/src/context-mode/routing.ts

@@ -47,10 +47,22 @@ export function isBashSearchCommand(command: unknown): boolean {
   return BASH_SEARCH_PATTERNS.some((p) => p.test(command));
 }
 
-/** Check if a Read call is a full-file read (no limit/offset/sel = likely analysis, not edit prep) */
+/** Check if a Read call is a full-file read (no limit/offset/path selector = likely analysis, not edit prep) */
 export function isFullFileRead(input: Record<string, unknown> | undefined): boolean {
   if (!input) return true;
-  return input.limit == null && input.offset == null && input.sel == null;
+  return input.limit == null && input.offset == null && !hasEmbeddedReadSelector(input);
+}
+
+const READ_PATH_SELECTOR_RE = /:(?:raw|\d+(?:[-+]\d+)?|L\d+(?:-L?\d+|\+L?\d+)?)$/i;
+
+function getReadPath(input: Record<string, unknown>): string | null {
+  const path = input.path ?? input.file_path;
+  return typeof path === "string" && path.length > 0 ? path : null;
+}
+
+function hasEmbeddedReadSelector(input: Record<string, unknown>): boolean {
+  const path = getReadPath(input);
+  return path != null && READ_PATH_SELECTOR_RE.test(path);
 }
 
 /** Block result returned by routing functions */
@@ -63,33 +75,35 @@ export interface BlockResult {
 export function routeToolCall(
   toolName: string,
   input: Record<string, unknown> | undefined,
-  _status: ContextModeStatus,
+  status: ContextModeStatus,
   options: { enforceRouting: boolean; blockHttpCommands: boolean },
 ): BlockResult | undefined {
-  // Native tools are always available — no availability check needed.
+  const searchReplacement = getSearchReplacement(status);
+  const shellSearchReplacement = getShellSearchReplacement(status);
+  const fetchReplacement = status.tools.ctxFetchAndIndex ? "ctx_fetch_and_index" : null;
+  const bashHttpReplacement = getBashHttpReplacement(status);
 
-  // Grep → block, redirect to ctx_search
-  if (options.enforceRouting && toolName === "grep") {
+  // Search → block only when an active search/shell replacement exists.
+  if (options.enforceRouting && toolName === "search" && searchReplacement) {
     return {
       block: true,
-      reason:
-        'Use ctx_search(queries: ["<pattern>"]) or ctx_batch_execute instead of Grep. ' +
-        "Results are indexed and compressed to save context window.",
+      reason: formatSearchReplacementReason(searchReplacement),
     };
   }
 
-  // Find/Glob → block, redirect to ctx_execute or ctx_batch_execute
-  if (options.enforceRouting && toolName === "find") {
+  // Find/Glob → block only when an active shell/search replacement exists.
+  if (options.enforceRouting && toolName === "find" && shellSearchReplacement) {
     return {
       block: true,
       reason:
-        'Use ctx_execute(language: "shell", code: "find ...") or ctx_batch_execute instead of Find/Glob. ' +
-        "Results are indexed and compressed to save context window.",
+        shellSearchReplacement === "ctx_execute"
+          ? 'Use ctx_execute(language: "shell", code: "find ...") or ctx_batch_execute instead of Find/Glob. Results are indexed and compressed to save context window.'
+          : "Use ctx_batch_execute instead of Find/Glob. Results are indexed and compressed to save context window.",
     };
   }
 
-  // Fetch/WebFetch → block, redirect to ctx_fetch_and_index
-  if (toolName === "fetch" || toolName === "web_fetch") {
+  // Fetch/WebFetch → block only when ctx_fetch_and_index is active.
+  if ((toolName === "fetch" || toolName === "web_fetch") && fetchReplacement) {
     return {
       block: true,
       reason:
@@ -102,26 +116,85 @@ export function routeToolCall(
   if (toolName === "bash") {
     const command = input?.command;
 
-    // Bash search commands → block, redirect to ctx_execute
-    if (options.enforceRouting && isBashSearchCommand(command)) {
+    // Bash search commands → block only when an active shell/search replacement exists.
+    if (options.enforceRouting && isBashSearchCommand(command) && shellSearchReplacement) {
       return {
         block: true,
         reason:
-          'Use ctx_execute(language: "shell", code: "<command>") instead of Bash for search commands. ' +
-          "For multiple commands, use ctx_batch_execute. Results stay in sandbox and are auto-indexed.",
+          shellSearchReplacement === "ctx_execute"
+            ? 'Use ctx_execute(language: "shell", code: "<command>") instead of Bash for search commands. For multiple commands, use ctx_batch_execute. Results stay in sandbox and are auto-indexed.'
+            : "Use ctx_batch_execute instead of Bash for search commands. Results stay in sandbox and are auto-indexed.",
       };
     }
 
-    // Bash HTTP commands → block, redirect to ctx_fetch_and_index
-    if (options.blockHttpCommands && isHttpCommand(command)) {
+    // Bash HTTP commands → block only when an active HTTP replacement exists.
+    if (options.blockHttpCommands && isHttpCommand(command) && bashHttpReplacement) {
       return {
         block: true,
-        reason:
-          "Use ctx_fetch_and_index instead of curl/wget. " +
-          "It fetches the URL, indexes the content, and returns a compressed summary.",
+        reason: formatBashHttpReplacementReason(bashHttpReplacement),
       };
     }
   }
 
   return undefined;
+}
+
+function getSearchReplacement(status: ContextModeStatus): "ctx_search" | "ctx_batch_execute" | "ctx_execute" | null {
+  if (status.tools.ctxSearch) return "ctx_search";
+  if (status.tools.ctxBatchExecute) return "ctx_batch_execute";
+  if (status.tools.ctxExecute) return "ctx_execute";
+  return null;
+}
+
+function getShellSearchReplacement(status: ContextModeStatus): "ctx_execute" | "ctx_batch_execute" | null {
+  if (status.tools.ctxExecute) return "ctx_execute";
+  if (status.tools.ctxBatchExecute) return "ctx_batch_execute";
+  return null;
+}
+
+function getBashHttpReplacement(status: ContextModeStatus): "ctx_fetch_and_index" | "ctx_execute" | null {
+  if (status.tools.ctxFetchAndIndex) return "ctx_fetch_and_index";
+  if (status.tools.ctxExecute) return "ctx_execute";
+  return null;
+}
+
+/**
+ * Native host tools that are fully shadowed by an active ctx_* replacement.
+ *
+ * When `enforceRouting` is on, these tools should be hidden from the model's
+ * active tool catalog (via `setActiveTools`) so the LLM never tries to call
+ * them only to receive a routing-block error. The `routeToolCall` runtime
+ * block remains as a safety net for hosts that cannot filter the tool list.
+ *
+ * Bash is intentionally NOT included: it is needed for non-search shell work,
+ * and `routeToolCall` already blocks only the search/HTTP subset.
+ */
+export function getShadowedNativeTools(status: ContextModeStatus): string[] {
+  const shadowed: string[] = [];
+  if (getSearchReplacement(status)) shadowed.push("search");
+  if (getShellSearchReplacement(status)) shadowed.push("find");
+  if (status.tools.ctxFetchAndIndex) {
+    shadowed.push("fetch", "web_fetch");
+  }
+  return shadowed;
+}
+
+function formatSearchReplacementReason(replacement: "ctx_search" | "ctx_batch_execute" | "ctx_execute"): string {
+  if (replacement === "ctx_search") {
+    return 'Use active ctx_search(queries: ["<pattern>"]) instead of Search. Results are indexed and compressed to save context window.';
+  }
+  if (replacement === "ctx_batch_execute") {
+    return "Use active ctx_batch_execute instead of Search. Results are indexed and compressed to save context window.";
+  }
+  return 'Use active ctx_execute(language: "shell", code: "grep ...") instead of Search. Results stay in sandbox to save context window.';
+}
+
+function formatBashHttpReplacementReason(replacement: "ctx_fetch_and_index" | "ctx_execute"): string {
+  if (replacement === "ctx_fetch_and_index") {
+    return (
+      "Use ctx_fetch_and_index instead of curl/wget. " +
+      "It fetches the URL, indexes the content, and returns a compressed summary."
+    );
+  }
+  return 'Use ctx_execute(language: "shell", code: "<http request>") instead of Bash HTTP commands. Only printed summaries enter context.';
 }

package/src/context-mode/sandbox/runners.ts

@@ -5,10 +5,14 @@ export interface LanguageRunner {
   compileCmd?: (srcPath: string, outPath: string) => string[];
 }
 
+function getPythonBinary(): string[] {
+  return process.platform === "win32" ? ["python"] : ["python3"];
+}
+
 const RUNNERS: Record<string, LanguageRunner> = {
   javascript: { binary: ["bun", "run"], fileExt: ".js" },
   typescript: { binary: ["bun", "run"], fileExt: ".ts" },
-  python: { binary: ["python3"], fileExt: ".py" },
+  python: { binary: getPythonBinary(), fileExt: ".py" },
   shell: { binary: ["bash"], fileExt: ".sh" },
   ruby: { binary: ["ruby"], fileExt: ".rb" },
   go: { binary: ["go", "run"], fileExt: ".go" },

package/src/context-mode/snapshot-builder.ts

@@ -19,6 +19,14 @@ function escapeXML(str: string): string {
     .replace(/'/g, "'");
 }
 
+function latestFirst(events: TrackedEvent[]): TrackedEvent[] {
+  return [...events].sort((a, b) => {
+    const byTimestamp = b.timestamp - a.timestamp;
+    if (byTimestamp !== 0) return byTimestamp;
+    return (b.id ?? 0) - (a.id ?? 0);
+  });
+}
+
 interface SnapshotOpts {
   compactCount?: number;
   searchTool?: string;
@@ -81,22 +89,47 @@ function buildReferenceSnapshot(eventStore: EventStore, sessionId: string, opts:
   }
 
   // --- files ---
-  const fileEvents = eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 });
+  const fileEvents = latestFirst(eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 }));
   if (fileEvents.length > 0) {
     const edited = new Set<string>();
     const read = new Set<string>();
+    const modSeen = new Set<string>();
+    const readSeen = new Set<string>();
+    let maskedStale = 0;
     for (const f of fileEvents) {
       const data = safeParse(f.data);
       const p = typeof data?.path === "string" ? data.path : null;
       if (!p) continue;
-      if (data?.op === "edit" || data?.op === "write") edited.add(p);
-      else if (data?.op === "read") read.add(p);
+      const op = data?.op;
+      const sourceKey = typeof data?.sourceHash === "string" ? data.sourceHash : p.replace(/\\/g, "/");
+      if (op === "edit" || op === "write") {
+        if (modSeen.has(sourceKey)) {
+          maskedStale += 1;
+          continue;
+        }
+        modSeen.add(sourceKey);
+        edited.add(p);
+      } else if (op === "read") {
+        if (modSeen.has(sourceKey)) {
+          maskedStale += 1;
+          continue;
+        }
+        if (readSeen.has(sourceKey)) {
+          maskedStale += 1;
+          continue;
+        }
+        readSeen.add(sourceKey);
+        read.add(p);
+      }
     }
+    // Modifications dominate: do not double-list a path that was both edited and read.
+    for (const p of edited) read.delete(p);
     if (edited.size > 0 || read.size > 0) {
       sections.push("");
-      sections.push(`  <files count="${edited.size + read.size}">`);
+      sections.push(`  <files count="${edited.size + read.size}" stale_masked="${maskedStale}">`);
       if (edited.size > 0) sections.push(`    Edited: ${[...edited].map(escapeXML).join(", ")}`);
       if (read.size > 0) sections.push(`    Read: ${[...read].map(escapeXML).join(", ")}`);
+      if (maskedStale > 0) sections.push(`    Masked stale observations: ${maskedStale}`);
       const queryPaths = [...edited, ...read].slice(0, 5);
       sections.push(`    For full details:`);
       sections.push(`    ctx_search(queries: [${queryPaths.map((p) => `"${escapeXML(p)}"`).join(", ")}], source: "session-events")`);
@@ -288,18 +321,28 @@ function buildFallbackSnapshot(eventStore: EventStore, sessionId: string): strin
   }
 
   // Files modified (write/edit only, deduplicated)
-  const fileEvents = eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 });
+  const fileEvents = latestFirst(eventStore.getEvents(sessionId, { categories: ["file"], limit: 200 }));
   const modifiedPaths = new Set<string>();
+  const seenSources = new Set<string>();
+  let maskedStaleFiles = 0;
   for (const f of fileEvents) {
     const data = safeParse(f.data);
-    if (data?.op === "edit" || data?.op === "write") {
-      if (typeof data.path === "string") modifiedPaths.add(data.path);
+    const p = typeof data?.path === "string" ? data.path : null;
+    if (!p) continue;
+    if (data?.op !== "edit" && data?.op !== "write") continue;
+    const sourceKey = typeof data?.sourceHash === "string" ? data.sourceHash : p.replace(/\\/g, "/");
+    if (seenSources.has(sourceKey)) {
+      maskedStaleFiles += 1;
+      continue;
     }
+    seenSources.add(sourceKey);
+    modifiedPaths.add(p);
   }
   if (modifiedPaths.size > 0) {
     sections.push("  <files_modified>");
     const paths = [...modifiedPaths].slice(0, CAPS.files);
     for (const p of paths) sections.push(`    - ${escapeXML(p)}`);
+    if (maskedStaleFiles > 0) sections.push(`    - stale observations masked: ${maskedStaleFiles}`);
     sections.push("  </files_modified>");
   }
 
@@ -346,11 +389,63 @@ function safeParse(json: string): Record<string, unknown> | null {
 function extractTaskContent(data: Record<string, unknown> | null): string | null {
   if (!data?.input) return null;
   const input = data.input as Record<string, unknown>;
-  if (Array.isArray(input.ops)) {
-    const ops = input.ops as Array<{ content?: string; op?: string }>;
-    return ops.map((o) => `${o.op ?? "task"}: ${o.content ?? ""}`).join("; ");
+  if (!Array.isArray(input.ops)) return JSON.stringify(input).slice(0, 100);
+
+  const parts: string[] = [];
+  for (const rawOp of input.ops as Array<Record<string, unknown>>) {
+    if (!rawOp || typeof rawOp !== "object") continue;
+    const verb = typeof rawOp.op === "string" ? rawOp.op : "task";
+
+    if (verb === "init" && Array.isArray(rawOp.list)) {
+      for (const phase of rawOp.list as Array<Record<string, unknown>>) {
+        const items = Array.isArray(phase?.items) ? phase.items : [];
+        for (const item of items) {
+          if (typeof item === "string" && item) parts.push(`init: ${item}`);
+          else if (item && typeof item === "object" && typeof (item as { label?: unknown }).label === "string") {
+            parts.push(`init: ${(item as { label: string }).label}`);
+          }
+        }
+      }
+    } else if (verb === "replace" && Array.isArray(rawOp.phases)) {
+      // Legacy `todo_write` shape (pre-14.5.11): `op:"replace", phases:[{ name, tasks:[{ content }] }]`.
+      // Persisted event rows still carry this shape until 7-day retention expires; we keep
+      // read-side compatibility here so resume snapshots remain truthful for those rows.
+      for (const phase of rawOp.phases as Array<Record<string, unknown>>) {
+        const tasks = Array.isArray(phase?.tasks) ? phase.tasks : [];
+        for (const task of tasks) {
+          const content = task && typeof task === "object" && typeof (task as { content?: unknown }).content === "string"
+            ? (task as { content: string }).content
+            : "";
+          if (content) parts.push(`replace: ${content}`);
+        }
+      }
+    } else if (verb === "append" && Array.isArray(rawOp.items)) {
+      for (const item of rawOp.items) {
+        if (typeof item === "string" && item) parts.push(`append: ${item}`);
+        else if (item && typeof item === "object" && typeof (item as { label?: unknown }).label === "string") {
+          // Legacy append items shaped as objects with `label`.
+          parts.push(`append: ${(item as { label: string }).label}`);
+        }
+      }
+    } else if (verb === "note") {
+      const text = typeof rawOp.text === "string" ? rawOp.text : "";
+      if (text) parts.push(`note: ${text}`);
+    } else {
+      const legacyContent = typeof rawOp.content === "string" ? rawOp.content : "";
+      if (legacyContent) {
+        parts.push(`${verb}: ${legacyContent}`);
+        continue;
+      }
+
+      const target = (typeof rawOp.task === "string" && rawOp.task)
+        || (typeof rawOp.phase === "string" && rawOp.phase)
+        || "all";
+      parts.push(`${verb}: ${target}`);
+    }
   }
-  return JSON.stringify(input).slice(0, 100);
+
+  // Preserve the existing 100-char cap so prompts stay bounded.
+  return parts.length > 0 ? parts.join("; ").slice(0, 100) : null;
 }
 
 function formatErrorSummary(data: Record<string, unknown> | null): string | null {

package/src/context-mode/source-hash.ts

@@ -0,0 +1,173 @@
+// src/context-mode/source-hash.ts
+//
+// Compute the per-row `unique_source_hash` for L1 metrics. The hash exists
+// to power "unique-source share" without storing raw paths or commands. Two
+// invariants:
+//
+//   1. The same logical source produces the same hash regardless of platform
+//      separator or relative-vs-absolute spelling, given the same `cwd`.
+//   2. The same path under two different `projectSlug` values produces
+//      different hashes, so a hash is never a cross-project identifier.
+//
+// Tool inputs are never copied verbatim; only canonicalized prefixes flow
+// into the hash input.
+
+import { createHash } from "node:crypto";
+
+import { canonicalToolName } from "./tool-name.js";
+
+export interface UniqueSourceHashOpts {
+  tool: string;
+  input: Record<string, unknown> | undefined;
+  cwd: string;
+  projectSlug: string;
+}
+
+/**
+ * Detect whether a path string is absolute on either POSIX or Windows.
+ *
+ * Recognized absolute forms:
+ *   - leading `/` (POSIX)
+ *   - drive-letter prefix `[A-Za-z]:` followed by `\` or `/` (Windows)
+ *   - UNC prefix `\\` or `//` (network share / WSL `\\?\` namespace)
+ */
+function isAbsolutePath(p: string): boolean {
+  if (p.length === 0) return false;
+  if (p[0] === "/" || p[0] === "\\") {
+    // Includes both POSIX `/x` and Windows `\\server\share`
+    return true;
+  }
+  // Drive-letter Windows path: `C:\…` or `c:/…`
+  if (/^[A-Za-z]:[\\/]/.test(p)) return true;
+  return false;
+}
+
+/** Normalize separators and collapse `.` / `..` segments using POSIX rules. */
+function toPosix(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+function stripCurrentDirPrefixBeforeWindowsAbsolute(p: string): string {
+  return p.replace(/^\.[\\/]+(?=[A-Za-z]:[\\/])/, "");
+}
+
+
+/** Resolve `pathInput` to a canonical absolute POSIX form. */
+export function canonicalizeSourcePath(pathInput: string, cwd: string): string {
+  const normalizedInput = stripCurrentDirPrefixBeforeWindowsAbsolute(pathInput);
+  const posix = toPosix(normalizedInput);
+  if (isAbsolutePath(normalizedInput)) {
+    return collapsePosix(posix);
+  }
+  const cwdPosix = toPosix(cwd);
+  return collapsePosix(joinPosix(cwdPosix, posix));
+}
+
+/** Lightweight POSIX `path.normalize` — segment-by-segment without depending on
+ *  Node's platform-specific `path.posix.normalize` differences. */
+function collapsePosix(p: string): string {
+  const isAbs = p.startsWith("/");
+  const parts = p.split("/").filter(Boolean);
+  const stack: string[] = [];
+  for (const part of parts) {
+    if (part === ".") continue;
+    if (part === "..") {
+      if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+        stack.pop();
+      } else if (!isAbs) {
+        stack.push("..");
+      }
+      continue;
+    }
+    stack.push(part);
+  }
+  const joined = stack.join("/");
+  return isAbs ? "/" + joined : joined || ".";
+}
+
+function joinPosix(left: string, right: string): string {
+  if (left === "") return right;
+  if (left.endsWith("/")) return left + right;
+  return left + "/" + right;
+}
+
+function sha256Hex(input: string): string {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+/**
+ * Truncate a bash command to a stable, leak-free identifier:
+ *   - split on whitespace, take the first 4 tokens, lowercase them, rejoin.
+ *
+ * Anything past the 4th token (env exports, secrets, file paths, command
+ * arguments) is dropped. The first 4 tokens give us enough resolution to
+ * distinguish `bun run typecheck` from `bun run test` while never copying
+ * the rest of the command into the hash input.
+ */
+function truncateBashCommand(command: string): string {
+  return command
+    .trim()
+    .split(/\s+/)
+    .slice(0, 4)
+    .map((token) => token.toLowerCase())
+    .join(" ");
+}
+
+/**
+ * Produce the unique-source hash, or `null` for tools whose inputs do not
+ * map to a stable source identifier.
+ */
+export function uniqueSourceHash(opts: UniqueSourceHashOpts): string | null {
+  const { tool, input, cwd, projectSlug } = opts;
+  const canonical = canonicalToolName(tool);
+
+  switch (canonical) {
+    case "read":
+    case "open": {
+      const p = typeof input?.path === "string" ? input.path : null;
+      if (!p) return null;
+      const absolute = canonicalizeSourcePath(p, cwd);
+      return sha256Hex(`file:${absolute}:${projectSlug}`);
+    }
+    case "search": {
+      const paths = Array.isArray(input?.paths)
+        ? (input.paths as unknown[]).filter((p): p is string => typeof p === "string")
+        : [];
+      const pattern = typeof input?.pattern === "string" ? input.pattern : "";
+      if (paths.length === 0) {
+        // Pattern-only search (no scope): keep a deterministic salt so distinct
+        // pattern-only calls dedup correctly per-project.
+        return sha256Hex(`search:${pattern}:${projectSlug}`);
+      }
+      // Order matters: OMP runs each path under root-level resolution, so [a,b] != [b,a].
+      // Use SOH (\u0001) as the joiner — it cannot appear in a path on any platform.
+      const joined = paths.map((p) => canonicalizeSourcePath(p, cwd)).join("\u0001");
+      return sha256Hex(`search:${joined}:${pattern}:${projectSlug}`);
+    }
+    case "find": {
+      const paths = Array.isArray(input?.paths)
+        ? (input.paths as unknown[]).filter((p): p is string => typeof p === "string")
+        : [];
+      if (paths.length === 0) {
+        // Defensive: 14.7.x requires `paths`, so this should not happen.
+        return sha256Hex(`find::${projectSlug}`);
+      }
+      const joined = paths.map((p) => canonicalizeSourcePath(p, cwd)).join("\u0001");
+      return sha256Hex(`find:${joined}:${projectSlug}`);
+    }
+    case "edit":
+    case "write": {
+      const p = typeof input?.path === "string" ? input.path : null;
+      if (!p) return null;
+      const absolute = canonicalizeSourcePath(p, cwd);
+      return sha256Hex(`file:${absolute}:${projectSlug}`);
+    }
+    case "bash": {
+      const command = typeof input?.command === "string" ? input.command : "";
+      const truncated = truncateBashCommand(command);
+      return sha256Hex(`bash:${truncated}:${projectSlug}`);
+    }
+    default:
+      return null;
+  }
+}

package/src/context-mode/tool-name.ts

@@ -0,0 +1,11 @@
+// src/context-mode/tool-name.ts
+//
+// OMP 14.3.0 renamed `read` to `open` at the wire level while keeping `read`
+// as a legacy alias. Internally we keep using the historical `read` key so
+// every dispatch site only has to learn one name. Apply this normalizer to
+// the raw `tool_call`/`tool_result` `toolName` before any switch.
+
+/** Map an OMP tool name to its canonical internal key. */
+export function canonicalToolName(name: string): string {
+  return name === "open" ? "read" : name;
+}