pi-smart-compact 9.0.0 → 9.1.0

package/dist/provider-scenario-eval.js

@@ -169,7 +169,7 @@ function getLlmClient() {
 }
 
 // src/constants.ts
-var VERSION = "9.0.0";
+var VERSION = "9.1.0";
 var COMPACT_SYSTEM_PREFIX = "You are an expert conversation summarizer for a coding agent. " + "Produce structured markdown summaries. " + "Follow output format exactly. " + "Use EXACT names \u2014 never paraphrase code identifiers. " + "Trust deterministic extraction data over intuition.";
 var PROFILES = {
   light: {
@@ -325,6 +325,14 @@ var FIVE_MINUTES_MS = 5 * 60 * 1000;
 var ONE_HOUR_MS = 60 * 60 * 1000;
 var SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+var ID_PREFIX = {
+  PROJECT: "proj-",
+  COMPACT_SESSION: "sc-",
+  MULTI_TOOL_USE_SYNTHETIC: "mtu_",
+  OPEN_LOOP: "loop-",
+  DECISION: "decision-",
+  ERROR: "error-"
+};
 var TUNING = {
   EMA_PREV: 0.7,
   EMA_SAMPLE: 0.3,
@@ -443,8 +451,14 @@ function calibrationKey(provider, model) {
 }
 
 // src/utils/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function isTextBlock(c) {
-  return typeof c === "object" && c !== null && c.type === "text" && typeof c.text === "string";
+  return isRecord(c) && c.type === "text" && typeof c.text === "string";
+}
+function isToolCallBlock(c) {
+  return isRecord(c) && c.type === "toolCall" && typeof c.name === "string" && isRecord(c.arguments);
 }
 var KNOWN_METHODS = new Set(["eesv", "single-pass", "heuristic"]);
 var KNOWN_PROFILES = new Set(["light", "balanced", "aggressive"]);
@@ -465,9 +479,37 @@ var GENERIC_BASENAMES = new Set([
   "lib.rs",
   "__init__.py"
 ]);
+var MIN_BARE_BASENAME_LEN = 5;
 function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
 }
+function buildPathNeedles(filePath) {
+  const parts = normalizePath(filePath).split("/").filter(Boolean);
+  if (parts.length === 0)
+    return [];
+  const needles = [];
+  const basename = parts[parts.length - 1];
+  if (!GENERIC_BASENAMES.has(basename) && basename.length >= MIN_BARE_BASENAME_LEN) {
+    needles.push(basename);
+  }
+  for (let j = parts.length - 2;j >= 0; j--) {
+    needles.push(parts.slice(j).join("/"));
+  }
+  return needles;
+}
+function buildUniquePathNeedles(filePath, allPaths) {
+  const normalized = allPaths.map(normalizePath);
+  return buildPathNeedles(filePath).filter((needle) => {
+    let owners = 0;
+    for (const candidate of normalized) {
+      if (candidate === needle || candidate.endsWith("/" + needle))
+        owners++;
+      if (owners > 1)
+        return false;
+    }
+    return owners === 1;
+  });
+}
 function isKnownPathReference(ref, knownPaths) {
   const normalizedRef = normalizePath(ref);
   return knownPaths.some((path) => {
@@ -476,6 +518,74 @@ function isKnownPathReference(ref, knownPaths) {
   });
 }
 
+// src/domain/tool-semantics.ts
+var PATH_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "filename",
+  "file",
+  "target_file",
+  "file_uri",
+  "absolute_path"
+];
+var PAYLOAD_KEYS = [
+  "content",
+  "newText",
+  "oldText",
+  "new_str",
+  "old_str",
+  "new_string",
+  "old_string",
+  "edits",
+  "patch",
+  "replacement"
+];
+var COMMAND_KEYS = ["command", "cmd", "script"];
+function hasPresent(args, keys) {
+  return keys.some((k) => args[k] != null);
+}
+function extractToolPath(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const a = args;
+  for (const k of PATH_KEYS) {
+    const v = a[k];
+    if (typeof v === "string" && v.length > 0)
+      return v;
+  }
+  return;
+}
+function normalizeToolName(name) {
+  if (typeof name !== "string")
+    return "";
+  return name.replace(/^functions[.:/_-]+/i, "").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function nameHas(name, hints) {
+  const words = name.split("_");
+  return hints.some((hint) => words.includes(hint));
+}
+function classifyToolOperation(args, toolName) {
+  const a = args && typeof args === "object" ? args : {};
+  const name = normalizeToolName(toolName);
+  const hasPath = extractToolPath(a) !== undefined;
+  if (hasPath && hasPresent(a, PAYLOAD_KEYS))
+    return "mutate";
+  if (hasPresent(a, COMMAND_KEYS))
+    return "execute";
+  if (hasPath && hasPresent(a, ["text"]) && nameHas(name, ["write", "edit", "patch", "replace", "append", "create", "update", "insert"]))
+    return "mutate";
+  if (hasPath && nameHas(name, ["delete", "remove", "unlink"]))
+    return "delete";
+  if (hasPresent(a, ["pattern", "query", "glob"]) || nameHas(name, ["grep", "search", "find", "glob", "rg"]))
+    return "search";
+  if (nameHas(name, ["list", "ls", "tree"]))
+    return "list";
+  if (hasPath || nameHas(name, ["read"]))
+    return "read";
+  return "unknown";
+}
+
 // src/utils/file-ref-detect.ts
 var CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|rb|cs|cpp|c|h|hpp|swift|kt|scala|php|css|scss|html|json|yaml|yml|toml|md|mdx|sh|sql|tf|ini|env|lock|gradle|xml)$/i;
 var VERSION_RE = /^v?\d+(?:\.\d+)+(?:[-+][\w.-]+)?$/i;
@@ -546,6 +656,7 @@ function parseSummary(markdown) {
   let currentHeading = "";
   let currentKind = "unknown";
   let bodyLines = [];
+  let fence = null;
   let started = false;
   const flush = () => {
     if (!started)
@@ -559,16 +670,31 @@ function parseSummary(markdown) {
       sections.push({ kind: currentKind, heading: currentHeading.trim(), body });
   };
   for (const line of lines) {
-    const m = line.match(HEADING_RE);
-    if (m) {
-      const kind = classifyHeading(m[2]);
-      if (m[1].length <= 2 || kind !== "unknown") {
-        flush();
-        currentHeading = "## " + m[2].trim();
-        currentKind = kind;
-        bodyLines = [];
-        started = true;
-        continue;
+    const fenceMatch = line.match(/^\s{0,3}(`{3,}|~{3,})(.*)$/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      const markerLength = fenceMatch[1].length;
+      if (!fence) {
+        fence = { marker, length: markerLength };
+      } else if (marker === fence.marker && markerLength >= fence.length && !fenceMatch[2].trim()) {
+        fence = null;
+      }
+      if (started)
+        bodyLines.push(line);
+      continue;
+    }
+    if (!fence) {
+      const heading = line.match(HEADING_RE);
+      if (heading) {
+        const kind = classifyHeading(heading[2]);
+        if (heading[1].length <= 2 || kind !== "unknown") {
+          flush();
+          currentHeading = "## " + heading[2].trim();
+          currentKind = kind;
+          bodyLines = [];
+          started = true;
+          continue;
+        }
       }
     }
     if (started)
@@ -583,6 +709,24 @@ function findSection(summary, kind) {
 }
 
 // src/utils/extraction.ts
+function nestedToolCallId(wrapperId, messageIndex, toolIndex, nestedId) {
+  return typeof nestedId === "string" ? nestedId : wrapperId ? wrapperId + "_" + toolIndex : ID_PREFIX.MULTI_TOOL_USE_SYNTHETIC + messageIndex + "_" + toolIndex;
+}
+function flattenToolCallBlock(b) {
+  if (!isToolCallBlock(b))
+    return [];
+  if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+    return b.arguments.tool_uses.map((u) => {
+      const recipient = u?.recipient_name ?? "";
+      return {
+        name: recipient.replace(/^functions\./, ""),
+        id: u?.id ?? undefined,
+        arguments: u?.parameters ?? {}
+      };
+    });
+  }
+  return [{ name: b.name, id: b.id, arguments: b.arguments }];
+}
 function extractText(content) {
   if (typeof content === "string")
     return content;
@@ -596,6 +740,31 @@ function extractText(content) {
     return "";
   }).join("");
 }
+function buildToolCallIndex(msgs) {
+  const idx = new Map;
+  for (let i = 0;i < msgs.length; i++) {
+    const m = msgs[i];
+    if (m.role !== "assistant")
+      continue;
+    const blocks = Array.isArray(m.content) ? m.content : [];
+    for (const b of blocks) {
+      if (!isToolCallBlock(b))
+        continue;
+      if (b.id) {
+        idx.set(b.id, { name: b.name, arguments: b.arguments, msgIndex: i });
+      }
+      if (b.name === "multi_tool_use.parallel" && Array.isArray(b.arguments?.tool_uses)) {
+        const nested = flattenToolCallBlock(b);
+        for (let t = 0;t < nested.length; t++) {
+          const tool = nested[t];
+          const id = nestedToolCallId(b.id, i, t, tool.id);
+          idx.set(id, { name: tool.name, arguments: tool.arguments, msgIndex: i });
+        }
+      }
+    }
+  }
+  return idx;
+}
 var CONSTRAINT_PATTERNS = [
   { re: /\b(?:must|need|require|has to|important)\b.*\b(?:be|use|have|include|support)\b/i, cat: "requirement", conf: TUNING.CONFIDENCE_HIGH },
   { re: /\b(?:don't|never|avoid|shouldn't|must not|do not|no\s+(?:need|want))\b/i, cat: "prohibition", conf: TUNING.CONFIDENCE_MEDIUM },
@@ -725,30 +894,41 @@ function mergeFindings(target, findings) {
   for (const finding of findings)
     target.set(finding.kind, (target.get(finding.kind) ?? 0) + finding.count);
 }
-var SECRET_KEY_NAMES = new Set([
-  "api_key",
-  "apikey",
-  "access_token",
-  "auth_token",
-  "authorization",
-  "password",
-  "passwd",
-  "secret",
-  "secret_key",
-  "secret_access_key",
-  "client_secret",
-  "private_key",
-  "database_url",
-  "connection_string"
-]);
+var SECRET_KEY_NAMES = {
+  api_key: true,
+  apikey: true,
+  access_token: true,
+  auth_token: true,
+  authorization: true,
+  password: true,
+  passwd: true,
+  secret: true,
+  secret_key: true,
+  secret_access_key: true,
+  client_secret: true,
+  private_key: true,
+  database_url: true,
+  connection_string: true,
+  token: true,
+  refresh_token: true,
+  session_token: true,
+  credential: true,
+  credentials: true,
+  cookie: true,
+  set_cookie: true,
+  otp: true,
+  one_time_password: true,
+  pin: true,
+  passcode: true
+};
 function normalizeObjectKey(key) {
   return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
 }
 function isSecretBearingKey(key) {
   const normalized = normalizeObjectKey(key);
-  if (SECRET_KEY_NAMES.has(normalized))
+  if (SECRET_KEY_NAMES[normalized])
     return true;
-  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key)(?:_|$)/.test(normalized);
+  return /(?:^|_)(?:api_key|access_token|auth_token|password|passwd|secret_access_key|client_secret|private_key|refresh_token|session_token|one_time_password|passcode)(?:_|$)/.test(normalized);
 }
 
 class SecretScrubber {
@@ -804,7 +984,8 @@ class SecretScrubber {
       const output = {};
       seen.set(value2, output);
       for (const [key, item] of Object.entries(value2)) {
-        if (this.secretsEnabled && isSecretBearingKey(key) && typeof item === "string" && item.length > 0) {
+        const carriesSecret = typeof item === "string" ? item.length > 0 : item != null;
+        if (this.secretsEnabled && isSecretBearingKey(key) && carriesSecret) {
           output[key] = "[REDACTED:credential]";
           recordCredential();
         } else {
@@ -1069,8 +1250,8 @@ function readMetricsLog(limit = 100) {
     const fd = fs2.openSync(logPath, "r");
     try {
       const buf = Buffer.alloc(wantBytes);
-      fs2.readSync(fd, buf, 0, wantBytes, startPos);
-      let text = buf.toString("utf8");
+      const bytesRead = fs2.readSync(fd, buf, 0, wantBytes, startPos);
+      let text = buf.subarray(0, bytesRead).toString("utf8");
       if (startPos > 0) {
         const nl = text.indexOf(`
 `);
@@ -1117,29 +1298,56 @@ function classifyOutcomeClaim(claim) {
     return "file";
   return "generic";
 }
-function successfulToolSupportsClaim(claim, messages, extraction) {
+var successfulToolEvidenceCache = new WeakMap;
+function successfulToolEvidence(messages) {
+  const cached = successfulToolEvidenceCache.get(messages);
+  if (cached)
+    return cached;
+  const toolCalls = buildToolCallIndex(messages);
+  const evidence = [];
+  for (const message of messages) {
+    if (message.role !== "toolResult" || message.isError)
+      continue;
+    const call = toolCalls.get(message.toolCallId ?? "");
+    if (!call)
+      continue;
+    const result = extractText(message.content).slice(0, 8000);
+    if (!result.trim() || LIKELY_ERROR_RE.test(result))
+      continue;
+    const command = [call.arguments.command, call.arguments.cmd, call.arguments.script].find((value) => typeof value === "string") ?? "";
+    evidence.push({
+      name: normalizeToolName(call.name),
+      operation: classifyToolOperation(call.arguments, call.name),
+      command,
+      path: extractToolPath(call.arguments),
+      result
+    });
+  }
+  successfulToolEvidenceCache.set(messages, evidence);
+  return evidence;
+}
+function successfulToolSupportsClaim(claim, tools, extraction) {
   const shape = semanticShape(claim);
   const category = classifyOutcomeClaim(claim);
   if (category === "error" && extraction.errors.some((error) => error.resolved && hasSemanticEvidence(claim, error.message)))
     return true;
   if (category === "file" && extraction.modifiedFiles.some((file) => claim.toLowerCase().includes(file.path.toLowerCase())))
     return true;
-  for (const message of messages) {
-    if (message.role !== "toolResult" || message.isError)
-      continue;
-    const bounded = extractText(message.content).slice(0, 8000);
-    if (!bounded.trim() || LIKELY_ERROR_RE.test(bounded))
+  for (const tool of tools) {
+    const operationText = tool.name + " " + tool.command;
+    const operationSupports = category === "test" ? /\b(?:test|tests|pytest|jest|vitest|mocha|rspec)\b/i.test(operationText) : category === "build" ? /\b(?:build|compile|typecheck|tsc|check)\b/i.test(operationText) : category === "release" ? /\b(?:deploy|publish|release)\b/i.test(operationText) : category === "file" ? tool.operation === "mutate" || tool.operation === "delete" : category === "error" ? tool.operation === "execute" || tool.operation === "mutate" || tool.operation === "delete" : tool.operation !== "read" && tool.operation !== "search" && tool.operation !== "list";
+    if (!operationSupports)
       continue;
-    if (hasSemanticEvidence(claim, bounded))
+    if (hasSemanticEvidence(claim, tool.result))
       return true;
-    const lower = bounded.toLowerCase();
+    const lower = tool.result.toLowerCase();
     if (category === "test" && /\b\d+\s+(?:tests?\s+)?pass(?:ed)?\b/.test(lower) && !/\b(?:fail(?:ed|ures?)?|errors?)\s*[:=]?\s*[1-9]\d*\b/.test(lower))
       return true;
-    if (category === "build" && /\b(?:build|compile|typecheck)\b/.test(lower) && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
+    if (category === "build" && /\b(?:succeeded|successful|passed|exit(?:ed)?\s+(?:code\s+)?0)\b/.test(lower))
       return true;
-    if (category === "release" && /\b(?:publish|release|deploy)\b/.test(lower) && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
+    if (category === "release" && /\b(?:succeeded|successful|completed|published|deployed|released)\b/.test(lower))
       return true;
-    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, bounded))
+    if (category === "error" && shape.concepts.length > 0 && /\b(?:fixed|resolved|passed|succeeded|successful)\b/.test(lower) && hasSemanticEvidence(claim, tool.result))
       return true;
   }
   return false;
@@ -1224,9 +1432,15 @@ function stemToken(token) {
 function semanticTokens(text) {
   return (text.normalize("NFKC").match(/[\p{L}\p{N}_-]+/gu) ?? []).map(stemToken).filter((token) => token.length > 2);
 }
-function evidenceFragments(text) {
-  const fragments = text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean);
-  return Array.from(new Set(fragments));
+var semanticShapeCache = new Map;
+var semanticFragmentCache = new Map;
+function semanticFragments(text) {
+  const cached = lruGet(semanticFragmentCache, text);
+  if (cached)
+    return cached;
+  const fragments = Array.from(new Set(text.split(/\r?\n/).flatMap((line) => [line, ...line.split(/[.;]/)]).map((part) => part.replace(/^\s*[-*\d.)]+\s*/, "").trim()).filter(Boolean))).map(semanticTokens);
+  lruSet(semanticFragmentCache, text, fragments, 256);
+  return fragments;
 }
 function hasNearbyMarker(tokens, anchor, markers) {
   return tokens.some((token, index) => token === anchor && tokens.slice(Math.max(0, index - 2), index + 3).some((near) => markers.has(near)));
@@ -1250,20 +1464,24 @@ function hasEffectiveTargetNegation(tokens, anchor) {
   });
 }
 function semanticShape(source) {
+  const cached = lruGet(semanticShapeCache, source);
+  if (cached)
+    return cached;
   const sourceTokens = semanticTokens(source);
   const concepts = Array.from(new Set(sourceTokens.filter((token) => !/^\d+$/.test(token) && !SEMANTIC_STOP.has(token) && !NEGATION_MARKERS.has(token) && !CONDITION_MARKERS.has(token))));
   const negative = sourceTokens.some((token) => NEGATION_MARKERS.has(token));
   const conditional = sourceTokens.some((token) => CONDITION_MARKERS.has(token));
   const anchor = concepts.find((concept) => hasNearbyMarker(sourceTokens, concept, NEGATION_MARKERS)) ?? concepts[0] ?? "";
-  return { sourceTokens, concepts, anchor, negative, conditional };
+  const shape = { sourceTokens, concepts, anchor, negative, conditional };
+  lruSet(semanticShapeCache, source, shape, 512);
+  return shape;
 }
 function hasSemanticEvidence(source, target) {
   const { sourceTokens, concepts, anchor, negative, conditional } = semanticShape(source);
   if (!concepts.length)
     return true;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
     if (overlap < required)
       return false;
@@ -1285,8 +1503,7 @@ function hasSemanticContradiction(source, target) {
   if (!anchor)
     return false;
   const required = Math.min(concepts.length, Math.max(1, Math.ceil(concepts.length * 0.6)));
-  return evidenceFragments(target).some((fragment) => {
-    const tokens = semanticTokens(fragment);
+  return semanticFragments(target).some((tokens) => {
     if (!tokens.includes(anchor))
       return false;
     const overlap = concepts.filter((concept) => tokens.includes(concept)).length;
@@ -1448,16 +1665,18 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
       gaps.push({ kind: "inconsistency", detail: "blocked-none: Blocked says none despite unresolved errors" });
       score -= 12;
     }
+    const doneRefs = new Set(extractFileRefs(doneSection).map(normalizePath));
     for (const file of extraction.modifiedFiles) {
-      const basename = file.path.split("/").pop() ?? "";
-      if (!doneSection.toLowerCase().includes(basename.toLowerCase()))
+      const uniqueNeedles = buildUniquePathNeedles(file.path, modifiedPaths);
+      if (!uniqueNeedles.some((needle) => doneRefs.has(normalizePath(needle))))
         continue;
       const unresolved = unresolvedEvidence.find((error) => {
         const firstLine = error.message.split(/\r?\n/, 1)[0] ?? "";
-        return extractFileRefs(firstLine).some((ref) => isKnownPathReference(ref, [file.path]));
+        const errorRefs = extractFileRefs(firstLine).map(normalizePath);
+        return uniqueNeedles.some((needle) => errorRefs.includes(normalizePath(needle)));
       });
       if (unresolved) {
-        gaps.push({ kind: "inconsistency", detail: basename + " marked Done but has unresolved error" });
+        gaps.push({ kind: "inconsistency", detail: file.path + " marked Done but has unresolved error" });
         score -= 5;
       }
     }
@@ -1479,8 +1698,9 @@ function verifySummary(summary, extraction, continuity = null, evidence = {}) {
     score -= 5;
   }
   if (evidence.sourceMessages) {
+    const tools = successfulToolEvidence(evidence.sourceMessages);
     for (const claim of outcomeClaims(summary)) {
-      if (!successfulToolSupportsClaim(claim, evidence.sourceMessages, extraction)) {
+      if (!successfulToolSupportsClaim(claim, tools, extraction)) {
         gaps.push({ kind: "unsupported-claim", claim });
         score -= 20;
       }