pi-workflow-engine 0.10.1 → 0.10.3

package/.pi/extensions/pi-workflow-engine/index.ts

@@ -12,6 +12,7 @@ import { handleReviewViewerAction } from "./src/review/review-actions.ts";
 import { decideReviewResultsPresentation, extensionContextMode, maybeShowReviewResultsViewer } from "./src/review/review-results-flow.ts";
 import {
   formatWorkflowDetailLines,
+  isAdvisoryReport,
   isWorkflowResult,
   renderWorkflowResult,
   type WorkflowPerfDetails,
@@ -37,7 +38,39 @@ function formatMessageContent(
   metadata?: WorkflowRunMetadata,
 ): string {
   const details = formatWorkflowDetailLines({ usage, perf, metadata });
-  return `## Workflow: ${name}\n\n${summarize(result)}${details.length > 0 ? `\n\n${details.join("\n")}` : ""}`;
+  return `## Workflow: ${name}\n\n${formatResultForContext(result)}${details.length > 0 ? `\n\n${details.join("\n")}` : ""}`;
+}
+
+function formatResultForContext(result: unknown): string {
+  if (!isAdvisoryReport(result)) return summarize(result);
+
+  const lines = [result.summary];
+  if (result.findings.length > 0) {
+    lines.push("", "Findings:");
+    result.findings.forEach((finding, index) => {
+      const id = `R${String(index + 1).padStart(3, "0")}`;
+      lines.push(
+        `\n### ${id}: ${finding.summary}`,
+        `- Severity: ${finding.severity}`,
+        `- Confidence: ${finding.confidence}`,
+        `- Category: ${finding.category}`,
+        `- Location: ${finding.locations.map(formatFindingLocation).join(", ")}`,
+        `- Impact: ${finding.impact}`,
+        `- Evidence: ${finding.evidence.length > 0 ? finding.evidence.join("; ") : "(none cited)"}`,
+        `- Recommendation: ${finding.recommendation}`,
+      );
+    });
+  }
+  if (result.nextSteps.length > 0) {
+    lines.push("", "Next steps:", ...result.nextSteps.map((step) => `- ${step}`));
+  }
+  return lines.join("\n");
+}
+
+function formatFindingLocation(location: { readonly file: string; readonly line?: number; readonly symbol?: string }): string {
+  const line = location.line === undefined ? "" : `:${location.line}`;
+  const symbol = location.symbol === undefined ? "" : ` (${location.symbol})`;
+  return `${location.file}${line}${symbol}`;
 }
 
 function workflowEnvelope(
@@ -696,9 +729,8 @@ export default function workflowEngine(pi: ExtensionAPI): void {
         },
       });
       const perf = compactPerfSnapshot(perfSnapshot);
-      const detailLines = formatWorkflowDetailLines({ usage: usageSnapshot, perf, metadata: runMetadata });
       return {
-        content: [{ type: "text", text: `${summarize(result)}${detailLines.length > 0 ? `\n\n${detailLines.join("\n")}` : ""}` }],
+        content: [{ type: "text", text: formatMessageContent(resultName, result, usageSnapshot, perf, runMetadata) }],
         details: workflowEnvelope(resultName, result, usageSnapshot, perf, runMetadata),
       };
     },

package/.pi/extensions/pi-workflow-engine/src/worktree.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { cp, mkdir, rm } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
 import { runBoundedProcess } from "./process-runner.ts";
 
 export interface WorktreeGitCommandOptions {
@@ -24,11 +25,13 @@ export interface WorktreeGitRunner {
 
 export interface WorktreeRef {
   readonly path: string;
+  readonly snapshot?: boolean;
 }
 
 export interface WorktreeAddFailure {
   readonly path: string;
   readonly error: string;
+  readonly snapshot?: boolean;
   readonly cleanup?: WorktreeGitCommandResult;
 }
 
@@ -67,6 +70,7 @@ let pathCounter = 0;
 
 export class WorktreeRegistry {
   private readonly paths = new Set<string>();
+  private readonly snapshots = new Set<string>();
   private readonly runner: WorktreeGitRunner;
   private readonly patchCapture: WorktreePatchCapture;
   private readonly timeoutMs: number;
@@ -92,6 +96,7 @@ export class WorktreeRegistry {
   async add(signal?: AbortSignal): Promise<WorktreeRef | WorktreeAddFailure> {
     const added = await addWorktree({ repoCwd: this.repoCwd, runner: this.runner, signal, timeoutMs: this.timeoutMs });
     this.register(added.path);
+    if (added.snapshot === true) this.snapshots.add(added.path);
     if ("error" in added) {
       const cleanup = await this.remove(added.path);
       return { ...added, cleanup };
@@ -104,13 +109,16 @@ export class WorktreeRegistry {
   }
 
   async remove(path: string): Promise<WorktreeGitCommandResult> {
-    const result = await removeWorktree({ repoCwd: this.repoCwd, path, runner: this.runner, timeoutMs: this.timeoutMs }).catch((error: unknown) => ({
+    const result = await removeWorktree({ repoCwd: this.repoCwd, path, runner: this.runner, timeoutMs: this.timeoutMs, snapshot: this.snapshots.has(path) }).catch((error: unknown) => ({
       ok: false,
       stdout: "",
       stderr: "",
       error: formatError(error),
     }));
-    if (result.ok) this.paths.delete(path);
+    if (result.ok) {
+      this.paths.delete(path);
+      this.snapshots.delete(path);
+    }
     return result;
   }
 
@@ -163,8 +171,16 @@ export async function addWorktree(options: {
       timeoutMs: options.timeoutMs ?? DEFAULT_WORKTREE_TIMEOUT_MS,
     })
     .catch((error: unknown) => ({ ok: false, stdout: "", stderr: "", error: formatError(error) }));
-  if (!result.ok) return { path, error: result.error ?? (result.stderr.trim() || "git worktree add failed") };
-  return { path };
+  if (result.ok) return { path };
+
+  const message = result.error ?? (result.stderr.trim() || "git worktree add failed");
+  if (!isInvalidHeadError(message)) return { path, error: message };
+
+  const snapshotError = await createUnbornRepoSnapshot({ repoCwd: options.repoCwd, path, timeoutMs: options.timeoutMs, signal: options.signal })
+    .then(() => undefined)
+    .catch((error: unknown) => formatError(error));
+  if (snapshotError !== undefined) return { path, snapshot: true, error: `git worktree add failed (${message}); unborn-repo snapshot fallback failed: ${snapshotError}` };
+  return { path, snapshot: true };
 }
 
 export async function removeWorktree(options: {
@@ -172,7 +188,12 @@ export async function removeWorktree(options: {
   readonly path: string;
   readonly runner?: WorktreeGitRunner;
   readonly timeoutMs?: number;
+  readonly snapshot?: boolean;
 }): Promise<WorktreeGitCommandResult> {
+  if (options.snapshot === true) {
+    await rm(options.path, { recursive: true, force: true });
+    return { ok: true, stdout: "", stderr: "" };
+  }
   return await (options.runner ?? spawnGitRunner).runGit({
     cwd: options.repoCwd,
     args: ["worktree", "remove", "--force", options.path],
@@ -211,6 +232,38 @@ export async function captureWorktreePatch(options: {
   return { patch: diff.stdout, changed: diff.stdout.trim().length > 0 };
 }
 
+async function createUnbornRepoSnapshot(options: {
+  readonly repoCwd: string;
+  readonly path: string;
+  readonly signal?: AbortSignal;
+  readonly timeoutMs?: number;
+}): Promise<void> {
+  const targetRoot = resolve(options.path);
+  await rm(options.path, { recursive: true, force: true });
+  await mkdir(options.path, { recursive: true });
+  await cp(options.repoCwd, options.path, {
+    recursive: true,
+    force: true,
+    filter: (source) => {
+      const resolvedSource = resolve(source);
+      if (resolvedSource === targetRoot || resolvedSource.startsWith(`${targetRoot}${sep}`)) return false;
+      return !resolvedSource.split(/[\\/]/).includes(".git");
+    },
+  });
+  await runGitCommand({ cwd: options.path, args: ["init"], signal: options.signal, timeoutMs: options.timeoutMs ?? DEFAULT_WORKTREE_TIMEOUT_MS });
+  await runGitCommand({ cwd: options.path, args: ["add", "-A"], signal: options.signal, timeoutMs: options.timeoutMs ?? DEFAULT_WORKTREE_TIMEOUT_MS });
+  await runGitCommand({
+    cwd: options.path,
+    args: ["-c", "user.name=pi-workflow", "-c", "user.email=pi-workflow@example.invalid", "commit", "--allow-empty", "-m", "pi workflow baseline"],
+    signal: options.signal,
+    timeoutMs: options.timeoutMs ?? DEFAULT_WORKTREE_TIMEOUT_MS,
+  });
+}
+
+function isInvalidHeadError(message: string): boolean {
+  return /invalid reference:\s*HEAD/i.test(message) || /ambiguous argument ['"]?HEAD/i.test(message) || /unknown revision or path.*HEAD/i.test(message);
+}
+
 export const spawnGitRunner: WorktreeGitRunner = {
   async runGit(options) {
     return await runGitCommand(options);
@@ -218,11 +271,14 @@ export const spawnGitRunner: WorktreeGitRunner = {
 };
 
 async function runGitCommand(options: WorktreeGitCommandOptions): Promise<WorktreeGitCommandResult> {
+  const env = { ...process.env };
+  delete env.GIT_EXTERNAL_DIFF;
+  delete env.GIT_DIFF_OPTS;
   return await runBoundedProcess({
     file: "git",
     args: options.args,
     cwd: options.cwd,
-    env: { ...process.env, GIT_EXTERNAL_DIFF: "", GIT_DIFF_OPTS: "" },
+    env,
     signal: options.signal,
     timeoutMs: options.timeoutMs,
     maxBufferBytes: options.maxBufferBytes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-workflow-engine",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "type": "module",
   "description": "Zero-dependency Dynamax workflows for pi: live parallel subagents, typed handoffs, synthesized results.",
   "keywords": [