@matyah00/openpi 0.1.5 → 0.2.0

package/extensions/openpi.ts

@@ -2,7 +2,8 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { extensionDir } from "./lib/packagePaths.ts";
+import { extensionDir, bundledPromptsDir, bundledAgentsDir, bundledPiPiAgentsDir } from "./lib/packagePaths.ts";
+import { parseMarkdownFrontmatter, stringField, arrayField } from "./lib/markdown.ts";
 
 type Profile = {
   name: string;
@@ -130,26 +131,31 @@ function resolveSettingsPath(cwd: string, global: boolean): string {
   return global ? path.join(os.homedir(), ".pi", "agent", "settings.json") : path.join(cwd, ".pi", "settings.json");
 }
 
-function applyProfileToSettings(settingsPath: string, profile: Profile): { added: string[]; removed: number } {
+function applyProfileToSettings(settingsPath: string, profile: Profile, dryRun = false): { added: string[]; removed: number } {
   const settingsDir = path.dirname(settingsPath);
   const settings = readJsonFile(settingsPath);
   const currentExtensions = stringArray(settings.extensions);
   const keptExtensions = currentExtensions.filter((entry) => !isManagedExtensionEntry(entry, settingsDir));
   const added = profile.extensions.map(extensionPath);
 
-  settings.extensions = addUnique(keptExtensions, added);
-  writeJsonFile(settingsPath, settings);
+  if (!dryRun) {
+    settings.extensions = addUnique(keptExtensions, added);
+    writeJsonFile(settingsPath, settings);
+  }
 
   return { added, removed: currentExtensions.length - keptExtensions.length };
 }
 
-function clearProfileFromSettings(settingsPath: string): { removed: number } {
+function clearProfileFromSettings(settingsPath: string, dryRun = false): { removed: number } {
   const settingsDir = path.dirname(settingsPath);
   const settings = readJsonFile(settingsPath);
   const currentExtensions = stringArray(settings.extensions);
-  settings.extensions = currentExtensions.filter((entry) => !isManagedExtensionEntry(entry, settingsDir));
-  writeJsonFile(settingsPath, settings);
-  return { removed: currentExtensions.length - stringArray(settings.extensions).length };
+  const keptExtensions = currentExtensions.filter((entry) => !isManagedExtensionEntry(entry, settingsDir));
+  if (!dryRun) {
+    settings.extensions = keptExtensions;
+    writeJsonFile(settingsPath, settings);
+  }
+  return { removed: currentExtensions.length - keptExtensions.length };
 }
 
 function profileListMarkdown(): string {
@@ -157,6 +163,7 @@ function profileListMarkdown(): string {
     "# openpi profiles",
     "",
     "Use `/openpi use <profile>` to activate a profile for this project.",
+    "Use `/openpi use <profile1>+<profile2>` to combine multiple profiles (e.g. `commands+guard`).",
     "Use `/openpi use <profile> --global` to activate it globally.",
     "Run `/reload` or restart Pi after changing profiles.",
     "",
@@ -172,6 +179,110 @@ function emit(pi: ExtensionAPI, content: string) {
   pi.sendMessage({ customType: "openpi", content, display: true });
 }
 
+const NATIVE_TOOLS_BY_EXTENSION: Record<string, string[]> = {
+  "search-tools.ts": ["project_tree", "code_search_batch"],
+  "audit-tools.ts": ["env_scan", "secret_scan", "ghost_test_scan", "dependency_inventory", "sast_scan"],
+  "state-tools.ts": ["state_snapshot", "state_restore", "state_diff", "state_clean"],
+  "agent-team.ts": ["dispatch_agent"],
+  "agent-chain.ts": ["run_chain"],
+  "workflow.ts": ["spawn_agents"],
+};
+
+const NATIVE_COMMANDS_BY_EXTENSION: Record<string, string[]> = {
+  "workflow.ts": ["add", "fix", "review", "openpi-agents"],
+  "theme-cycler.ts": ["theme"],
+  "system-select.ts": ["system"],
+  "agent-team.ts": ["agents-team", "agents-list"],
+  "agent-chain.ts": ["chain", "chain-list"],
+  "commands.ts": ["commands", "command:status"],
+};
+
+function scanDirForFiles(dir: string, extension: string): string[] {
+  if (!fs.existsSync(dir)) return [];
+  try {
+    return fs.readdirSync(dir)
+      .filter((file) => file.endsWith(extension))
+      .map((file) => path.basename(file, extension).toLowerCase());
+  } catch {
+    return [];
+  }
+}
+
+function getProfileSummary(extensions: string[], cwd: string) {
+  const tools = new Set<string>();
+  const commands = new Set<string>();
+
+  for (const ext of extensions) {
+    const extTools = NATIVE_TOOLS_BY_EXTENSION[ext] || [];
+    for (const t of extTools) {
+      tools.add(t);
+    }
+    const extCmds = NATIVE_COMMANDS_BY_EXTENSION[ext] || [];
+    for (const c of extCmds) {
+      commands.add(c);
+    }
+  }
+
+  // If commands.ts is active, also scan prompts
+  if (extensions.includes("commands.ts")) {
+    const promptDirs = [
+      bundledPromptsDir,
+      path.join(cwd, ".pi", "prompts")
+    ];
+    for (const dir of promptDirs) {
+      if (fs.existsSync(dir)) {
+        try {
+          const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+          for (const file of files) {
+            const filePath = path.join(dir, file);
+            const raw = fs.readFileSync(filePath, "utf-8");
+            const { frontmatter } = parseMarkdownFrontmatter(raw);
+            const name = stringField(frontmatter.name) || path.basename(file, ".md");
+            commands.add(name.toLowerCase());
+            const aliases = arrayField(frontmatter.aliases);
+            for (const alias of aliases) {
+              commands.add(alias.toLowerCase());
+            }
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+  }
+
+  // Scan agents
+  const agents = new Set<string>();
+  const agentDirs = [
+    bundledAgentsDir,
+    bundledPiPiAgentsDir,
+    path.join(cwd, ".pi", "agents"),
+    path.join(cwd, "agents")
+  ];
+  for (const dir of agentDirs) {
+    if (fs.existsSync(dir)) {
+      try {
+        const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md"));
+        for (const file of files) {
+          const agentName = path.basename(file, ".md").toLowerCase();
+          agents.add(agentName);
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }
+
+  return {
+    commandsCount: commands.size,
+    commandsList: Array.from(commands),
+    toolsCount: tools.size,
+    toolsList: Array.from(tools),
+    agentsCount: agents.size,
+    agentsList: Array.from(agents),
+  };
+}
+
 function registerProfileCommand(pi: ExtensionAPI, name: string, description: string) {
   pi.registerCommand(name, {
     description,
@@ -185,6 +296,16 @@ function registerProfileCommand(pi: ExtensionAPI, name: string, description: str
       }
       if (words[0] === "use") {
         const partial = words[1] || "";
+        if (partial.includes("+")) {
+          const parts = partial.split("+");
+          const last = parts[parts.length - 1];
+          const base = parts.slice(0, -1).join("+");
+          return PROFILES.filter((profile) => profile.name.startsWith(last)).map((profile) => ({
+            value: `${base}+${profile.name}`,
+            label: `${base}+${profile.name}`,
+            description: `Combine with ${profile.name}`,
+          }));
+        }
         return PROFILES.filter((profile) => profile.name.startsWith(partial)).map((profile) => ({
           value: profile.name,
           label: profile.name,
@@ -202,36 +323,62 @@ function registerProfileCommand(pi: ExtensionAPI, name: string, description: str
         return;
       }
 
-      if (PROFILE_BY_NAME.has(action)) tokens.unshift("use");
+      const isComposition = action.includes("+") && action.split("+").every(name => PROFILE_BY_NAME.has(name));
+      if (PROFILE_BY_NAME.has(action) || isComposition) tokens.unshift("use");
 
       if (tokens[0] === "use") {
-        const profile = PROFILE_BY_NAME.get(tokens[1] || "");
-        if (!profile) {
-          ctx.ui.notify("Usage: /openpi use <profile> [--global]", "error");
+        const profileArg = tokens[1] || "";
+        const profileNames = profileArg.split("+").filter(Boolean);
+        if (!profileNames.length) {
+          ctx.ui.notify("Usage: /openpi use <profile1>+<profile2> [--global] [--dry-run]", "error");
           return;
         }
+
+        const invalidNames = profileNames.filter(name => !PROFILE_BY_NAME.has(name));
+        if (invalidNames.length > 0) {
+          ctx.ui.notify(`Unknown profile(s): ${invalidNames.join(", ")}`, "error");
+          return;
+        }
+
+        const profiles = profileNames.map(name => PROFILE_BY_NAME.get(name)!);
+        const composedProfile: Profile = {
+          name: profileNames.join("+"),
+          description: profiles.map(p => p.description).join(" | "),
+          extensions: Array.from(new Set(profiles.flatMap(p => p.extensions))),
+          notes: Array.from(new Set(profiles.flatMap(p => p.notes || [])))
+        };
+
         const global = tokens.includes("--global");
+        const dryRun = tokens.includes("--dry-run");
         const settingsPath = resolveSettingsPath(ctx.cwd, global);
-        const result = applyProfileToSettings(settingsPath, profile);
+        const result = applyProfileToSettings(settingsPath, composedProfile, dryRun);
+
+        const summary = getProfileSummary(composedProfile.extensions, ctx.cwd);
         emit(pi, [
-          `Activated **${profile.name}** in ${global ? "global" : "project"} Pi settings.`,
+          `${dryRun ? "**[DRY-RUN]** " : ""}Activated **${composedProfile.name}** in ${global ? "global" : "project"} Pi settings.`,
           "",
           `Settings: \`${settingsPath}\``,
-          `Removed previous openpi profile entries: ${result.removed}`,
-          "Added:",
-          ...result.added.map((entry) => `- \`${entry}\``),
+          `${dryRun ? "Would remove" : "Removed"} previous openpi profile entries: ${result.removed}`,
+          `${dryRun ? "Would add" : "Added"} extensions: ${result.added.length}`,
+          ...result.added.map((entry) => `- \`${path.basename(entry)}\``),
           "",
-          "Run `/reload` or restart Pi.",
-          ...(profile.notes?.length ? ["", ...profile.notes.map((note) => `- ${note}`)] : []),
+          "### Profile Capability Summary",
+          `- **Commands Enabled**: ${summary.commandsCount} (${summary.commandsList.join(", ")})`,
+          `- **Tools Enabled**: ${summary.toolsCount} (${summary.toolsList.join(", ")})`,
+          `- **Agents Available**: ${summary.agentsCount} (${summary.agentsList.join(", ")})`,
+          "",
+          dryRun ? "This was a dry run. No settings files were modified." : "Run `/reload` or restart Pi to apply changes.",
+          ...(composedProfile.notes?.length ? ["", ...composedProfile.notes.map((note) => `- ${note}`)] : []),
         ].join("\n"));
         return;
       }
 
       if (tokens[0] === "clear") {
         const global = tokens.includes("--global");
+        const dryRun = tokens.includes("--dry-run");
         const settingsPath = resolveSettingsPath(ctx.cwd, global);
-        const result = clearProfileFromSettings(settingsPath);
-        emit(pi, `Cleared ${result.removed} openpi extension entr${result.removed === 1 ? "y" : "ies"} from \`${settingsPath}\`. Run \`/reload\` or restart Pi.`);
+        const result = clearProfileFromSettings(settingsPath, dryRun);
+        emit(pi, `${dryRun ? "**[DRY-RUN]** Would clear" : "Cleared"} ${result.removed} openpi extension entr${result.removed === 1 ? "y" : "ies"} from \`${settingsPath}\`.${dryRun ? "" : " Run `/reload` or restart Pi."}`);
         return;
       }
 
@@ -240,6 +387,7 @@ function registerProfileCommand(pi: ExtensionAPI, name: string, description: str
   });
 }
 
+
 export default function (pi: ExtensionAPI) {
   registerProfileCommand(pi, "openpi", "Manage openpi native profiles");
   registerProfileCommand(pi, "azpi", "Deprecated alias for /openpi");

package/extensions/search-tools.ts

@@ -31,6 +31,7 @@ type TreeNode = {
   name: string;
   relativePath: string;
   isDirectory: boolean;
+  sizeBytes?: number;
   children?: TreeNode[];
 };
 
@@ -39,6 +40,7 @@ type SearchQuery = {
   cwd?: string;
   globs?: string[];
   caseInsensitive?: boolean;
+  isRegex?: boolean;
   before?: number;
   after?: number;
   maxResults?: number;
@@ -83,6 +85,7 @@ function buildTree(params: {
   maxDepth: number;
   maxEntries: number;
   includeHidden: boolean;
+  showSizes: boolean;
 }): { nodes: TreeNode[]; omitted: number; visited: number } {
   const ignoreNames = readIgnoreNames(params.projectRoot);
   let visited = 0;
@@ -120,7 +123,11 @@ function buildTree(params: {
           children: walk(absolutePath, depth + 1),
         });
       } else {
-        nodes.push({ name: entry.name, relativePath, isDirectory: false });
+        let sizeBytes: number | undefined;
+        if (params.showSizes) {
+          try { sizeBytes = fs.statSync(absolutePath).size; } catch { /* skip */ }
+        }
+        nodes.push({ name: entry.name, relativePath, isDirectory: false, sizeBytes });
       }
     }
     return nodes;
@@ -129,12 +136,19 @@ function buildTree(params: {
   return { nodes: walk(params.root, 0), omitted, visited };
 }
 
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
 function renderTree(nodes: TreeNode[], prefix = ""): string[] {
   const lines: string[] = [];
   nodes.forEach((node, index) => {
     const isLast = index === nodes.length - 1;
     const connector = isLast ? "`-- " : "|-- ";
-    lines.push(`${prefix}${connector}${node.name}${node.isDirectory ? "/" : ""}`);
+    const sizeSuffix = node.sizeBytes !== undefined ? ` (${formatSize(node.sizeBytes)})` : "";
+    lines.push(`${prefix}${connector}${node.name}${node.isDirectory ? "/" : ""}${sizeSuffix}`);
     if (node.children?.length) {
       lines.push(...renderTree(node.children, `${prefix}${isLast ? "    " : "|   "}`));
     }
@@ -145,6 +159,7 @@ function renderTree(nodes: TreeNode[], prefix = ""): string[] {
 function runRipgrep(projectRoot: string, query: SearchQuery): Promise<string> {
   const cwd = resolveProjectPath(projectRoot, query.cwd);
   const args = ["--line-number", "--column", "--no-heading", "--color", "never"];
+  if (!query.isRegex) args.push("-F");
   if (query.caseInsensitive) args.push("-i");
   if (query.before) args.push("-B", String(query.before));
   if (query.after) args.push("-A", String(query.after));
@@ -193,13 +208,15 @@ export default function searchToolsExtension(pi: ExtensionAPI) {
       maxDepth: Type.Optional(Type.Number({ description: "Maximum directory depth. Default 3." })),
       maxEntries: Type.Optional(Type.Number({ description: "Maximum entries to include. Default 400." })),
       includeHidden: Type.Optional(Type.Boolean({ description: "Include hidden files and directories. Default false." })),
+      showSizes: Type.Optional(Type.Boolean({ description: "Show file sizes next to filenames. Default false." })),
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const root = resolveProjectPath(ctx.cwd, params.root as string | undefined);
       const maxDepth = Math.max(0, Math.min(Number(params.maxDepth ?? 3), 8));
       const maxEntries = Math.max(20, Math.min(Number(params.maxEntries ?? 400), 4000));
       const includeHidden = Boolean(params.includeHidden);
-      const result = buildTree({ projectRoot: ctx.cwd, root, maxDepth, maxEntries, includeHidden });
+      const showSizes = Boolean(params.showSizes);
+      const result = buildTree({ projectRoot: ctx.cwd, root, maxDepth, maxEntries, includeHidden, showSizes });
       const header = [
         `root: ${normalizeRelative(ctx.cwd, root)}`,
         `depth: ${maxDepth}`,
@@ -236,6 +253,7 @@ export default function searchToolsExtension(pi: ExtensionAPI) {
           cwd: Type.Optional(Type.String({ description: "Project-relative directory to search in." })),
           globs: Type.Optional(Type.Array(Type.String(), { description: "Optional ripgrep -g patterns." })),
           caseInsensitive: Type.Optional(Type.Boolean({ description: "Use case-insensitive search." })),
+          isRegex: Type.Optional(Type.Boolean({ description: "Treat pattern as regex. Default false (literal/fixed-string search)." })),
           before: Type.Optional(Type.Number({ description: "Context lines before each match." })),
           after: Type.Optional(Type.Number({ description: "Context lines after each match." })),
           maxResults: Type.Optional(Type.Number({ description: "Maximum matches per file from rg -m." })),

package/extensions/workflow.ts

@@ -20,6 +20,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, getAgentDir, parseFrontmatter, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { writeAuditLog } from "./lib/auditLogger.ts";
 
 type AgentScope = "user" | "project" | "both";
 type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
@@ -28,6 +29,8 @@ type ExecutionMode = "parallel" | "sequential";
 const MAX_AGENTS_PER_CALL = 8;
 const MAX_PARALLEL_CONCURRENCY = 4;
 const OUTPUT_PREVIEW_CHARS = 6_000;
+const DEFAULT_AGENT_TIMEOUT_MS = 120_000;
+const RETRY_DELAY_MS = 2_000;
 const ROLE_ALIASES: Record<string, string> = {
   "file_picker": "file-picker",
   "file-picker": "file-picker",
@@ -83,6 +86,8 @@ interface AgentRunRequest {
   model?: string;
   thinking?: ThinkingLevel;
   tools?: string[];
+  timeout?: number;
+  retry?: boolean;
 }
 
 interface UsageStats {
@@ -108,6 +113,7 @@ interface AgentRunResult {
   thinking?: ThinkingLevel;
   stopReason?: string;
   errorMessage?: string;
+  retryCount?: number;
 }
 
 interface SpawnAgentsDetails {
@@ -271,6 +277,7 @@ async function runSingleAgent(
   availableAgents: AgentConfig[],
   request: AgentRunRequest,
   signal: AbortSignal | undefined,
+  onProgress?: (agentName: string, text: string) => void,
 ): Promise<AgentRunResult> {
   const requestedAgent = normalizeRoleName(request.agent ?? request.agent_type);
   const prompt = (request.prompt ?? request.task ?? "").trim();
@@ -330,6 +337,7 @@ async function runSingleAgent(
         stdio: ["ignore", "pipe", "pipe"],
       });
       let buffer = "";
+      let progressText = "";
 
       const processLine = (line: string) => {
         if (!line.trim()) return;
@@ -340,6 +348,13 @@ async function runSingleAgent(
           return;
         }
 
+        // Stream text deltas for live progress
+        if (event.type === "message_update" && event.assistantMessageEvent?.type === "text_delta") {
+          const delta = event.assistantMessageEvent.delta || "";
+          progressText += delta;
+          if (onProgress) onProgress(requestedAgent, progressText);
+        }
+
         if (event.type === "message_end" && event.message) {
           const message = event.message as Message;
           messages.push(message);
@@ -397,17 +412,42 @@ async function runSingleAgent(
         if (signal.aborted) killProc();
         else signal.addEventListener("abort", killProc, { once: true });
       }
+
+      // Agent timeout
+      const timeoutMs = request.timeout ?? DEFAULT_AGENT_TIMEOUT_MS;
+      if (timeoutMs > 0) {
+        setTimeout(() => {
+          if (!proc.killed) {
+            wasAborted = true;
+            baseResult.stopReason = "timeout";
+            proc.kill("SIGTERM");
+            setTimeout(() => {
+              if (!proc.killed) proc.kill("SIGKILL");
+            }, 5_000);
+          }
+        }, timeoutMs);
+      }
     });
 
     if (wasAborted) {
-      return { ...baseResult, exitCode, errorMessage: "Subagent was aborted" };
+      return { ...baseResult, exitCode, errorMessage: baseResult.stopReason === "timeout" ? `Agent timed out after ${(request.timeout ?? DEFAULT_AGENT_TIMEOUT_MS) / 1000}s` : "Subagent was aborted" };
     }
 
-    return {
+    const result: AgentRunResult = {
       ...baseResult,
       exitCode,
       output: getFinalAssistantText(messages),
     };
+
+    // Retry logic: retry once if failed with empty output (transient failure)
+    if (request.retry && exitCode !== 0 && !result.output.trim() && !(result.retryCount ?? 0)) {
+      await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      const retryResult = await runSingleAgent(projectCwd, availableAgents, { ...request, retry: false }, signal, onProgress);
+      retryResult.retryCount = 1;
+      return retryResult;
+    }
+
+    return result;
   } finally {
     if (tmpPromptPath) await fs.promises.rm(tmpPromptPath, { force: true }).catch(() => undefined);
     if (tmpPromptDir) await fs.promises.rm(tmpPromptDir, { recursive: true, force: true }).catch(() => undefined);
@@ -439,12 +479,13 @@ function summarizeSpawnResults(results: AgentRunResult[]): string {
     .map((result, index) => {
       const ok = result.exitCode === 0 && !result.errorMessage;
       const usage = formatUsage(result.usage);
+      const retryNote = result.retryCount ? ` (retried ${result.retryCount}x)` : "";
       const meta = [result.model, result.thinking ? `thinking:${result.thinking}` : undefined, usage]
         .filter(Boolean)
         .join(" | ");
       const body = result.output || result.errorMessage || result.stderr || "(no output)";
       return [
-        `## ${index + 1}. ${ok ? "OK" : "FAIL"} ${result.agent}`,
+        `## ${index + 1}. ${ok ? "OK" : "FAIL"} ${result.agent}${retryNote}`,
         meta ? `_${meta}_` : undefined,
         "",
         truncateText(body),
@@ -478,6 +519,8 @@ const AgentRequestSchema = Type.Object({
     }),
   ),
   tools: Type.Optional(Type.Array(Type.String(), { description: "Optional tool override for this agent process" })),
+  timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds for this agent. Default 120000 (2 minutes)." })),
+  retry: Type.Optional(Type.Boolean({ description: "Retry once on transient failure (empty output + non-zero exit). Default false." })),
 });
 
 export default function workflowExtension(pi: ExtensionAPI) {
@@ -543,7 +586,14 @@ export default function workflowExtension(pi: ExtensionAPI) {
 
       if (mode === "sequential") {
         for (const request of requests) {
-          const result = await runSingleAgent(ctx.cwd, discovery.agents, request, signal);
+          const runStart = Date.now();
+          const result = await runSingleAgent(ctx.cwd, discovery.agents, request, signal, (agentName, text) => {
+            onUpdate?.({
+              content: [{ type: "text", text: `spawn_agents [${agentName}]: ${text.split("\n").filter(Boolean).pop() || "working..."}` }],
+              details: makeDetails([...results]),
+            });
+          });
+          (result as any).elapsedMs = Date.now() - runStart;
           results.push(result);
           emitProgress();
           if (result.exitCode !== 0 || result.errorMessage) break;
@@ -553,7 +603,14 @@ export default function workflowExtension(pi: ExtensionAPI) {
           requests,
           MAX_PARALLEL_CONCURRENCY,
           async (request) => {
-            const result = await runSingleAgent(ctx.cwd, discovery.agents, request, signal);
+            const runStart = Date.now();
+            const result = await runSingleAgent(ctx.cwd, discovery.agents, request, signal, (agentName, text) => {
+              onUpdate?.({
+                content: [{ type: "text", text: `spawn_agents [${agentName}]: ${text.split("\n").filter(Boolean).pop() || "working..."}` }],
+                details: makeDetails([...results]),
+              });
+            });
+            (result as any).elapsedMs = Date.now() - runStart;
             results.push(result);
             emitProgress();
             return result;
@@ -563,6 +620,21 @@ export default function workflowExtension(pi: ExtensionAPI) {
       }
 
       const successCount = results.filter((result) => result.exitCode === 0 && !result.errorMessage).length;
+
+      for (const res of results) {
+        writeAuditLog(ctx.cwd, {
+          type: "workflow",
+          name: `spawn_agents:${res.agent}`,
+          task: res.prompt,
+          input: res.prompt,
+          output: res.output || res.errorMessage || "",
+          exitCode: res.exitCode,
+          elapsedMs: (res as any).elapsedMs || 0,
+
+          metadata: { executionMode: mode, success: res.exitCode === 0 && !res.errorMessage }
+        });
+      }
+
       return {
         content: [
           {

package/package.json

@@ -1,15 +1,19 @@
 {
   "name": "@matyah00/openpi",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "type": "module",
-  "description": "Pi-native commands, skills, agents, and workflows.",
+  "description": "Comprehensive, high-performance, and safety-hardened Pi-native multi-agent orchestration package, featuring advanced workflows, damage-control rules, and developer tooling.",
   "keywords": [
     "pi-package",
     "pi-coding-agent",
     "commands",
     "skills",
     "agents",
-    "workflows"
+    "workflows",
+    "orchestration",
+    "safety",
+    "multi-agent",
+    "damage-control"
   ],
   "homepage": "https://github.com/haytamAroui/OpenPi#readme",
   "repository": {

package/prompts/docs.md

@@ -0,0 +1,37 @@
+---
+description: Generate or update documentation with gap detection and review
+category: quality
+aliases:
+  - document
+---
+
+Generate or update documentation for:
+
+$ARGUMENTS
+
+Process:
+
+1. Use `project_tree` to map the project structure.
+2. Use `code_search_batch` to find exports, public APIs, route definitions, and type declarations.
+3. Identify documentation gaps:
+   - Missing README sections (setup, usage, API, contributing)
+   - Undocumented public functions, classes, or endpoints
+   - Stale documentation that doesn't match current code
+   - Missing architecture or design decision records
+4. Use `spawn_agents` with `docs-writer` for detailed documentation generation when useful.
+5. Use `spawn_agents` with `reviewer` to validate accuracy of generated docs.
+
+Rules:
+
+- Match existing documentation style and conventions.
+- Include working code examples.
+- Document error cases and edge cases.
+- Use concrete language, not abstract descriptions.
+- Link between related sections.
+- Include prerequisites and setup steps.
+
+Output:
+
+- Generated or updated documentation files.
+- List of remaining documentation gaps.
+- Review verdict on documentation accuracy.

package/prompts/migrate.md

@@ -0,0 +1,44 @@
+---
+description: Plan and execute migrations with risk assessment, phased execution, and rollback strategies
+category: planning
+aliases:
+  - upgrade
+---
+
+Plan a migration for:
+
+$ARGUMENTS
+
+Process:
+
+1. Use `env_scan` to identify the current stack and versions.
+2. Use `dependency_inventory` to audit current dependencies.
+3. Use `code_search_batch` to find all touchpoints for the migration target.
+4. Use `spawn_agents` with `migration-expert` for detailed migration analysis.
+5. If the migration is risky (data loss possible, breaking changes), use `spawn_agents` with `red-team` to challenge the plan.
+
+Output:
+
+```text
+Migration: {from} → {to}
+
+Risk: low | medium | high - {why}
+
+Current state:
+- ...
+
+Breaking changes:
+1. ...
+
+Phases:
+1. {phase} - rollback: {strategy}
+2. ...
+
+Validation:
+- {command or check}
+
+Point of no return:
+- {phase N} — after this, rollback requires {strategy}
+```
+
+Do not execute destructive operations. Present the plan and wait for approval.