@monotykamary/pi-vcc 0.8.0 → 0.8.2

package/README.md

@@ -248,6 +248,8 @@ When `PI_FABRIC_COMPACTION_ENGINE=fabric`, pi-vcc defers non-explicit summary co
 
 The precedence is: explicit `/pi-vcc` sentinel > pi-fabric engine > pi-vcc default override.
 
+For explicit `/pi-vcc` compactions, pi-vcc also expands the durable execution trace stored on each `fabric_exec` result. Nested `pi.*`, MCP, extension, agent, and other Fabric provider calls participate in file tracking, error extraction, the brief transcript, and `vcc_recall` search just like top-level tool calls. Current trace details and legacy Fabric audit details are both supported.
+
 ### How compaction works
 
 Pi splits the conversation at the **last user message**. Everything after — the **kept tail** — stays intact and untouched. pi-vcc only summarizes the older portion before that cut point.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-vcc",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Algorithmic conversation compactor for pi - transcript-preserving structured summaries, no LLM calls",
   "main": "index.ts",
   "keywords": [

package/src/core/content.ts

@@ -59,6 +59,28 @@ const thinkingParts = (content: Message["content"]): string[] => {
 export const thinkingOf = (content: Message["content"]): string =>
   thinkingParts(content).join("\n");
 
+const toolCallArgText = (args: Record<string, unknown>): string => {
+  const vals: string[] = [];
+  for (const v of Object.values(args ?? {})) {
+    if (typeof v === "string" && v.length > 0) vals.push(v);
+  }
+  return vals.join("\n");
+};
+
+const toolCallParts = (content: Message["content"]): string[] => {
+  if (!content || typeof content === "string") return [];
+  return content
+    .filter((part) => part.type === "toolCall")
+    .map((part) => toolCallArgText(part.arguments));
+};
+
+/** Extract all string-valued arguments from toolCall content parts.
+ *  Lets vcc_recall match against tool invocations — e.g. a bash
+ *  toolCall's `arguments.command`, a grep's `pattern`, an edit's
+ *  `oldText`/`newText`. Non-string args are skipped. */
+export const toolCallsOf = (content: Message["content"]): string =>
+  toolCallParts(content).filter(Boolean).join("\n");
+
 /** Extract a snippet of ~`radius` chars around the first match of `term` in `text`. */
 const snippet = (text: string, term: string, radius = 60): string | null => {
   const idx = text.toLowerCase().indexOf(term.toLowerCase());

package/src/core/fabric-trace.ts

@@ -0,0 +1,118 @@
+type FabricOperationOutcome = "succeeded" | "failed" | "aborted" | "timed_out";
+
+export interface FabricOperation {
+  ref: string;
+  name: string;
+  args: Record<string, unknown>;
+  outcome: FabricOperationOutcome;
+  error?: string;
+  result?: unknown;
+}
+
+const OUTCOMES = new Set<FabricOperationOutcome>([
+  "succeeded",
+  "failed",
+  "aborted",
+  "timed_out",
+]);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const identityOf = (ref: string, provider?: unknown, action?: unknown) => {
+  const separator = ref.indexOf(".");
+  const lexicalProvider = separator > 0 ? ref.slice(0, separator) : undefined;
+  const lexicalAction = separator > 0 && separator < ref.length - 1
+    ? ref.slice(separator + 1)
+    : undefined;
+  const resolvedProvider = typeof provider === "string" ? provider : lexicalProvider;
+  const resolvedAction = typeof action === "string" ? action : lexicalAction;
+  return {
+    name: resolvedProvider === "pi" && resolvedAction
+      ? resolvedAction
+      : resolvedAction ?? ref,
+  };
+};
+
+const operationOf = (value: unknown): FabricOperation | undefined => {
+  if (!isRecord(value) || typeof value.ref !== "string" || !isRecord(value.args)) {
+    return undefined;
+  }
+  if (!OUTCOMES.has(value.outcome as FabricOperationOutcome)) return undefined;
+  if (value.error !== undefined && typeof value.error !== "string") return undefined;
+  return {
+    ref: value.ref,
+    name: identityOf(value.ref, value.provider, value.action).name,
+    args: value.args,
+    outcome: value.outcome as FabricOperationOutcome,
+    ...(typeof value.error === "string" ? { error: value.error } : {}),
+    ...(Object.prototype.hasOwnProperty.call(value, "result") ? { result: value.result } : {}),
+  };
+};
+
+const legacyOperationOf = (value: unknown): FabricOperation | undefined => {
+  if (!isRecord(value) || typeof value.ref !== "string" || !isRecord(value.args)) {
+    return undefined;
+  }
+  if (typeof value.success !== "boolean") return undefined;
+  if (value.error !== undefined && typeof value.error !== "string") return undefined;
+  return {
+    ref: value.ref,
+    name: identityOf(value.ref).name,
+    args: value.args,
+    outcome: value.success ? "succeeded" : "failed",
+    ...(typeof value.error === "string" ? { error: value.error } : {}),
+    ...(Object.prototype.hasOwnProperty.call(value, "result") ? { result: value.result } : {}),
+  };
+};
+
+/** Read the durable nested-operation projection stored by pi-fabric on a fabric_exec result. */
+export const fabricOperationsOf = (details: unknown): FabricOperation[] => {
+  if (!isRecord(details)) return [];
+  if (isRecord(details.trace)) {
+    const trace = details.trace;
+    if (trace.kind !== "pi-fabric.execution" || trace.version !== 1 || !Array.isArray(trace.operations)) {
+      return [];
+    }
+    const operations: FabricOperation[] = [];
+    for (const value of trace.operations) {
+      const operation = operationOf(value);
+      if (!operation) return [];
+      operations.push(operation);
+    }
+    return operations;
+  }
+  if (!Array.isArray(details.audits)) return [];
+  const operations: FabricOperation[] = [];
+  for (const value of details.audits) {
+    const operation = legacyOperationOf(value);
+    if (!operation) return [];
+    operations.push(operation);
+  }
+  return operations;
+};
+
+export const fabricArgsText = (operation: FabricOperation): string => {
+  try {
+    return JSON.stringify(operation.args);
+  } catch {
+    return Object.keys(operation.args).join(" ");
+  }
+};
+
+export const fabricResultText = (operation: FabricOperation): string => {
+  if (operation.error) return operation.error;
+  const value = operation.result;
+  if (typeof value === "string") return value;
+  if (isRecord(value)) {
+    for (const key of ["output", "text", "content"]) {
+      if (typeof value[key] === "string") return value[key] as string;
+    }
+  }
+  if (value === undefined) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};

package/src/core/normalize.ts

@@ -2,6 +2,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import type { NormalizedBlock } from "../types";
 import { textOf } from "./content";
 import { sanitize } from "./sanitize";
+import { fabricOperationsOf, fabricResultText } from "./fabric-trace";
 
 const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
   if (msg.role === "user") {
@@ -26,13 +27,31 @@ const normalizeOne = (msg: Message, msgIndex: number): NormalizedBlock[] => {
   }
 
   if (msg.role === "toolResult") {
-    return [{
+    const blocks: NormalizedBlock[] = [{
       kind: "tool_result",
       name: msg.toolName,
       text: sanitize(textOf(msg.content)),
       isError: msg.isError,
       sourceIndex: msgIndex,
     }];
+    if (msg.toolName === "fabric_exec") {
+      for (const operation of fabricOperationsOf((msg as any).details)) {
+        blocks.push({
+          kind: "tool_call",
+          name: operation.name,
+          args: operation.args,
+          sourceIndex: msgIndex,
+        });
+        blocks.push({
+          kind: "tool_result",
+          name: operation.name,
+          text: sanitize(fabricResultText(operation)),
+          isError: operation.outcome !== "succeeded",
+          sourceIndex: msgIndex,
+        });
+      }
+    }
+    return blocks;
   }
 
   if (msg.role === "assistant") {

package/src/core/render-entries.ts

@@ -2,6 +2,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import { clip, textOf, thinkingOf } from "./content";
 import { summarizeToolArgs } from "./tool-args";
 import { extractPath } from "./tool-args";
+import { fabricOperationsOf } from "./fabric-trace";
 
 export interface RenderedEntry {
   index: number;
@@ -33,9 +34,21 @@ export const renderMessage = (msg: Message, index: number, full = false): Render
   if (msg.role === "toolResult") {
     const prefix = msg.isError ? "ERROR " : "";
     const text = full ? textOf(msg.content) : clip(textOf(msg.content), 200);
+    const nested = msg.toolName === "fabric_exec"
+      ? fabricOperationsOf((msg as any).details)
+      : [];
+    const nestedSummary = nested
+      .slice(-20)
+      .map((operation) => `${operation.name}(${summarizeToolArgs(operation.args)})`)
+      .join(", ");
+    const files = [...new Set(nested
+      .map((operation) => extractPath(operation.args))
+      .filter((path): path is string => path !== null))]
+      .slice(0, 50);
     return {
       index, role: "tool_result",
-      summary: `${prefix}[${msg.toolName}] ${text}`,
+      summary: `${prefix}[${msg.toolName}] ${text}${nestedSummary ? `\n${nestedSummary}` : ""}`,
+      ...(files.length > 0 && { files }),
     };
   }
   // bashExecution has command+output instead of content

package/src/core/search-entries.ts

@@ -1,6 +1,7 @@
 import type { Message } from "@earendil-works/pi-ai";
 import type { RenderedEntry } from "./render-entries";
-import { textOf, thinkingOf } from "./content";
+import { textOf, thinkingOf, toolCallsOf } from "./content";
+import { fabricArgsText, fabricOperationsOf, fabricResultText } from "./fabric-trace";
 
 export interface SearchHit extends RenderedEntry {
   /** Context snippet around the first matched term (only when query provided) */
@@ -270,10 +271,24 @@ const fullText = (msg: Message): string => {
   if ((msg as any).role === "bashExecution") {
     return `${(msg as any).command ?? ""} ${(msg as any).output ?? ""}`;
   }
-  // Include thinking content so recall can match against model reasoning
+  // Include thinking + toolCall arguments so recall can match against
+  // model reasoning and tool invocations (e.g. a bash toolCall's command).
   let text = textOf(msg.content);
+  if (msg.role === "toolResult" && msg.toolName === "fabric_exec") {
+    const nested = fabricOperationsOf((msg as any).details)
+      .flatMap((operation) => [
+        operation.ref,
+        fabricArgsText(operation),
+        fabricResultText(operation),
+      ])
+      .filter(Boolean)
+      .join("\n");
+    if (nested) text += "\n" + nested;
+  }
   const thinking = thinkingOf(msg.content);
   if (thinking) text = thinking + "\n" + text;
+  const toolArgs = toolCallsOf(msg.content);
+  if (toolArgs) text = toolArgs + "\n" + text;
   return text;
 };