@bastani/atomic 0.8.4-0 → 0.8.5-0

package/dist/builtin/workflows/src/extension/render-call.ts

@@ -6,7 +6,7 @@
 export interface WorkflowToolArgs {
   workflow?: string;
   inputs?: Record<string, unknown>;
-  action?: "run" | "list" | "get" | "status" | "interrupt" | "resume" | "inputs";
+  action?: "run" | "list" | "get" | "status" | "interrupt" | "kill" | "resume" | "inputs";
   runId?: string;
 }
 
@@ -29,6 +29,8 @@ export function renderCall(args: WorkflowToolArgs): string {
       return `workflow: run "${name}"`;
     case "interrupt":
       return `workflow: interrupt run "${name}"`;
+    case "kill":
+      return `workflow: kill run "${name}"`;
     case "resume":
       return `workflow: resume run "${name}"`;
     case "get":

package/dist/builtin/workflows/src/extension/render-result.ts

@@ -96,6 +96,7 @@ type RunResult = {
   message?: string;
 };
 type InterruptResult = { action: "interrupt"; runId: string; status: string; message: string };
+type KillResult = { action: "kill"; runId: string; status: string; message: string };
 type ResumeResult = { action: "resume"; runId: string; status: string; message: string };
 
 export type WorkflowToolResult =
@@ -106,6 +107,7 @@ export type WorkflowToolResult =
   | GetResult
   | RunResult
   | InterruptResult
+  | KillResult
   | ResumeResult;
 
 export interface RenderResultOpts {
@@ -200,6 +202,11 @@ export function renderResult(result: WorkflowToolResult, opts?: RenderResultOpts
       return `workflow interrupt ${r.runId}: ${r.message}`;
     }
 
+    case "kill": {
+      const r = result as KillResult;
+      return `workflow kill ${r.runId}: ${r.message}`;
+    }
+
     case "resume": {
       const r = result as ResumeResult;
       return `workflow resume ${r.runId}: ${r.message}`;

package/dist/builtin/workflows/src/extension/runtime.ts

@@ -170,14 +170,15 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       chain: _chain,
       chainName,
       concurrency,
+      failFast,
       async: _async,
       intercom: _intercom,
       output,
       outputMode,
+      reads,
       chainDir,
       maxOutput,
       artifacts,
-      progress,
       worktree,
       ...stageOptions
     } = args;
@@ -187,12 +188,13 @@ export function createExtensionRuntime(opts: ExtensionRuntimeOpts = {}): Extensi
       ...(typeof task === "string" ? { task } : {}),
       ...(typeof chainName === "string" ? { chainName } : {}),
       ...(typeof concurrency === "number" ? { concurrency } : {}),
+      ...(typeof failFast === "boolean" ? { failFast } : {}),
       ...(typeof chainDir === "string" ? { chainDir } : {}),
       ...(output !== undefined ? { output } : {}),
       ...(outputMode !== undefined ? { outputMode } : {}),
+      ...(reads !== undefined ? { reads } : {}),
       ...(maxOutput !== undefined ? { maxOutput } : {}),
       ...(typeof artifacts === "boolean" ? { artifacts } : {}),
-      ...(typeof progress === "boolean" ? { progress } : {}),
       ...(typeof worktree === "boolean" ? { worktree } : {}),
     };
   }

package/dist/builtin/workflows/src/extension/wiring.ts

@@ -87,11 +87,14 @@ function isTestContext(): boolean {
  * cross-ref: node_modules/@bastani/atomic/docs/sdk.md
  *            node_modules/@bastani/atomic/dist/core/sdk.d.ts
  */
-interface PiSdkSettingsManager {}
-interface PiSdkResourceLoader {
+export interface PiSdkSettingsManager {}
+export interface PiSdkResourceLoader {
   reload(): Promise<void>;
 }
-interface PiCodingAgentSdk {
+interface PiSdkSessionManager {
+  getCwd(): string;
+}
+export interface PiCodingAgentSdk {
   getAgentDir(): string;
   SettingsManager: {
     create(cwd?: string, agentDir?: string): PiSdkSettingsManager;
@@ -103,19 +106,40 @@ interface PiCodingAgentSdk {
   }) => PiSdkResourceLoader;
   createAgentSession(options?: AtomicCreateAgentSessionOptions): Promise<{ session: StageSessionRuntime }>;
 }
-type AtomicCreateAgentSessionOptions = Omit<CreateAgentSessionOptions, "settingsManager" | "resourceLoader"> & {
+type AtomicCreateAgentSessionOptions = Omit<CreateAgentSessionOptions, "settingsManager" | "resourceLoader" | "sessionManager"> & {
   settingsManager?: PiSdkSettingsManager;
   resourceLoader?: PiSdkResourceLoader;
+  sessionManager?: PiSdkSessionManager;
 };
 
-async function withDefaultStageResourceLoader(
+function resolveSessionCwd(options: AtomicCreateAgentSessionOptions | undefined): string {
+  return options?.cwd ?? options?.sessionManager?.getCwd() ?? process.cwd();
+}
+
+/**
+ * Prepare Atomic SDK stage-session options with Atomic-first resource loading.
+ *
+ * The Atomic SDK's documented defaults are intentionally significant:
+ * omitted `agentDir` means credentials/models/settings can be read from the
+ * primary `~/.atomic/agent` paths first while still considering legacy
+ * `~/.pi/agent` compatibility paths when the SDK supports multiple config
+ * directories. Passing the computed default back as an explicit `agentDir`
+ * would accidentally turn that multi-dir behavior into a single-dir override.
+ *
+ * A user-supplied `agentDir` is still preserved exactly and remains an
+ * explicit override. A user-supplied `resourceLoader` is also preserved; in
+ * that case cwd/agentDir no longer control resource discovery and only affect
+ * session naming/tool path resolution, matching the pi SDK docs.
+ */
+export async function prepareAtomicStageSessionOptions(
   options: CreateAgentSessionOptions | undefined,
   sdk: PiCodingAgentSdk,
 ): Promise<AtomicCreateAgentSessionOptions | undefined> {
   const atomicOptions = options as AtomicCreateAgentSessionOptions | undefined;
   if (atomicOptions?.resourceLoader !== undefined) return atomicOptions;
 
-  const cwd = atomicOptions?.cwd ?? process.cwd();
+  const cwd = resolveSessionCwd(atomicOptions);
+  const hasAgentDirOverride = atomicOptions?.agentDir !== undefined;
   const agentDir = atomicOptions?.agentDir ?? sdk.getAgentDir();
   const settingsManager =
     atomicOptions?.settingsManager ?? sdk.SettingsManager.create(cwd, agentDir);
@@ -129,7 +153,7 @@ async function withDefaultStageResourceLoader(
   return {
     ...atomicOptions,
     cwd,
-    agentDir,
+    ...(hasAgentDirOverride ? { agentDir } : {}),
     settingsManager,
     resourceLoader,
   };
@@ -139,7 +163,7 @@ async function createPiSdkAgentSession(
   options?: CreateAgentSessionOptions,
 ): Promise<{ session: StageSessionRuntime }> {
   const sdk = await import("@bastani/atomic") as PiCodingAgentSdk;
-  const sessionOptions = await withDefaultStageResourceLoader(options, sdk);
+  const sessionOptions = await prepareAtomicStageSessionOptions(options, sdk);
   const result = await sdk.createAgentSession(sessionOptions);
   // `CreateAgentSessionResult` is `{ session, extensionsResult, modelFallbackMessage? }`;
   // workflow stages only consume `.session` (structurally an `AgentSession`,

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

@@ -1,4 +1,14 @@
+import type { CreateAgentSessionOptions } from "@bastani/atomic";
 import { Type, type Static } from "typebox";
+import type { WorkflowModelValue } from "../shared/types.js";
+
+type ArrayElement<T> = T extends readonly (infer Element)[] ? Element : never;
+
+const SdkSessionOptionSchema = <Key extends keyof CreateAgentSessionOptions>(_key: Key) =>
+  Type.Unsafe<NonNullable<CreateAgentSessionOptions[Key]>>({});
+
+const SdkSessionOptionArrayElementSchema = <Key extends keyof CreateAgentSessionOptions>(_key: Key) =>
+  Type.Unsafe<ArrayElement<NonNullable<CreateAgentSessionOptions[Key]>>>({});
 
 const IntercomOptionsSchema = Type.Object({
   enabled: Type.Optional(Type.Boolean()),
@@ -30,18 +40,20 @@ const McpOptionsSchema = Type.Object({
 const StageSessionOptionProperties = {
   cwd: Type.Optional(Type.String()),
   agentDir: Type.Optional(Type.String()),
-  authStorage: Type.Optional(Type.Any()),
-  modelRegistry: Type.Optional(Type.Any()),
-  model: Type.Optional(Type.Any()),
-  thinkingLevel: Type.Optional(Type.String()),
-  scopedModels: Type.Optional(Type.Array(Type.Any())),
-  noTools: Type.Optional(Type.Union([Type.Literal("all"), Type.Literal("builtin")])),
+  authStorage: Type.Optional(SdkSessionOptionSchema("authStorage")),
+  modelRegistry: Type.Optional(SdkSessionOptionSchema("modelRegistry")),
+  model: Type.Optional(Type.Unsafe<WorkflowModelValue>({})),
+  thinkingLevel: Type.Optional(SdkSessionOptionSchema("thinkingLevel")),
+  scopedModels: Type.Optional(Type.Array(SdkSessionOptionArrayElementSchema("scopedModels"))),
+  noTools: Type.Optional(Type.Unsafe<NonNullable<CreateAgentSessionOptions["noTools"]>>({
+    enum: ["all", "builtin"],
+  })),
   tools: Type.Optional(Type.Array(Type.String())),
-  customTools: Type.Optional(Type.Array(Type.Any())),
-  resourceLoader: Type.Optional(Type.Any()),
-  sessionManager: Type.Optional(Type.Any()),
-  settingsManager: Type.Optional(Type.Any()),
-  sessionStartEvent: Type.Optional(Type.Any()),
+  customTools: Type.Optional(Type.Array(SdkSessionOptionArrayElementSchema("customTools"))),
+  resourceLoader: Type.Optional(SdkSessionOptionSchema("resourceLoader")),
+  sessionManager: Type.Optional(SdkSessionOptionSchema("sessionManager")),
+  settingsManager: Type.Optional(SdkSessionOptionSchema("settingsManager")),
+  sessionStartEvent: Type.Optional(SdkSessionOptionSchema("sessionStartEvent")),
   fallbackModels: Type.Optional(Type.Array(Type.String())),
   mcp: Type.Optional(McpOptionsSchema),
   sessionDir: Type.Optional(Type.String()),
@@ -53,7 +65,6 @@ const WorkflowTaskOptionProperties = {
   output: Type.Optional(Type.Union([Type.String(), Type.Literal(false)])),
   outputMode: Type.Optional(Type.Union([Type.Literal("inline"), Type.Literal("file-only")])),
   reads: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Literal(false)])),
-  progress: Type.Optional(Type.Boolean()),
   worktree: Type.Optional(Type.Boolean()),
   maxOutput: Type.Optional(MaxOutputSchema),
   artifacts: Type.Optional(Type.Boolean()),
@@ -78,7 +89,7 @@ export const WorkflowParametersSchema = Type.Object({
   workflow: Type.Optional(Type.String({
     description: "Named workflow ID for named-workflow execution.",
   })),
-  inputs: Type.Optional(Type.Record(Type.String(), Type.Any(), {
+  inputs: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
     default: {},
     description: "Key/value inputs passed to a named workflow run.",
   })),
@@ -89,10 +100,20 @@ export const WorkflowParametersSchema = Type.Object({
     Type.Literal("inputs"),
     Type.Literal("status"),
     Type.Literal("interrupt"),
+    Type.Literal("kill"),
     Type.Literal("resume"),
   ])),
   runId: Type.Optional(Type.String({
-    description: "Run identifier for status/interrupt/resume.",
+    description: "Run identifier or unique prefix for status/interrupt/kill/resume. Use '--all' for interrupt/kill all.",
+  })),
+  all: Type.Optional(Type.Boolean({
+    description: "Apply supported run-control actions (interrupt/kill) to all in-flight runs.",
+  })),
+  stageId: Type.Optional(Type.String({
+    description: "Stage id, unique prefix, or stage name for stage-scoped resume.",
+  })),
+  message: Type.Optional(Type.String({
+    description: "Optional message forwarded when resuming paused work.",
   })),
   task: Type.Optional(Type.Union([
     DirectTaskSchema,
@@ -102,6 +123,7 @@ export const WorkflowParametersSchema = Type.Object({
   tasks: Type.Optional(Type.Array(DirectTaskSchema)),
   chain: Type.Optional(Type.Array(Type.Union([DirectTaskSchema, ParallelChainStepSchema]))),
   concurrency: Type.Optional(Type.Number()),
+  failFast: Type.Optional(Type.Boolean()),
   async: Type.Optional(Type.Boolean()),
   intercom: Type.Optional(IntercomOptionsSchema),
   ...StageSessionOptionProperties,

package/dist/builtin/workflows/src/runs/background/runner.ts

@@ -84,8 +84,8 @@ export function buildDetachedAccepted(
  * the store remains source of truth for run status. Cancellation is wired
  * through the provided (or default) CancellationRegistry.
  */
-export function runDetached(
-  def: WorkflowDefinition,
+export function runDetached<TInputs extends Record<string, unknown>>(
+  def: WorkflowDefinition<TInputs>,
   inputs: Record<string, unknown>,
   opts: DetachedRunOpts = {},
 ): DetachedAccepted {

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -34,6 +34,10 @@ export type KillResult =
   | { ok: true; runId: string; previousStatus: RunStatus }
   | { ok: false; runId: string; reason: "not_found" | "already_ended" };
 
+export type DestroyRunResult =
+  | { ok: true; runId: string; previousStatus: RunStatus; wasInFlight: boolean }
+  | { ok: false; runId: string; reason: "not_found" };
+
 export type ResumeResult =
   | { ok: true; runId: string; snapshot: RunSnapshot; resumed: readonly StageSnapshot[] }
   | { ok: false; runId: string; reason: "not_found" };
@@ -50,6 +54,8 @@ export type PauseResult =
       reason: "not_found" | "already_ended" | "no_active_stages" | "stage_not_found";
     };
 
+export type InterruptRunResult = PauseResult;
+
 /**
  * Per-run detail returned by {@link inspectRun}. A read-only view over the
  * store snapshot suitable for the "▎ RUN" detail surface — same data the
@@ -163,6 +169,57 @@ export function killAllRuns(opts?: {
   );
 }
 
+// ---------------------------------------------------------------------------
+// destroyRun
+// ---------------------------------------------------------------------------
+
+/**
+ * Destructively kills a workflow run and removes it from live history/status.
+ *
+ * In-flight runs are aborted and persisted with a terminal `killed` entry so
+ * session restore will not resurrect them. Ended runs are simply removed from
+ * the live store without appending a duplicate terminal event.
+ */
+export function destroyRun(
+  runId: string,
+  opts?: { store?: Store; cancellation?: CancellationRegistry; persistence?: WorkflowPersistencePort },
+): DestroyRunResult {
+  const activeStore = opts?.store ?? defaultStore;
+  const run = activeStore.runs().find((r) => r.id === runId);
+
+  if (!run) {
+    return { ok: false, runId, reason: "not_found" };
+  }
+
+  const previousStatus = run.status;
+  const wasInFlight = run.endedAt === undefined;
+
+  if (wasInFlight) {
+    opts?.cancellation?.abort(runId, "workflow killed");
+    if (opts?.persistence) {
+      appendRunEnd(opts.persistence, { runId, status: "killed", ts: Date.now() });
+    }
+  }
+
+  activeStore.removeRun(runId);
+  return { ok: true, runId, previousStatus, wasInFlight };
+}
+
+/**
+ * Destructively kills and removes all in-flight runs.
+ */
+export function destroyAllRuns(opts?: {
+  store?: Store;
+  cancellation?: CancellationRegistry;
+  persistence?: WorkflowPersistencePort;
+}): DestroyRunResult[] {
+  const activeStore = opts?.store ?? defaultStore;
+  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
+  return inFlight.map((r) =>
+    destroyRun(r.id, { store: activeStore, cancellation: opts?.cancellation, persistence: opts?.persistence }),
+  );
+}
+
 // ---------------------------------------------------------------------------
 // resumeRun
 // ---------------------------------------------------------------------------
@@ -308,6 +365,38 @@ export function pauseRun(
   return { ok: true, runId, paused: pausedSnaps };
 }
 
+// ---------------------------------------------------------------------------
+// interruptRun
+// ---------------------------------------------------------------------------
+
+/**
+ * Interrupt a run in a resumable way by pausing live stage handles when
+ * available. Unlike `destroyRun`, this never aborts the workflow controller and
+ * never removes the run from status/history.
+ */
+export function interruptRun(
+  runId: string,
+  opts?: {
+    store?: Store;
+    stageControlRegistry?: StageControlRegistry;
+    stageId?: string;
+  },
+): InterruptRunResult {
+  return pauseRun(runId, opts);
+}
+
+/** Interrupt all in-flight runs without removing them from history/status. */
+export function interruptAllRuns(opts?: {
+  store?: Store;
+  stageControlRegistry?: StageControlRegistry;
+}): InterruptRunResult[] {
+  const activeStore = opts?.store ?? defaultStore;
+  const inFlight = activeStore.runs().filter((r) => r.endedAt === undefined);
+  return inFlight.map((r) =>
+    interruptRun(r.id, { store: activeStore, stageControlRegistry: opts?.stageControlRegistry }),
+  );
+}
+
 // ---------------------------------------------------------------------------
 // inspectRun
 // ---------------------------------------------------------------------------