@quintinshaw/pi-dynamic-workflows 1.4.0 → 1.6.0

package/dist/workflow.js

@@ -6,6 +6,7 @@ import { DEFAULT_AGENT_TIMEOUT_MS, MAX_AGENTS_PER_RUN, MAX_CONCURRENCY } from ".
 import { WorkflowError, WorkflowErrorCode, wrapError } from "./errors.js";
 import { createWorkflowLogger } from "./logger.js";
 import { parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
+import { createWorktree, removeWorktree } from "./worktree.js";
 const DETERMINISM_BLOCKLIST = /\bDate\s*\.\s*now\b|\bMath\s*\.\s*random\b|\bnew\s+Date\s*\(\s*\)/;
 export async function runWorkflow(script, options = {}) {
     const started = Date.now();
@@ -15,6 +16,7 @@ export async function runWorkflow(script, options = {}) {
     const maxAgents = options.maxAgents ?? MAX_AGENTS_PER_RUN;
     const agentTimeoutMs = options.agentTimeoutMs ?? DEFAULT_AGENT_TIMEOUT_MS;
     const runId = options.runId ?? `run-${started.toString(36)}`;
+    const baseCwd = options.cwd ?? process.cwd();
     // Initialize logger
     const logger = createWorkflowLogger({
         runId,
@@ -88,6 +90,14 @@ export async function runWorkflow(script, options = {}) {
             const label = requestedLabel || defaultAgentLabel(assignedPhase, state.agentCount);
             const timeout = agentOptions.timeoutMs ?? agentTimeoutMs;
             options.onAgentStart?.({ label, phase: assignedPhase, prompt, model: modelSpec });
+            // Optional per-agent worktree isolation (deterministic name -> stable resume keys).
+            let worktree;
+            if (agentOptions.isolation === "worktree") {
+                worktree = await createWorktree(baseCwd, `${runId}-${callIndex}-${label}`);
+                if (!worktree.isolated)
+                    log(`isolation ignored for "${label}" (${worktree.reason})`);
+            }
+            const runCwd = worktree?.isolated ? worktree.cwd : undefined;
             // Captured from the subagent's real session usage; falls back to an
             // estimate when the provider reports no usage (total === 0).
             let usage;
@@ -111,6 +121,7 @@ export async function runWorkflow(script, options = {}) {
                     signal: options.signal,
                     instructions: buildAgentInstructions(assignedPhase, agentOptions),
                     model: modelSpec,
+                    cwd: runCwd,
                     onUsage: (u) => {
                         usage = u;
                     },
@@ -118,7 +129,7 @@ export async function runWorkflow(script, options = {}) {
                 throwIfAborted();
                 const tokens = recordTokens(result);
                 options.onAgentJournal?.({ index: callIndex, hash: callHash, result });
-                options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens });
+                options.onAgentEnd?.({ label, phase: assignedPhase, result, tokens, worktree: runCwd });
                 return result;
             }
             catch (error) {
@@ -127,13 +138,18 @@ export async function runWorkflow(script, options = {}) {
                 const workflowError = wrapError(error, { agentLabel: label });
                 logger.error(`agent ${label} failed: ${workflowError.message}`);
                 const tokens = recordTokens(null);
-                options.onAgentEnd?.({ label, phase: assignedPhase, result: null, tokens });
+                options.onAgentEnd?.({ label, phase: assignedPhase, result: null, tokens, worktree: runCwd });
                 // Return null for recoverable errors
                 if (workflowError.recoverable) {
                     return null;
                 }
                 throw workflowError;
             }
+            finally {
+                // Always tear down the worktree, even on timeout/abort.
+                if (worktree?.isolated)
+                    await removeWorktree(worktree);
+            }
         });
     };
     const parallel = async (thunks) => {

package/dist/worktree.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Per-agent git worktree isolation. When an agent requests `isolation: "worktree"`,
+ * it runs in a throwaway worktree on its own branch so parallel agents can edit the
+ * same files without conflict. Results are NOT auto-merged — the path is surfaced for
+ * the caller to inspect. Falls back to a logged no-op when isolation isn't possible.
+ */
+export interface Worktree {
+    /** True when a real worktree was created; false means "ran in the shared tree". */
+    isolated: boolean;
+    /** cwd the agent should run in (worktree path when isolated, else the base cwd). */
+    cwd: string;
+    branch?: string;
+    /** Repo root the worktree was added to (for teardown). */
+    repoRoot?: string;
+    /** Why isolation was skipped, when isolated === false. */
+    reason?: string;
+}
+/**
+ * Create an isolated worktree under `<repoRoot>/.pi/worktrees/<name>` on branch
+ * `pi/wf/<name>`. The `name` must be deterministic (derived from runId + call index,
+ * never wall-clock) so resume keys stay stable. Returns a no-op Worktree on any failure.
+ */
+export declare function createWorktree(baseCwd: string, name: string): Promise<Worktree>;
+/** Remove a worktree and its branch. Best-effort; safe to call on a no-op Worktree. */
+export declare function removeWorktree(wt: Worktree): Promise<void>;

package/dist/worktree.js

@@ -0,0 +1,61 @@
+/**
+ * Per-agent git worktree isolation. When an agent requests `isolation: "worktree"`,
+ * it runs in a throwaway worktree on its own branch so parallel agents can edit the
+ * same files without conflict. Results are NOT auto-merged — the path is surfaced for
+ * the caller to inspect. Falls back to a logged no-op when isolation isn't possible.
+ */
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+function slug(name) {
+    return (name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 32) || "agent");
+}
+/**
+ * Create an isolated worktree under `<repoRoot>/.pi/worktrees/<name>` on branch
+ * `pi/wf/<name>`. The `name` must be deterministic (derived from runId + call index,
+ * never wall-clock) so resume keys stay stable. Returns a no-op Worktree on any failure.
+ */
+export async function createWorktree(baseCwd, name) {
+    const id = slug(name);
+    let repoRoot;
+    try {
+        const { stdout } = await exec("git", ["-C", baseCwd, "rev-parse", "--show-toplevel"]);
+        repoRoot = stdout.trim();
+    }
+    catch {
+        return { isolated: false, cwd: baseCwd, reason: "not a git repository" };
+    }
+    const path = join(repoRoot, ".pi", "worktrees", id);
+    const branch = `pi/wf/${id}`;
+    try {
+        await exec("git", ["-C", repoRoot, "worktree", "add", "-b", branch, path, "HEAD"]);
+        return { isolated: true, cwd: path, branch, repoRoot };
+    }
+    catch (error) {
+        return { isolated: false, cwd: baseCwd, reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Remove a worktree and its branch. Best-effort; safe to call on a no-op Worktree. */
+export async function removeWorktree(wt) {
+    if (!wt.isolated || !wt.repoRoot)
+        return;
+    try {
+        await exec("git", ["-C", wt.repoRoot, "worktree", "remove", "--force", wt.cwd]);
+    }
+    catch {
+        // already gone / locked — fall through
+    }
+    if (wt.branch) {
+        try {
+            await exec("git", ["-C", wt.repoRoot, "branch", "-D", wt.branch]);
+        }
+        catch {
+            // branch already deleted
+        }
+    }
+}

package/extensions/workflow.ts

@@ -1,5 +1,11 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createWorkflowStorage, createWorkflowTool, registerWorkflowCommands, WorkflowManager } from "../src/index.js";
+import {
+  createWorkflowStorage,
+  createWorkflowTool,
+  registerBuiltinWorkflows,
+  registerWorkflowCommands,
+  WorkflowManager,
+} from "../src/index.js";
 
 export default function extension(pi: ExtensionAPI) {
   // Single manager/storage shared by the workflow tool and the /workflows command,
@@ -11,6 +17,7 @@ export default function extension(pi: ExtensionAPI) {
   const workflowTool = createWorkflowTool({ cwd, manager, storage });
   pi.registerTool(workflowTool);
   registerWorkflowCommands(pi, manager);
+  registerBuiltinWorkflows(pi, { cwd });
 
   pi.on("session_start", () => {
     const active = pi.getActiveTools();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quintinshaw/pi-dynamic-workflows",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Claude-Code-style dynamic workflow orchestration for Pi.",
   "type": "module",
   "main": "./dist/index.js",

package/src/adversarial-review.ts

@@ -12,61 +12,64 @@ export interface AdversarialReviewConfig {
   agreementThreshold: number;
 }
 
-const DEFAULT_CONFIG: AdversarialReviewConfig = {
-  reviewerCount: 2,
-  filterContested: true,
-  agreementThreshold: 0.5,
-};
-
 /**
- * Generate an adversarial review workflow script.
+ * Generate an adversarial-review workflow. The script is static and reads its
+ * inputs from `args` (task/reviewers/threshold) — no string interpolation.
+ *
+ * Each finding is judged independently by N reviewers who are told to REFUTE it;
+ * a finding survives only when the share of reviewers calling it real meets the
+ * agreement threshold.
  */
-export function generateAdversarialReviewWorkflow(
-  taskDescription: string,
-  config: Partial<AdversarialReviewConfig> = {},
-): string {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-
+export function generateAdversarialReviewWorkflow(): string {
   return `export const meta = {
   name: 'adversarial_review',
-  description: 'Adversarial review with ${cfg.reviewerCount} independent reviewers',
+  description: 'Adversarial review: findings cross-checked by independent skeptics',
   phases: [
-    { title: 'Initial Investigation' },
-    { title: 'Independent Review' },
-    { title: 'Cross-Check' },
+    { title: 'Investigate' },
+    { title: 'Refute' },
     { title: 'Consensus' },
   ],
-};
+}
 
-phase('Initial Investigation');
-const findings = await agent(
-  'Investigate and document findings for: ${taskDescription.replace(/'/g, "\\'").slice(0, 80)}',
-  { label: 'investigator' }
-);
+const task = (args && args.task) || ''
+const reviewers = (args && args.reviewers) || 2
+const threshold = (args && args.threshold) || 0.5
 
-phase('Independent Review');
-const reviews = await parallel(Array.from({ length: ${cfg.reviewerCount} }, (_, i) => () =>
-  agent(
-    'Independently review these findings. Agree or disagree with each point, and explain why:\\n\\n' + findings,
-    { label: 'reviewer-' + (i + 1) }
-  )
-));
+phase('Investigate')
+const investigation = await agent(
+  'Investigate the following and list concrete, individually-checkable findings:\\n' + task,
+  { label: 'investigate', schema: { type: 'object', properties: { findings: { type: 'array', items: { type: 'string' } } }, required: ['findings'] } }
+)
+const findings = investigation.findings || []
 
-phase('Cross-Check');
-const crossCheck = await agent(
-  'Compare these independent reviews and identify points of agreement and disagreement:\\n' +
-  'Reviews: ' + JSON.stringify(reviews) + '\\n' +
-  'Original findings: ' + findings,
-  { label: 'cross-checker' }
-);
+phase('Refute')
+const judged = await parallel(findings.map((f, i) => () =>
+  parallel(Array.from({ length: reviewers }, (_, r) => () =>
+    agent(
+      'You are a skeptical reviewer. Try to REFUTE this finding for the task below. ' +
+      'Default to real=false when uncertain. Investigate with the available tools if needed.\\n\\n' +
+      'TASK: ' + task + '\\nFINDING: ' + f,
+      { label: 'refute ' + (i + 1) + '.' + (r + 1), schema: { type: 'object', properties: { real: { type: 'boolean' }, reason: { type: 'string' } }, required: ['real'] } }
+    )
+  )).then((votes) => {
+    const valid = votes.filter(Boolean)
+    const realCount = valid.filter((v) => v && v.real).length
+    const ratio = valid.length ? realCount / valid.length : 0
+    return { finding: f, realVotes: realCount, totalVotes: valid.length, survives: ratio >= threshold }
+  })
+))
 
-phase('Consensus');
-const consensus = await agent(
-  'Based on the cross-check, produce a final verified report. Only include findings that survived independent review:\\n' + crossCheck,
-  { label: 'consensus-builder' }
-);
+const survivors = judged.filter((j) => j && j.survives)
+
+phase('Consensus')
+const report = await agent(
+  'Write a final review report. Include ONLY the findings that survived adversarial review (listed below), ' +
+  'each with a short justification. Note how many were discarded.\\n\\n' +
+  'SURVIVING FINDINGS JSON:\\n' + JSON.stringify(survivors),
+  { label: 'consensus' }
+)
 
-return { findings, reviews, crossCheck, consensus };`;
+return { total: findings.length, survivors, report }`;
 }
 
 /**

package/src/agent.ts

@@ -54,6 +54,8 @@ export interface AgentRunOptions<TSchemaDef extends TSchema | undefined = undefi
   model?: string;
   /** Called with the resolved model id once known (for display/telemetry). */
   onModelResolved?: (modelId: string) => void;
+  /** Run this agent in a different working directory (e.g. an isolated worktree). */
+  cwd?: string;
 }
 
 export type AgentRunResult<TSchemaDef extends TSchema | undefined> = TSchemaDef extends TSchema
@@ -105,7 +107,11 @@ export class WorkflowAgent {
     options: AgentRunOptions<TSchemaDef> = {},
   ): Promise<AgentRunResult<TSchemaDef>> {
     const capture: StructuredOutputCapture<any> = { called: false, value: undefined };
-    const customTools: ToolDefinition[] = [...this.baseTools, ...(options.tools ?? [])];
+    // Per-call cwd (e.g. a worktree) needs coding tools bound to that directory,
+    // since tools capture their cwd at construction and can't be relocated.
+    const runCwd = options.cwd ?? this.cwd;
+    const baseTools = runCwd === this.cwd ? this.baseTools : createCodingTools(runCwd);
+    const customTools: ToolDefinition[] = [...baseTools, ...(options.tools ?? [])];
 
     if (options.schema) {
       customTools.push(createStructuredOutputTool({ schema: options.schema, capture }) as unknown as ToolDefinition);
@@ -125,7 +131,7 @@ export class WorkflowAgent {
 
     const agentDir = getAgentDir();
     const { session } = await createAgentSession({
-      cwd: this.cwd,
+      cwd: runCwd,
       agentDir,
       sessionManager: SessionManager.inMemory(),
       // Use real SettingsManager to inherit user's default provider/model settings.

package/src/builtin-commands.ts

@@ -0,0 +1,77 @@
+/**
+ * Bundled workflow commands: `/deep-research` and `/adversarial-review`.
+ * They run a generated workflow script and print the final report.
+ */
+
+import { createCodingTools, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { generateAdversarialReviewWorkflow } from "./adversarial-review.js";
+import { generateDeepResearchWorkflow } from "./deep-research.js";
+import { createWebTools } from "./web-tools.js";
+import { runWorkflow, type WorkflowRunResult } from "./workflow.js";
+
+function alreadyRegistered(pi: ExtensionAPI, name: string): boolean {
+  try {
+    return (pi.getCommands?.() ?? []).some((c: { name: string }) => c.name === name);
+  } catch {
+    return false;
+  }
+}
+
+function reportText(result: WorkflowRunResult): string {
+  const r = result.result as { report?: unknown } | undefined;
+  if (r && typeof r.report === "string" && r.report.trim()) return r.report;
+  return JSON.stringify(result.result, null, 2);
+}
+
+export function registerBuiltinWorkflows(pi: ExtensionAPI, opts: { cwd: string }): void {
+  const cwd = opts.cwd;
+
+  if (!alreadyRegistered(pi, "deep-research")) {
+    pi.registerCommand("deep-research", {
+      description: "Research a question across the web with cross-checked sources",
+      async handler(args: string, ctx: ExtensionCommandContext) {
+        const question = args.trim();
+        if (!question) return ctx.ui.notify("Usage: /deep-research <question>", "warning");
+        ctx.ui.notify("Researching — running web searches across several angles…", "info");
+        try {
+          const result = await runWorkflow(generateDeepResearchWorkflow(), {
+            cwd,
+            args: { question },
+            // Research agents need real web access on top of the coding tools.
+            tools: [...createCodingTools(cwd), ...createWebTools()],
+            onPhase: (title) => ctx.ui.setStatus("deep-research", `research: ${title}`),
+          });
+          ctx.ui.setStatus("deep-research", undefined);
+          await pi.sendMessage({ customType: "deep-research", content: reportText(result), display: true });
+        } catch (error) {
+          ctx.ui.setStatus("deep-research", undefined);
+          ctx.ui.notify(`deep-research failed: ${error instanceof Error ? error.message : error}`, "error");
+        }
+      },
+    });
+  }
+
+  if (!alreadyRegistered(pi, "adversarial-review")) {
+    pi.registerCommand("adversarial-review", {
+      description: "Investigate a task, then cross-check each finding with skeptical reviewers",
+      async handler(args: string, ctx: ExtensionCommandContext) {
+        const task = args.trim();
+        if (!task) return ctx.ui.notify("Usage: /adversarial-review <task or question>", "warning");
+        ctx.ui.notify("Reviewing — investigating then refuting each finding…", "info");
+        try {
+          const result = await runWorkflow(generateAdversarialReviewWorkflow(), {
+            cwd,
+            args: { task },
+            tools: createCodingTools(cwd),
+            onPhase: (title) => ctx.ui.setStatus("adversarial-review", `review: ${title}`),
+          });
+          ctx.ui.setStatus("adversarial-review", undefined);
+          await pi.sendMessage({ customType: "adversarial-review", content: reportText(result), display: true });
+        } catch (error) {
+          ctx.ui.setStatus("adversarial-review", undefined);
+          ctx.ui.notify(`adversarial-review failed: ${error instanceof Error ? error.message : error}`, "error");
+        }
+      },
+    });
+  }
+}

package/src/deep-research.ts

@@ -4,80 +4,72 @@
  */
 
 export interface DeepResearchConfig {
-  /** Number of search angles to explore. */
-  searchAngles: number;
-  /** Number of sources to fetch per angle. */
-  sourcesPerAngle: number;
-  /** Whether to cross-check claims across sources. */
-  crossCheck: boolean;
-  /** Maximum number of agents to use. */
-  maxAgents: number;
+  /** Number of distinct search angles/queries to explore. */
+  angles: number;
+  /** Minimum distinct sources required for a claim to survive cross-checking. */
+  minSupport: number;
 }
 
-const DEFAULT_CONFIG: DeepResearchConfig = {
-  searchAngles: 4,
-  sourcesPerAngle: 3,
-  crossCheck: true,
-  maxAgents: 20,
-};
-
 /**
- * Generate a deep research workflow script.
+ * Generate a deep-research workflow that uses the real web_search/web_fetch tools.
+ *
+ * The script is static and reads its inputs from `args` (question/angles/minSupport),
+ * so the question is never string-interpolated into source — no escaping hazards.
+ * Inject the web tools at run time via the agent's `tools` option.
  */
-export function generateDeepResearchWorkflow(question: string, config: Partial<DeepResearchConfig> = {}): string {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-  const escapedQuestion = question.replace(/'/g, "\\'").slice(0, 80);
-
-  const crossCheckPhase = cfg.crossCheck
-    ? `phase('Cross-Check');
-const crossCheck = await agent(
-  'Cross-check these research findings. Identify claims that are supported by multiple sources vs. claims that appear in only one source:\\n' +
-  'Sources: ' + JSON.stringify(sources),
-  { label: 'cross-checker' }
-);`
-    : "";
-
-  const crossCheckRef = cfg.crossCheck ? "'Cross-check: ' + crossCheck + '\\n' + " : "";
-  const crossCheckReturn = cfg.crossCheck ? "crossCheck, " : "";
-
+export function generateDeepResearchWorkflow(): string {
   return `export const meta = {
   name: 'deep_research',
-  description: 'Deep research: ${escapedQuestion}',
+  description: 'Deep research with real web search and cross-checked claims',
   phases: [
-    { title: 'Search Planning' },
-    { title: 'Source Gathering' },
-    { title: 'Cross-Check' },
+    { title: 'Queries' },
+    { title: 'Gather' },
+    { title: 'Verify' },
     { title: 'Report' },
   ],
-};
+}
 
-phase('Search Planning');
-const question = '${escapedQuestion}';
-const searchPlan = await agent(
-  'Plan ${cfg.searchAngles} different search angles to research this question comprehensively: ' + question,
-  { label: 'search-planner' }
-);
+const question = (args && args.question) || ''
+const angles = (args && args.angles) || 4
+const minSupport = (args && args.minSupport) || 2
+
+phase('Queries')
+const plan = await agent(
+  'You are planning web research for this question:\\n' + question +
+  '\\n\\nProduce ' + angles + ' diverse, specific search queries that together cover the question from different angles.',
+  { label: 'plan queries', schema: { type: 'object', properties: { queries: { type: 'array', items: { type: 'string' } } }, required: ['queries'] } }
+)
+const queries = (plan.queries || []).slice(0, angles)
 
-phase('Source Gathering');
-const sources = await parallel(Array.from({ length: ${cfg.searchAngles} }, (_, i) => () =>
+phase('Gather')
+const gathered = await parallel(queries.map((q, i) => () =>
   agent(
-    'Research angle ' + (i + 1) + ' for this question: ' + question + '\\n\\nPlan: ' + searchPlan + '\\n\\nFind and summarize ${cfg.sourcesPerAngle} relevant sources.',
-    { label: 'researcher-' + (i + 1) }
+    'Research this query using the web_search and web_fetch tools.\\nQuery: ' + q +
+    '\\n\\nSteps: (1) call web_search with the query; (2) web_fetch the 2 most relevant result URLs; ' +
+    '(3) extract concrete, verifiable factual claims, each tagged with the exact source URL it came from. ' +
+    'Do NOT invent sources or claims — report only what the fetched pages actually say.',
+    { label: 'research ' + (i + 1), schema: { type: 'object', properties: { sources: { type: 'array', items: { type: 'object', properties: { url: { type: 'string' }, claims: { type: 'array', items: { type: 'string' } } }, required: ['url', 'claims'] } } }, required: ['sources'] } }
   )
-));
-
-${crossCheckPhase}
-
-phase('Report');
+))
+const allSources = gathered.filter(Boolean).flatMap((g) => (g && g.sources) || [])
+
+phase('Verify')
+const verdict = await agent(
+  'Cross-check these research sources. Group claims that assert the same fact across different source URLs. ' +
+  'Keep a claim only if it is supported by at least ' + minSupport + ' distinct source URLs OR by one clearly authoritative source. ' +
+  'Discard claims found in a single weak source or that conflict with others.\\n\\nSOURCES JSON:\\n' + JSON.stringify(allSources),
+  { label: 'cross-check', schema: { type: 'object', properties: { supported: { type: 'array', items: { type: 'object', properties: { claim: { type: 'string' }, sources: { type: 'array', items: { type: 'string' } } }, required: ['claim', 'sources'] } }, discarded: { type: 'array', items: { type: 'string' } } }, required: ['supported'] } }
+)
+
+phase('Report')
 const report = await agent(
-  'Synthesize a comprehensive research report from these findings:\\n' +
-  'Question: ' + question + '\\n' +
-  'Sources: ' + JSON.stringify(sources) + '\\n' +
-  ${crossCheckRef}'\\n\\nProduce a well-structured report with citations and confidence levels.',
-  { label: 'report-writer' }
-);
+  'Write a concise, well-structured research report that answers the question using ONLY the supported claims below. ' +
+  'Cite source URLs inline next to each claim. If the evidence is thin, say so explicitly.\\n\\n' +
+  'QUESTION: ' + question + '\\n\\nSUPPORTED CLAIMS JSON:\\n' + JSON.stringify((verdict && verdict.supported) || []),
+  { label: 'write report' }
+)
 
-return { searchPlan, sources, ${crossCheckReturn}report };`;
+return { question, queries, supported: (verdict && verdict.supported) || [], report }`;
 }
 
 /**

package/src/index.ts

@@ -4,6 +4,7 @@ export type { AgentRunOptions, AgentRunResult, WorkflowAgentOptions } from "./ag
 export { WorkflowAgent } from "./agent.js";
 export type { AutoWorkflowConfig } from "./auto-workflow.js";
 export { shouldUseWorkflow, suggestWorkflowScript } from "./auto-workflow.js";
+export { registerBuiltinWorkflows } from "./builtin-commands.js";
 export * from "./config.js";
 export type { DeepResearchConfig } from "./deep-research.js";
 export { generateCodebaseAuditWorkflow, generateDeepResearchWorkflow } from "./deep-research.js";
@@ -39,8 +40,10 @@ export type { PersistedRunState, RunPersistence, RunStatus } from "./run-persist
 export { createRunPersistence, generateRunId } from "./run-persistence.js";
 export type { StructuredOutputCapture, StructuredOutputToolOptions } from "./structured-output.js";
 export { createStructuredOutputTool } from "./structured-output.js";
+export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";
 export type {
   AgentOptions,
+  JournalEntry,
   WorkflowMeta,
   WorkflowMetaPhase,
   WorkflowRunOptions,
@@ -54,3 +57,5 @@ export type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
 export { createWorkflowStorage } from "./workflow-saved.js";
 export type { WorkflowToolInput, WorkflowToolOptions } from "./workflow-tool.js";
 export { createWorkflowTool } from "./workflow-tool.js";
+export type { Worktree } from "./worktree.js";
+export { createWorktree, removeWorktree } from "./worktree.js";