@bastani/atomic 0.9.8 → 0.9.9-alpha.1

package/dist/builtin/workflows/src/extension/workflow-run-control-command.ts

@@ -1,20 +1,17 @@
 import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { interruptAllRuns, interruptRun, killAllRuns, killRun, pauseRun, resumeRun } from "../runs/background/status.js";
-import type { WorkflowPersistencePort } from "../shared/types.js";
+import { getDurableBackend } from "../durable/factory.js";
 import { store } from "../shared/store.js";
 import { topLevelWorkflowRuns } from "../shared/run-visibility.js";
 import { renderSessionList } from "../tui/session-list.js";
 import { openKillConfirm, openSessionPicker } from "../tui/session-overlays.js";
-import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
 import { deriveGraphTheme } from "../tui/graph-theme.js";
+import { openWorkflowResumeSelector } from "../tui/workflow-resume-selector.js";
 import { emitChatSurface } from "../tui/chat-surface-message.js";
-import type { GraphOverlayPort } from "../tui/overlay-adapter.js";
-import type { ExtensionRuntime } from "./runtime.js";
-import type { ExtensionAPI, PiCommandContext } from "./public-types.js";
+import type { PiCommandContext } from "./public-types.js";
 import type { WorkflowCommandReporter } from "./workflow-command-utils.js";
 import { stripYesFlag } from "./workflow-command-utils.js";
 import { workflowPolicyFromContext } from "./workflow-policy.js";
-import { formatResumableWorkflowList } from "../durable/resume-catalog.js";
 import type { ResumableWorkflowEntry } from "../durable/types.js";
 import {
   formatAlreadyEndedRetainedMessage,
@@ -23,14 +20,14 @@ import {
   resolveStageTarget,
 } from "./workflow-targets.js";
 import { formatWorkflowResourceLoadWarning } from "./workflow-command-surfaces.js";
+import {
+  handleDurableResume,
+  prepareWorkflowResumeCatalog,
+  resolveWorkflowResumeTarget,
+  type WorkflowRunControlDeps,
+} from "./workflow-durable-resume-command.js";
 
-export interface WorkflowRunControlDeps {
-  pi: ExtensionAPI;
-  overlay: GraphOverlayPort;
-  getPersistence: () => WorkflowPersistencePort | undefined;
-  runtimeForContext: (ctx?: PiCommandContext) => ExtensionRuntime;
-  ensureWorkflowResourcesLoaded: () => Promise<void> | void;
-}
+export type { WorkflowRunControlDeps } from "./workflow-durable-resume-command.js";
 
 function resolveAttachStageId(runId: string, stageTarget: string | undefined): string | undefined | false {
   if (!stageTarget) return undefined;
@@ -42,79 +39,6 @@ function resolveAttachStageId(runId: string, stageTarget: string | undefined): s
   return byName?.id ?? false;
 }
 
-function filterSelectorDurableEntries(
-  runtime: ExtensionRuntime,
-  entries: readonly ResumableWorkflowEntry[],
-): readonly ResumableWorkflowEntry[] {
-  const registry = runtime.registry as { has(name: string): boolean } | undefined;
-  if (registry === undefined) return entries;
-  return entries.filter((entry) => {
-    const requiresCurrentDefinition = entry.status === "running" || entry.status === "failed" || entry.status === "blocked";
-    return !requiresCurrentDefinition || registry.has(entry.name);
-  });
-}
-
-
-async function handleDurableResume(
-  target: string | undefined,
-  ctx: PiCommandContext,
-  reporter: WorkflowCommandReporter,
-  deps: WorkflowRunControlDeps,
-): Promise<boolean> {
-  const print = (msg: string): void => reporter.info(msg);
-  const fail = (msg: string): void => reporter.error(msg);
-  try {
-    await deps.ensureWorkflowResourcesLoaded();
-  } catch (error) {
-    ctx.ui?.notify(formatWorkflowResourceLoadWarning(error), "warning");
-  }
-  const runtime = deps.runtimeForContext(ctx);
-  const policy = workflowPolicyFromContext(ctx);
-  // Hydrate the durable backend from DBOS (if configured) before listing so a
-  // fresh process discovers workflows persisted by a prior session.
-  const prepared = await runtime.prepareDurableResumable(target);
-  const durable = filterSelectorDurableEntries(runtime, prepared);
-  if (target !== undefined) {
-    // Attempt resume by id/prefix against the durable catalog.
-    const result = runtime.resumeDurableWorkflow(target, { policy });
-    if (result.ok) {
-      print(result.message);
-      // Open/connect the overlay to the resumed run, analogous to live resume.
-      if (policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
-      return true;
-    }
-    // Not a durable workflow either — surface the catalog for discovery.
-    if (durable.length > 0) {
-      fail(`${result.message}\n\n${formatResumableWorkflowList(durable)}`);
-    } else {
-      fail(result.message);
-    }
-    return true;
-  }
-  // No target: show the durable selector when interactive, otherwise print.
-  if (durable.length === 0) {
-    fail("No resumable durable workflows found. Usage: /workflow resume <id> (or /resume for Atomic sessions).");
-    return true;
-  }
-  if (!policy.allowInputPicker) {
-    print(`${formatResumableWorkflowList(durable)}\n\nResume with: /workflow resume <id>`);
-    return true;
-  }
-  const picked = await openWorkflowResumeSelector(ctx.ui, [], durable);
-  if (picked.kind === "durable") {
-    const result = runtime.resumeDurableWorkflow(picked.workflowId, { policy });
-    if (result.ok) {
-      print(result.message);
-      if (policy.allowInputPicker) deps.overlay.open(result.runId, overlaySurfaceFromContext(ctx));
-    } else {
-      fail(result.message);
-    }
-  }
-  if (picked.kind !== "durable") {
-    print(`${formatResumableWorkflowList(durable)}\n\nResume with: /workflow resume <id>`);
-  }
-  return true;
-}
 
 export async function handleRunControlCommand(
   action: "connect" | "interrupt" | "kill" | "attach" | "pause" | "resume",
@@ -304,33 +228,35 @@ export async function handleRunControlCommand(
         // Only inactive workflows belong in the resume selector. Live runs:
         // show paused (quit) or recoverably-failed runs; actively-running live
         // runs are hidden (resuming one that is executing would double-dispatch).
-        const liveRuns = topLevelWorkflowRuns(store.runs()).filter((run) =>
+        let liveRuns = topLevelWorkflowRuns(store.runs()).filter((run) =>
           run.status === "paused" || (run.status === "failed" && run.resumable !== false),
         );
+        const activeLiveIds = new Set(
+          topLevelWorkflowRuns(store.runs())
+            .filter((run) => run.endedAt === undefined && run.status === "running" && run.exitReason !== "quit")
+            .map((run) => run.id),
+        );
+        await ensureWorkflowResourcesVisible();
+        const runtime = deps.runtimeForContext(ctx);
         let durableEntries: readonly ResumableWorkflowEntry[] = [];
-        if (liveRuns.length === 0) {
-          // Durable entries: a `running` durable handle may be a crashed process
-          // (cross-session crash recovery), so it stays selectable UNLESS it
-          // matches an actively-executing live run in this session.
-          const activeLiveIds = new Set(
-            topLevelWorkflowRuns(store.runs())
-              .filter((run) => run.endedAt === undefined && run.status === "running" && run.exitReason !== "quit")
-              .map((run) => run.id),
-          );
-          await ensureWorkflowResourcesVisible();
-          const runtime = deps.runtimeForContext(ctx);
-          try {
-            const prepared = await runtime.prepareDurableResumable(undefined);
-            durableEntries = filterSelectorDurableEntries(runtime, prepared)
-              .filter((entry) => !activeLiveIds.has(entry.workflowId));
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            fail(`Failed to list resumable workflows: ${message}`);
+        let completedEntries: readonly ResumableWorkflowEntry[] = [];
+        try {
+          const catalog = await prepareWorkflowResumeCatalog(runtime, activeLiveIds);
+          durableEntries = catalog.resumable;
+          completedEntries = catalog.completed;
+        } catch (error) {
+          liveRuns = liveRuns.filter((run) => getDurableBackend().isWorkflowLoadable(run.id));
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          if (liveRuns.length === 0) {
+            fail(`Failed to list workflow resume targets: ${errorMessage}`);
             return true;
           }
         }
-        const picked = await openWorkflowResumeSelector(ctx.ui, liveRuns, durableEntries);
-        if (picked.kind === "durable") return await handleDurableResume(picked.workflowId, ctx, reporter, deps);
+        liveRuns = liveRuns.filter((run) => getDurableBackend().isWorkflowLoadable(run.id));
+        const picked = await openWorkflowResumeSelector(ctx.ui, liveRuns, durableEntries, completedEntries);
+        if (picked.kind === "durable" || picked.kind === "completed") {
+          return await handleDurableResume(picked.workflowId, ctx, reporter, deps);
+        }
         if (picked.kind === "live") {
           const resolved = resolveRunIdPrefix(picked.runId);
           if (resolved.kind !== "exact") {
@@ -359,14 +285,42 @@ export async function handleRunControlCommand(
       if (action === "attach" && picked.kind === "kill") return handleRunControlCommand("kill", [picked.runId, "-y"], ctx, reporter, deps);
       if (picked.kind !== (action === "attach" ? "connect" : action)) return true;
       runId = picked.runId;
+    } else if (action === "resume") {
+      const backend = getDurableBackend();
+      const exactBeforePreparation = store.runs().find((run) => run.id === target);
+      let durable: readonly ResumableWorkflowEntry[] = [];
+      let preparationError: string | undefined;
+      const needsDurablePreparation = exactBeforePreparation === undefined
+        || !backend.isWorkflowLoadable(exactBeforePreparation.id);
+      if (needsDurablePreparation) {
+        await ensureWorkflowResourcesVisible();
+        const runtime = deps.runtimeForContext(ctx);
+        try {
+          durable = await runtime.prepareDurableResumable(target);
+        } catch (error) {
+          preparationError = error instanceof Error ? error.message : String(error);
+        }
+      }
+      const loadableRuns = topLevelWorkflowRuns(store.runs()).filter((run) => backend.isWorkflowLoadable(run.id));
+      const combined = resolveWorkflowResumeTarget(target, loadableRuns, durable, backend.listCompletedWorkflows());
+      if (combined.kind === "ambiguous") {
+        fail(`Ambiguous workflow prefix "${target}" matches: ${combined.matches.map((match) => `${match.name} (${match.workflowId.slice(0, 8)})`).join(", ")}`);
+        return true;
+      }
+      if (combined.kind === "completed" || combined.kind === "durable") {
+        return await handleDurableResume(combined.workflowId, ctx, reporter, deps);
+      }
+      if (combined.kind === "live") runId = combined.workflowId;
+      else {
+        if (preparationError !== undefined) {
+          fail(`Failed to resolve workflow resume target: ${preparationError}`);
+          return true;
+        }
+        return await handleDurableResume(target, ctx, reporter, deps);
+      }
     } else {
       const resolved = resolveRunIdPrefix(target);
       if (resolved.kind === "not_found") {
-        // Not a live run — fall back to the cross-session durable resume catalog.
-        // cross-ref: issue #1498 — /workflow resume by top-level workflow id.
-        if (action === "resume") {
-          return await handleDurableResume(target, ctx, reporter, deps);
-        }
         fail(`Run not found: ${target}`);
         return true;
       }

package/dist/builtin/workflows/src/extension/workflow-schema.ts

@@ -45,7 +45,7 @@ const JsonSchemaObject = Type.Unsafe<Record<string, unknown>>({
 
 const StageSessionOptionProperties = {
   schema: Type.Optional(JsonSchemaObject),
-  cwd: Type.Optional(Type.String()),
+  cwd: Type.Optional(Type.String({ description: "Starting directory only; does not provide worktree isolation." })),
   agentDir: Type.Optional(Type.String()),
   authStorage: Type.Optional(SdkSessionOptionSchema("authStorage")),
   modelRegistry: Type.Optional(SdkSessionOptionSchema("modelRegistry")),
@@ -88,8 +88,8 @@ const WorkflowTaskOptionProperties = {
   output: Type.Optional(WorkflowOutputSchema),
   outputMode: Type.Optional(Type.Union([Type.Literal("inline"), Type.Literal("file-only")])),
   reads: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Literal(false)])),
-  worktree: Type.Optional(Type.Boolean()),
-  gitWorktreeDir: Type.Optional(Type.String()),
+  worktree: Type.Optional(Type.Boolean({ description: "Runner-managed temporary per-task worktree isolation for direct runs." })),
+  gitWorktreeDir: Type.Optional(Type.String({ description: "Runner-managed reusable worktree; natural-language worktree instructions do not set this option." })),
   baseBranch: Type.Optional(Type.String()),
   maxOutput: Type.Optional(MaxOutputSchema),
   artifacts: Type.Optional(Type.Boolean()),
@@ -107,8 +107,8 @@ const ParallelChainStepSchema = Type.Object({
   parallel: Type.Array(DirectTaskSchema),
   concurrency: Type.Optional(Type.Number()),
   failFast: Type.Optional(Type.Boolean()),
-  worktree: Type.Optional(Type.Boolean()),
-  gitWorktreeDir: Type.Optional(Type.String()),
+  worktree: Type.Optional(Type.Boolean({ description: "Runner-managed temporary per-task worktree isolation for direct runs." })),
+  gitWorktreeDir: Type.Optional(Type.String({ description: "Runner-managed reusable worktree; natural-language worktree instructions do not set this option." })),
   baseBranch: Type.Optional(Type.String()),
 });
 

package/dist/builtin/workflows/src/extension/workflow-tool-control.ts

@@ -9,6 +9,7 @@ import {
 } from "../runs/background/status.js";
 import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { store } from "../shared/store.js";
+import { getDurableBackend } from "../durable/factory.js";
 import type { WorkflowExecutionPolicy, WorkflowPersistencePort } from "../shared/types.js";
 import type { ExtensionRuntime } from "./runtime.js";
 import type { WorkflowToolResult } from "./render-result.js";
@@ -176,6 +177,21 @@ export async function workflowResumeAction(
   if (target.kind === "all") return { action: "resume", runId: "--all", status: "noop", message: "Resume does not support --all." };
   if (target.kind === "ambiguous") return { action: "resume", runId: target.target, status: "noop", message: ambiguousRunMessage(target.target, target.matches) };
   if (target.kind === "not_found") return { action: "resume", runId: target.target, status: "noop", message: target.message };
+  const backend = getDurableBackend();
+  if (!backend.isWorkflowLoadable(target.runId)) {
+    try {
+      await deps.ensureWorkflowResourcesLoaded();
+      await deps.getRuntime().prepareDurableResumable(target.runId);
+    } catch {
+      // Durable compatibility preparation failures fall through to the
+      // authoritative loadability check below; workflow resume remains best-effort.
+    }
+    if (!backend.isWorkflowLoadable(target.runId)) {
+      store.removeRun(target.runId);
+      return { action: "resume", runId: target.runId, status: "noop", message: `Run not found: ${target.runId}` };
+    }
+  }
+  let warning: string | undefined;
   const stage = resolveToolStageTarget(target.runId, args.stageId);
   if (!stage.ok) return { action: "resume", runId: target.runId, status: "noop", message: stage.message };
   const stageRunId = stage.runId ?? target.runId;
@@ -188,7 +204,6 @@ export async function workflowResumeAction(
     (run.endedAt === undefined && run.resumable === true && run.failureRecoverability === "recoverable")
   );
   if (isResumableContinuation) {
-    let warning: string | undefined;
     try {
       await deps.ensureWorkflowResourcesLoaded();
     } catch (error) {

package/dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts

@@ -1,6 +1,6 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { CONFIG_DIR_NAME, isCodexFastModeCandidateModelId } from "@bastani/atomic";
+import { APP_NAME, CONFIG_DIR_NAME, isCodexFastModeCandidateModelId } from "@bastani/atomic";
 import { Type } from "typebox";
 import type {
   StageOptions,
@@ -10,7 +10,6 @@ import type {
   WorkflowDetails,
   WorkflowDirectOptions,
   WorkflowDirectTaskItem,
-  WorkflowOutputMode,
   WorkflowOutputSchema,
   WorkflowTaskResult,
   WorkflowTaskStep,
@@ -30,10 +29,11 @@ import {
   type GitWorktreeSetupResult,
   type WorktreeSetup,
 } from "../shared/worktree.js";
+import { resolveWorktreeStageCwd } from "../shared/worktree-cwd.js";
 import type { RunOpts, RunResult } from "./executor-types.js";
 import { isWorkflowExitStatus } from "./executor-abort.js";
-import { directTaskWithDefaults, resolveWorkflowPath, taskBaseDir, withoutUndefinedProperties } from "./executor-task-prompts.js";
-export { createGitWorktreeSetupCache } from "../shared/worktree.js";
+import { directTaskWithDefaults, withoutUndefinedProperties } from "./executor-task-prompts.js";
+export { createGitWorktreeSetupCache, createGitWorktreeSetupCacheOwner } from "../shared/worktree.js";
 export type { GitWorktreeSetupCache } from "../shared/worktree.js";
 
 export function directModelRequestsFromChain(
@@ -190,11 +190,17 @@ function namespaceRepeatedOutput(output: WorkflowDirectTaskItem["output"], index
   return join(dirname(output), `${base}-${index + 1}${ext}`);
 }
 
+export interface DirectOutputIsolation {
+  readonly baseDir: string;
+  readonly trustedRoot: string;
+}
+
 export interface PreparedDirectWorktrees {
   readonly tasks: WorkflowDirectTaskItem[];
   readonly setup?: WorktreeSetup;
   readonly agents: string[];
   readonly diffsDir?: string;
+  readonly outputIsolations?: readonly DirectOutputIsolation[];
 }
 
 export function directRunId(runOptions: RunOpts): string {
@@ -205,20 +211,18 @@ function hasDirectWorktreeIsolation(tasks: readonly WorkflowDirectTaskItem[], op
   return options.worktree === true || tasks.some((task) => task.worktree === true);
 }
 
-function resolveSharedDirectWorktreeCwd(tasks: readonly WorkflowDirectTaskItem[]): string {
+function resolveSharedDirectWorktreeCwd(
+  tasks: readonly WorkflowDirectTaskItem[],
+  workflowInvocationCwd: string,
+): string {
   const explicitCwd = tasks.find((task) => typeof task.cwd === "string")?.cwd;
-  if (explicitCwd === undefined) return process.cwd();
-  return isAbsolute(explicitCwd) ? explicitCwd : resolve(process.cwd(), explicitCwd);
+  if (explicitCwd === undefined) return workflowInvocationCwd;
+  return isAbsolute(explicitCwd) ? explicitCwd : resolve(workflowInvocationCwd, explicitCwd);
 }
 
-function normalizeDirectTaskCwd(cwd: string | undefined): string | undefined {
+function normalizeDirectTaskCwd(cwd: string | undefined, workflowInvocationCwd: string): string | undefined {
   if (cwd === undefined) return undefined;
-  return isAbsolute(cwd) ? cwd : resolve(process.cwd(), cwd);
-}
-
-export function resolveWorktreeCwdOverride(cwd: string | undefined, worktreeCwd: string): string | undefined {
-  if (cwd === undefined || cwd.length === 0) return undefined;
-  return isAbsolute(cwd) ? cwd : resolve(worktreeCwd, cwd);
+  return isAbsolute(cwd) ? cwd : resolve(workflowInvocationCwd, cwd);
 }
 
 export function stageOptionsWithInputDefaults<T extends StageOptions>(options: T | undefined, inputDefaults: Partial<StageOptions>): T | undefined {
@@ -229,13 +233,16 @@ export function stageOptionsWithInputDefaults<T extends StageOptions>(options: T
 
 export function stageOptionsWithGitWorktree<T extends StageOptions>(options: T | undefined, workflowInvocationCwd: string, cache?: GitWorktreeSetupCache): T | undefined {
   if (options === undefined) return undefined;
-  if (typeof options.gitWorktreeDir !== "string" || options.gitWorktreeDir.trim().length === 0) return options;
+  if (typeof options.gitWorktreeDir !== "string") return options;
+  if (options.gitWorktreeDir.trim().length === 0) {
+    throw new Error("atomic-workflows: gitWorktreeDir cannot be empty; provide a reusable worktree path or omit gitWorktreeDir for a non-worktree run.");
+  }
   const setup = setupGitWorktreeCached({
     gitWorktreeDir: options.gitWorktreeDir,
     baseBranch: options.baseBranch,
     cwd: workflowInvocationCwd,
   }, cache);
-  const explicitCwd = resolveWorktreeCwdOverride(options.cwd, setup.cwd);
+  const explicitCwd = resolveWorktreeStageCwd(options.cwd, setup);
   return { ...options, gitWorktreeDir: undefined, baseBranch: undefined, cwd: explicitCwd ?? setup.cwd };
 }
 
@@ -267,9 +274,24 @@ export function workflowInvocationMetadata(inputDefaults: Partial<StageOptions>,
   };
 }
 
+function nonBlankChainDir(chainDir: string | undefined): string | undefined {
+  return typeof chainDir === "string" && chainDir.trim().length > 0 ? chainDir : undefined;
+}
+
+function directWorktreeArtifactBase(options: WorkflowDirectOptions, setup: WorktreeSetup): string {
+  return nonBlankChainDir(options.chainDir) ?? join(setup.cwd, CONFIG_DIR_NAME, "workflows");
+}
+
 function directWorktreeDiffsDir(options: WorkflowDirectOptions, setup: WorktreeSetup, runId: string, scope: string): string {
-  const baseDir = options.chainDir ?? join(setup.cwd, CONFIG_DIR_NAME, "workflows");
-  return join(baseDir, "worktree-diffs", runId, scope);
+  return join(directWorktreeArtifactBase(options, setup), "worktree-diffs", runId, scope);
+}
+
+function directWorktreeOutputsRoot(): string {
+  return join(tmpdir(), `${APP_NAME}-workflow-outputs`);
+}
+
+function directWorktreeOutputsDir(runId: string, scope: string, index: number): string {
+  return join(directWorktreeOutputsRoot(), runId, scope, String(index));
 }
 
 export function prepareDirectWorktrees(
@@ -277,6 +299,7 @@ export function prepareDirectWorktrees(
   options: WorkflowDirectOptions,
   runId: string,
   scope: string,
+  workflowInvocationCwd: string = process.cwd(),
 ): PreparedDirectWorktrees {
   if (!hasDirectWorktreeIsolation(tasks, options)) {
     return {
@@ -289,9 +312,9 @@ export function prepareDirectWorktrees(
     throw new Error("atomic-workflows: worktree and gitWorktreeDir are mutually exclusive; use gitWorktreeDir for a reusable worktree or worktree:true for temporary isolated worktrees.");
   }
 
-  const sharedCwd = resolveSharedDirectWorktreeCwd(tasks);
+  const sharedCwd = resolveSharedDirectWorktreeCwd(tasks, workflowInvocationCwd);
   const conflict = findWorktreeTaskCwdConflict(
-    tasks.map((task) => ({ agent: task.name, cwd: normalizeDirectTaskCwd(task.cwd) })),
+    tasks.map((task) => ({ agent: task.name, cwd: normalizeDirectTaskCwd(task.cwd, workflowInvocationCwd) })),
     sharedCwd,
   );
   if (conflict !== undefined) throw new Error(formatWorktreeTaskCwdConflict(conflict, sharedCwd));
@@ -306,6 +329,10 @@ export function prepareDirectWorktrees(
     setup,
     agents,
     diffsDir: directWorktreeDiffsDir(options, setup, runId, scope),
+    outputIsolations: tasks.map((_, index) => ({
+      baseDir: directWorktreeOutputsDir(runId, scope, index),
+      trustedRoot: directWorktreeOutputsRoot(),
+    })),
   };
 }
 
@@ -343,31 +370,11 @@ export function isRunOpts(value: WorkflowDirectOptions | RunOpts | undefined): v
     "adapters" in value || "ui" in value || "store" in value || "persistence" in value ||
     "mcp" in value || "cancellation" in value || "overlay" in value || "signal" in value ||
     "config" in value || "depth" in value || "stageControlRegistry" in value || "runId" in value ||
-    "onRunStart" in value || "onStageStart" in value || "onStageEnd" in value || "onRunEnd" in value ||
-    "models" in value
+    "gitWorktreeSetupCache" in value || "onRunStart" in value || "onStageStart" in value ||
+    "onStageEnd" in value || "onRunEnd" in value || "models" in value
   );
 }
 
-export async function writeDirectOutput(
-  item: { readonly chainDir?: string; readonly cwd?: string; readonly output?: string | false; readonly outputMode?: WorkflowOutputMode },
-  result: WorkflowTaskResult,
-): Promise<{ result: WorkflowTaskResult; artifact?: WorkflowArtifact }> {
-  if (typeof item.output !== "string") return { result };
-
-  const outputPath = resolveWorkflowPath(item.output, taskBaseDir(item));
-  await mkdir(dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, result.text, "utf8");
-
-  const visibleResult = item.outputMode === "file-only" ? { ...result, text: "" } : result;
-  return {
-    result: visibleResult,
-    artifact: {
-      kind: "output",
-      path: outputPath,
-      taskName: result.name,
-    },
-  };
-}
 
 function directFailureMessage(error: unknown): string {
   return classifyWorkflowFailure(error).userMessage;

package/dist/builtin/workflows/src/runs/foreground/executor-direct-output.ts

@@ -0,0 +1,91 @@
+import { lstat, mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative } from "node:path";
+import type {
+  WorkflowArtifact,
+  WorkflowDirectTaskItem,
+  WorkflowTaskResult,
+} from "../../shared/types.js";
+import { setupGitWorktreeCached, type GitWorktreeSetupCache } from "../shared/worktree.js";
+import { resolveContainedRelativePath, resolveWorktreeStageCwd } from "../shared/worktree-cwd.js";
+import type { DirectOutputIsolation } from "./executor-direct-helpers.js";
+import { resolveWorkflowPath, taskBaseDir } from "./executor-task-prompts.js";
+
+function nonBlankChainDir(chainDir: string | undefined): string | undefined {
+  return typeof chainDir === "string" && chainDir.trim().length > 0 ? chainDir : undefined;
+}
+async function ensureTrustedArtifactRoot(root: string): Promise<void> {
+  await mkdir(root, { recursive: true });
+  const entry = await lstat(root);
+  if (entry.isSymbolicLink() || !entry.isDirectory()) {
+    throw new Error(
+      `atomic-workflows: runner artifact root ${root} must be a real directory, not a symlink or junction.`,
+    );
+  }
+}
+
+export async function writeDirectOutput(
+  item: Pick<WorkflowDirectTaskItem, "cwd" | "output" | "outputMode" | "gitWorktreeDir" | "baseBranch"> & { readonly chainDir?: string },
+  result: WorkflowTaskResult,
+  workflowInvocationCwd: string = process.cwd(),
+  outputIsolation?: DirectOutputIsolation,
+  gitWorktreeSetupCache?: GitWorktreeSetupCache,
+): Promise<{ result: WorkflowTaskResult; artifact?: WorkflowArtifact }> {
+  if (typeof item.output !== "string") return { result };
+
+  const explicitChainDir = nonBlankChainDir(item.chainDir);
+  let outputPath: string;
+  let trustedArtifactRoot: string | undefined;
+  let containment: { readonly root: string; readonly baseDir: string; readonly description: string } | undefined;
+  if (isAbsolute(item.output)) {
+    outputPath = item.output;
+  } else if (explicitChainDir !== undefined) {
+    outputPath = resolveWorkflowPath(item.output, resolveWorkflowPath(explicitChainDir, process.cwd()));
+  } else if (outputIsolation !== undefined) {
+    await ensureTrustedArtifactRoot(outputIsolation.trustedRoot);
+    trustedArtifactRoot = outputIsolation.trustedRoot;
+    const baseRelative = relative(outputIsolation.trustedRoot, outputIsolation.baseDir);
+    const baseDir = resolveContainedRelativePath(
+      outputIsolation.trustedRoot,
+      outputIsolation.trustedRoot,
+      baseRelative,
+      "runner artifact root",
+    );
+    await mkdir(baseDir, { recursive: true });
+    containment = { root: baseDir, baseDir, description: "runner output root" };
+    outputPath = resolveContainedRelativePath(baseDir, baseDir, item.output, containment.description);
+  } else if (typeof item.gitWorktreeDir === "string") {
+    const setup = setupGitWorktreeCached({
+      gitWorktreeDir: item.gitWorktreeDir,
+      baseBranch: item.baseBranch,
+      cwd: workflowInvocationCwd,
+    }, gitWorktreeSetupCache);
+    const baseDir = resolveWorktreeStageCwd(item.cwd, setup) ?? setup.cwd;
+    containment = { root: setup.worktreeRoot, baseDir, description: "gitWorktreeDir" };
+    outputPath = resolveContainedRelativePath(setup.worktreeRoot, baseDir, item.output, containment.description);
+  } else {
+    outputPath = resolveWorkflowPath(item.output, taskBaseDir(item));
+  }
+
+  await mkdir(dirname(outputPath), { recursive: true });
+  if (trustedArtifactRoot !== undefined) await ensureTrustedArtifactRoot(trustedArtifactRoot);
+
+  if (containment !== undefined) {
+    outputPath = resolveContainedRelativePath(
+      containment.root,
+      containment.baseDir,
+      item.output,
+      containment.description,
+    );
+  }
+  await writeFile(outputPath, result.text, "utf8");
+
+  const visibleResult = item.outputMode === "file-only" ? { ...result, text: "" } : result;
+  return {
+    result: visibleResult,
+    artifact: {
+      kind: "output",
+      path: outputPath,
+      taskName: result.name,
+    },
+  };
+}