@bastani/atomic 0.9.11-alpha.7 → 0.9.11-alpha.9

package/dist/builtin/workflows/src/extension/workflow-module-loader.ts

@@ -8,8 +8,6 @@
 
 import { createJiti } from "jiti/static";
 import * as typeboxModule from "typebox";
-import * as workflowsSdkSurface from "../sdk-surface.js";
-import { isBrandedWorkflowDefinition } from "../authoring/workflow.js";
 import adversarialVerification from "../../builtin/adversarial-verification.js";
 import classifyAndAct from "../../builtin/classify-and-act.js";
 import fanOutAndSynthesize from "../../builtin/fan-out-and-synthesize.js";
@@ -19,139 +17,141 @@ import loopUntilDone from "../../builtin/loop-until-done.js";
 import openClaudeDesign from "../../builtin/open-claude-design.js";
 import ralph from "../../builtin/ralph.js";
 import tournament from "../../builtin/tournament.js";
+import { isBrandedWorkflowDefinition } from "../authoring/workflow.js";
+import * as workflowsSdkSurface from "../sdk-surface.js";
 
 const WORKFLOWS_MODULE_SPECIFIER = "@bastani/workflows";
 const WORKFLOWS_BUILTIN_MODULE_SPECIFIER = `${WORKFLOWS_MODULE_SPECIFIER}/builtin`;
 const TYPEBOX_MODULE_SPECIFIER = "typebox";
 // Keep this in sync with index.ts through sdk-surface.ts.
 const WORKFLOWS_SDK_MODULE: Record<string, unknown> = {
-  ...workflowsSdkSurface,
+	...workflowsSdkSurface,
 };
 const WORKFLOWS_BUILTIN_MODULE: Record<string, unknown> = {
-  adversarialVerification,
-  classifyAndAct,
-  fanOutAndSynthesize,
-  generateAndFilter,
-  goal,
-  loopUntilDone,
-  openClaudeDesign,
-  ralph,
-  tournament,
+	adversarialVerification,
+	classifyAndAct,
+	fanOutAndSynthesize,
+	generateAndFilter,
+	goal,
+	loopUntilDone,
+	openClaudeDesign,
+	ralph,
+	tournament,
 };
 const TYPEBOX_MODULE: Record<string, unknown> = {
-  ...typeboxModule,
+	...typeboxModule,
 };
 const WORKFLOWS_VIRTUAL_MODULES: Record<string, unknown> = {
-  [WORKFLOWS_MODULE_SPECIFIER]: WORKFLOWS_SDK_MODULE,
-  [WORKFLOWS_BUILTIN_MODULE_SPECIFIER]: WORKFLOWS_BUILTIN_MODULE,
-  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE,
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/adversarial-verification`]: { default: adversarialVerification },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/classify-and-act`]: { default: classifyAndAct },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/fan-out-and-synthesize`]: { default: fanOutAndSynthesize },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/generate-and-filter`]: { default: generateAndFilter },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/goal`]: { default: goal },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/loop-until-done`]: { default: loopUntilDone },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/open-claude-design`]: { default: openClaudeDesign },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/ralph`]: { default: ralph },
-  [`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/tournament`]: { default: tournament },
+	[WORKFLOWS_MODULE_SPECIFIER]: WORKFLOWS_SDK_MODULE,
+	[WORKFLOWS_BUILTIN_MODULE_SPECIFIER]: WORKFLOWS_BUILTIN_MODULE,
+	[TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE,
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/adversarial-verification`]: { default: adversarialVerification },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/classify-and-act`]: { default: classifyAndAct },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/fan-out-and-synthesize`]: { default: fanOutAndSynthesize },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/generate-and-filter`]: { default: generateAndFilter },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/goal`]: { default: goal },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/loop-until-done`]: { default: loopUntilDone },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/open-claude-design`]: { default: openClaudeDesign },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/ralph`]: { default: ralph },
+	[`${WORKFLOWS_BUILTIN_MODULE_SPECIFIER}/tournament`]: { default: tournament },
 };
 
 const workflowModuleLoader = createJiti(import.meta.url, {
-  moduleCache: false,
-  // Keep workflow-file import semantics deterministic: jiti owns .ts/.js/.mjs/.cjs
-  // resolution instead of handing some imports back to native import().
-  tryNative: false,
-  // Resolve the @bastani/workflows SDK (and its builtin submodules) to in-memory
-  // surfaces in every runtime. This mirrors the compiled bun binary path and
-  // keeps discovery fast: aliasing the SDK to its on-disk package re-evaluated
-  // the entire SDK module graph once per workflow file (moduleCache stays false),
-  // which scaled discovery to multiple seconds on projects with many workflow
-  // files. Workflow files themselves are still evaluated fresh from disk, so
-  // `/workflow reload` continues to observe edits.
-  virtualModules: WORKFLOWS_VIRTUAL_MODULES,
+	moduleCache: false,
+	// Keep workflow-file import semantics deterministic: jiti owns .ts/.js/.mjs/.cjs
+	// resolution instead of handing some imports back to native import().
+	tryNative: false,
+	// Resolve the @bastani/workflows SDK (and its builtin submodules) to in-memory
+	// surfaces in every runtime. This mirrors the compiled bun binary path and
+	// keeps discovery fast: aliasing the SDK to its on-disk package re-evaluated
+	// the entire SDK module graph once per workflow file (moduleCache stays false),
+	// which scaled discovery to multiple seconds on projects with many workflow
+	// files. Workflow files themselves are still evaluated fresh from disk, so
+	// `/workflow reload` continues to observe edits.
+	virtualModules: WORKFLOWS_VIRTUAL_MODULES,
 });
 
 function materializeModuleObject(mod: object): Record<string, unknown> {
-  const materialized: Record<string, unknown> = {};
-
-  // jiti's callable API can return an interop namespace proxy. Its own property
-  // descriptors contain the authored export values, but property access may apply
-  // default-export conveniences (and even expose a throwing inherited `then`
-  // getter for `export default null`). Copy own descriptors into a plain object
-  // so candidate collection sees the exact authored exports.
-  for (const key of Object.getOwnPropertyNames(mod)) {
-    const descriptor = Object.getOwnPropertyDescriptor(mod, key);
-    if (descriptor === undefined) continue;
-
-    const value = "value" in descriptor ? descriptor.value : descriptor.get?.call(mod);
-    Object.defineProperty(materialized, key, {
-      value,
-      enumerable: descriptor.enumerable,
-      configurable: true,
-      writable: true,
-    });
-  }
-
-  return materialized;
+	const materialized: Record<string, unknown> = {};
+
+	// jiti's callable API can return an interop namespace proxy. Its own property
+	// descriptors contain the authored export values, but property access may apply
+	// default-export conveniences (and even expose a throwing inherited `then`
+	// getter for `export default null`). Copy own descriptors into a plain object
+	// so candidate collection sees the exact authored exports.
+	for (const key of Object.getOwnPropertyNames(mod)) {
+		const descriptor = Object.getOwnPropertyDescriptor(mod, key);
+		if (descriptor === undefined) continue;
+
+		const value = "value" in descriptor ? descriptor.value : descriptor.get?.call(mod);
+		Object.defineProperty(materialized, key, {
+			value,
+			enumerable: descriptor.enumerable,
+			configurable: true,
+			writable: true,
+		});
+	}
+
+	return materialized;
 }
 
 function normalizeWorkflowModule(mod: unknown): Record<string, unknown> {
-  if (mod !== null && typeof mod === "object") {
-    return materializeModuleObject(mod);
-  }
-  // CJS/default interop can return the exported value directly; wrap it so the
-  // candidate collector can handle it the same way as an ESM default export.
-  return { default: mod };
+	if (mod !== null && typeof mod === "object") {
+		return materializeModuleObject(mod);
+	}
+	// CJS/default interop can return the exported value directly; wrap it so the
+	// candidate collector can handle it the same way as an ESM default export.
+	return { default: mod };
 }
 
 export interface WorkflowModuleCandidate {
-  readonly value: unknown;
-  readonly exportKey: string;
+	readonly value: unknown;
+	readonly exportKey: string;
 }
 
 export function validateWorkflowDefinitionShape(value: unknown): string | null {
-  if (value === null || typeof value !== "object") {
-    return "export is not an object";
-  }
-  const d = value as Record<string, unknown>;
-
-  if (d["__piWorkflow"] !== true) {
-    return "missing or incorrect __piWorkflow sentinel (expected true); export a workflow from workflow({...})";
-  }
-  if (!isBrandedWorkflowDefinition(value)) {
-    return "workflow definition is not produced by workflow({...}); hand-rolled __piWorkflow objects are not supported";
-  }
-  if (typeof d["name"] !== "string" || (d["name"] as string).trim().length === 0) {
-    return "name must be a non-empty string";
-  }
-  if (typeof d["normalizedName"] !== "string" || (d["normalizedName"] as string).trim().length === 0) {
-    return "normalizedName must be a non-empty string";
-  }
-  if (typeof d["run"] !== "function") {
-    return "run must be a function";
-  }
-  return null;
+	if (value === null || typeof value !== "object") {
+		return "export is not an object";
+	}
+	const d = value as Record<string, unknown>;
+
+	if (d.__piWorkflow !== true) {
+		return "missing or incorrect __piWorkflow sentinel (expected true); export a workflow from workflow({...})";
+	}
+	if (!isBrandedWorkflowDefinition(value)) {
+		return "workflow definition is not produced by workflow({...}); hand-rolled __piWorkflow objects are not supported";
+	}
+	if (typeof d.name !== "string" || (d.name as string).trim().length === 0) {
+		return "name must be a non-empty string";
+	}
+	if (typeof d.normalizedName !== "string" || (d.normalizedName as string).trim().length === 0) {
+		return "normalizedName must be a non-empty string";
+	}
+	if (typeof d.run !== "function") {
+		return "run must be a function";
+	}
+	return null;
 }
 
 export function loadWorkflowModule(filePath: string): Record<string, unknown> {
-  return normalizeWorkflowModule(workflowModuleLoader(filePath));
+	return normalizeWorkflowModule(workflowModuleLoader(filePath));
 }
 
 export function collectWorkflowModuleCandidates(mod: Record<string, unknown>): WorkflowModuleCandidate[] {
-  const candidates: WorkflowModuleCandidate[] = [];
-
-  // Default export first (RFC §5.12: check mod.default before named exports)
-  if ("default" in mod && mod["default"] !== undefined) {
-    candidates.push({ value: mod["default"], exportKey: "default" });
-  }
-
-  // Then all named exports (a file may export multiple workflow definitions)
-  for (const [key, val] of Object.entries(mod)) {
-    if (key === "default") continue;
-    if (val !== undefined) {
-      candidates.push({ value: val, exportKey: key });
-    }
-  }
-
-  return candidates;
+	const candidates: WorkflowModuleCandidate[] = [];
+
+	// Default export first (RFC §5.12: check mod.default before named exports)
+	if ("default" in mod && mod.default !== undefined) {
+		candidates.push({ value: mod.default, exportKey: "default" });
+	}
+
+	// Then all named exports (a file may export multiple workflow definitions)
+	for (const [key, val] of Object.entries(mod)) {
+		if (key === "default") continue;
+		if (val !== undefined) {
+			candidates.push({ value: val, exportKey: key });
+		}
+	}
+
+	return candidates;
 }

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

@@ -1,15 +1,13 @@
 import {
-  INTERACTIVE_WORKFLOW_POLICY,
-  NON_INTERACTIVE_WORKFLOW_POLICY,
-  type WorkflowExecutionPolicy,
+	INTERACTIVE_WORKFLOW_POLICY,
+	NON_INTERACTIVE_WORKFLOW_POLICY,
+	type WorkflowExecutionPolicy,
 } from "../shared/types.js";
 
 export const WORKFLOW_NON_INTERACTIVE_MESSAGE =
-  "Workflows are policy-gated in non-interactive (-p) mode; deterministic workflows can run headlessly while runtime human input remains unavailable.";
+	"Workflows are policy-gated in non-interactive (-p) mode; deterministic workflows can run headlessly while runtime human input remains unavailable.";
 
-export function workflowPolicyFromContext(ctx?: {
-  readonly hasUI?: boolean;
-}): WorkflowExecutionPolicy {
-  if (ctx?.hasUI === false) return NON_INTERACTIVE_WORKFLOW_POLICY;
-  return INTERACTIVE_WORKFLOW_POLICY;
+export function workflowPolicyFromContext(ctx?: { readonly hasUI?: boolean }): WorkflowExecutionPolicy {
+	if (ctx?.hasUI === false) return NON_INTERACTIVE_WORKFLOW_POLICY;
+	return INTERACTIVE_WORKFLOW_POLICY;
 }

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

@@ -1,41 +1,37 @@
 import type { WorkflowMcpPort, WorkflowPersistencePort } from "../shared/types.js";
-import { clearMcpScope, setMcpScope, type PiEventBus, type PiMcpExtensionAPI } from "./mcp.js";
+import { clearMcpScope, type PiEventBus, type PiMcpExtensionAPI, setMcpScope } from "./mcp.js";
 import type { ExtensionAPI } from "./public-types.js";
 
-export function makePersistencePort(
-  pi: ExtensionAPI,
-  persistRuns: boolean,
-): WorkflowPersistencePort | undefined {
-  if (!persistRuns) return undefined;
-  if (typeof pi.appendEntry !== "function") return undefined;
-  const port: WorkflowPersistencePort = {
-    appendEntry: (type, payload) => pi.appendEntry!(type, payload),
-  };
-  if (typeof pi.setLabel === "function") {
-    port.setLabel = (entryId, label) => pi.setLabel!(entryId, label);
-  }
-  if (typeof pi.appendCustomMessageEntry === "function") {
-    port.appendCustomMessageEntry = (content, meta) =>
-      pi.appendCustomMessageEntry!(content, meta);
-  }
-  return port;
+export function makePersistencePort(pi: ExtensionAPI, persistRuns: boolean): WorkflowPersistencePort | undefined {
+	if (!persistRuns) return undefined;
+	if (typeof pi.appendEntry !== "function") return undefined;
+	const port: WorkflowPersistencePort = {
+		appendEntry: (type, payload) => pi.appendEntry!(type, payload),
+	};
+	if (typeof pi.setLabel === "function") {
+		port.setLabel = (entryId, label) => pi.setLabel!(entryId, label);
+	}
+	if (typeof pi.appendCustomMessageEntry === "function") {
+		port.appendCustomMessageEntry = (content, meta) => pi.appendCustomMessageEntry!(content, meta);
+	}
+	return port;
 }
 
 export function makeMcpPort(pi: ExtensionAPI): WorkflowMcpPort | undefined {
-  if (typeof pi.events?.emit !== "function") return undefined;
-  const piForMcp: PiMcpExtensionAPI = {
-    events: { emit: pi.events.emit as PiEventBus["emit"] },
-  };
-  return {
-    setScope(stageId: string, allow: string[] | null, deny: string[] | null) {
-      setMcpScope(piForMcp, {
-        stageId,
-        allow: allow ?? undefined,
-        deny: deny ?? undefined,
-      });
-    },
-    clearScope(stageId: string) {
-      clearMcpScope(piForMcp, stageId);
-    },
-  };
+	if (typeof pi.events?.emit !== "function") return undefined;
+	const piForMcp: PiMcpExtensionAPI = {
+		events: { emit: pi.events.emit as PiEventBus["emit"] },
+	};
+	return {
+		setScope(stageId: string, allow: string[] | null, deny: string[] | null) {
+			setMcpScope(piForMcp, {
+				stageId,
+				allow: allow ?? undefined,
+				deny: deny ?? undefined,
+			});
+		},
+		clearScope(stageId: string) {
+			clearMcpScope(piForMcp, stageId);
+		},
+	};
 }

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

@@ -1,17 +1,17 @@
 export const WORKFLOW_TOOL_DESCRIPTION =
-  "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " +
-  "when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; " +
-  "discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " +
-  "send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " +
-  "For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " +
-  "For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " +
-  "quote the exact path without rewriting separators (Windows backslashes are valid), " +
-  "then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " +
-  "Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " +
-  "When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
+	"Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " +
+	"when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; " +
+	"discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " +
+	"send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " +
+	"For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " +
+	"For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " +
+	"quote the exact path without rewriting separators (Windows backslashes are valid), " +
+	"then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " +
+	"Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " +
+	"When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
 
 export const DEFAULT_PROMPT_GUIDANCE: string[] = [
-  `**Workflows**: Treat workflows as the default execution path for any non-trivial task and for any request that has inherent structure plus an objective you can make verifiable. Use the \`workflow\` tool for existing named workflows; when the task needs a graph that is not installed, author a custom TypeScript \`workflow({...})\` inline with normal coding tools, reload workflow resources, and run it.
+	`**Workflows**: Treat workflows as the default execution path for any non-trivial task and for any request that has inherent structure plus an objective you can make verifiable. Use the \`workflow\` tool for existing named workflows; when the task needs a graph that is not installed, author a custom TypeScript \`workflow({...})\` inline with normal coding tools, reload workflow resources, and run it.
   - Workflow fit check: prefer a workflow for implementation, build, debug/diagnosis, bug-fix, migration, new-feature, scoped multi-file, or docs/code changes with validation; and whenever there are multiple steps, dependencies, handoffs, uncertainty, review/validation needs, long-running work, measurable done criteria, or an outcome that needs evidence.
   - Treat loop or stop-condition wording as a strong workflow signal, especially "do X until Y", "repeat until", "iterate until", "review/fix until passing", "run checks and fix until green", "keep going until done", or any prompt that names an approval gate or evidence requirement.
   - Do not force-fit an installed workflow. When another graph better matches the task, write a task-specific TypeScript workflow inline. Rich custom workflows may use deterministic branching, dynamic fan-out, child workflows, artifacts, structured outputs, human-in-the-loop prompts, gates, retries, and explicit stop conditions.
@@ -35,15 +35,16 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - Budget reconnaissance: once workflow fit is clear, keep pre-workflow exploration to a few quick reads that sharpen the objective and validation criteria. Put deep research, upstream/design comparison, and behavior probing inside the workflow. Pass large context through files/artifacts and \`reads\` rather than injecting it into prompts.
   - Course-correct instead of drifting: after roughly ten exploratory tool calls with no artifact, edit, or commit, or repeated "let me verify one more thing" loops, stop, write findings to a context file, and hand the task to the best-fit named or custom workflow. Sunk inline research transfers through files; it is not a reason to stay inline.
   - Only skip workflows for tiny, deterministic, low-risk answers or direct edits where stage tracking clearly costs more than it adds, typically a single-file/no-test/no-review change or a simple answer.`,
-  `**Workflow discovery and lifecycle**:
+	`**Workflow discovery and lifecycle**:
   - For unfamiliar named workflows, discover with \`action: "list"\`, inspect with \`action: "get"\` or \`action: "inputs"\`, and run with \`action: "run"\`, \`workflow\`, and validated \`inputs\`; do not invent workflow names or input keys.
   - In interactive chat, named workflow launches run in the background. Run \`/workflow connect <run>\` to see agents working and chat with and steer each stage. Inspection and control calls (\`status\`, \`stages\`, \`stage\`, \`transcript\`, \`send\`, \`pause\`, \`resume\`, \`interrupt\`, \`quit\`) remain available while work runs.
   - \`workflow send\` is nonterminal-only: once the authoritative root run has completed, failed, skipped, been cancelled or killed, or ended terminal-blocked, start a new workflow if tracked work remains. Proceed inline only when the remaining task is small, deterministic, and low risk. Use explicit \`/workflow attach <run> <stage>\` for user-driven post-mortem chat; it does not resume or modify workflow execution.
   - Natural-language instructions to create or use a worktree do not enable runner isolation. A named workflow must declare and implement any worktree and feature-branch inputs it supports; inspect its inputs and pass a distinct path and branch for each concurrent item. Reusable \`baseBranch\` binding creates a missing target as a detached checkout from that base or reuses an existing same-repository worktree as-is; neither case checks out a separate feature-branch input.
   - Once you have started the selected single run or every run in the selected bounded wave, end the current turn and wait for user input or lifecycle notices. Do not use sleep/status polling loops: key start, finish, and failure events arrive automatically. Use targeted \`status\`/\`stages\`/\`stage\` checks only when the user asks or the next step needs them, and use \`send\`/\`pause\`/\`resume\`/\`interrupt\`/\`quit\` only to answer, steer, or honor control requests.
   - For transcripts, avoid whole-file reads. Get \`sessionFile\`/\`transcriptPath\` from \`stages\` or \`stage\`, preserve the exact path and platform separators, search with \`rg\`/\`grep\`, and read small relevant ranges; use explicit \`tail\` or \`limit\` only for a bounded preview.`,
-  `**Workflow authoring and handoffs**:
+	`**Workflow authoring and handoffs**:
   - When a user asks to create or edit a workflow, clarify only unresolved requirements that materially affect its purpose, inputs, stages, handoffs, validation, success criteria, or starter pattern. Read the workflow docs/examples, implement the TypeScript definition with normal coding tools, reload it, and run representative test inputs before presenting it. Use the create-spec skill when it adds value; it is not mandatory when context is already sufficient.
+  - After creating and reloading a newly authored custom workflow, close the loop by stating the folder containing the workflow file just written, for example \`.atomic/workflows/\`, in this shape: \`Custom workflow created. You can inspect its code at: <workflow-folder-path>\`. Do this only for newly created custom workflows, never builtin or pre-existing workflows.
   - When creating or editing a workflow that pins an explicit stage \`model\` or \`fallbackModels\`, consult \`packages/coding-agent/docs/models/model-selection.md\` for role-based recommendations, then call \`workflow({ action: "models" })\` to see the models actually present in the user's configured catalog. Use only the catalog's returned \`fullId\` values as model strings, and append a thinking suffix only when that exact level appears in the entry's \`availableThinkingLevels\`; treat an absent or empty \`availableThinkingLevels\` as no suffix support rather than inferring one. If a guide-recommended model for the role is unavailable, try another guide-recommended model that is present in the catalog. If no recommendation intersects with the catalog, leave the stage unpinned rather than inventing a substitute, and mention the limitation, asking the user only if the workflow requires an explicit model choice. If the catalog is empty, continue with unpinned stages, state that no configured models were returned, and do not fabricate model IDs. Do not inspect or infer credentials, environment variables, auth files, token validity, entitlements, or the reason a model is absent; \`isCurrent\` marks the active selection, not a quality recommendation.
   - Consult docs/workflows.md and its starter patterns (Classify-and-act, Fan-out-and-synthesize, Adversarial verification, Generate-and-filter, Tournament, and Loop until done) when designing a stage graph.
   - Treat workflow composition as a first-class authoring option. Before duplicating stages, inspect reusable workflow modules and builtin exports; import their definitions and invoke them with \`ctx.workflow(...)\`, mapping typed inputs and consuming only declared outputs. Nested workflows can themselves import children, so combine small reusable graphs into a richer parent while respecting \`maxDepth\`.
@@ -56,4 +57,4 @@ export const DEFAULT_PROMPT_GUIDANCE: string[] = [
   - Pass large stage context through files/artifacts and \`reads\` with an explicit \`Read the file at <path>...\` prompt rather than large \`previous\` payloads or injected session history.
   - Separate implementation/review acceptance from explicitly authorized final actions such as PR/MR/review creation, release tagging, deployment, or publication. Stop implementation loops once acceptance is proven and carry a remaining final action separately.
   - A model stage sees its local prompt, artifacts, tools, and reads, not the graph name or surrounding implementation. State the concrete action, evidence, and success criteria directly.`,
-];
+];

package/dist/builtin/workflows/src/extension/workflow-reload-coordinator.ts

@@ -1,25 +1,25 @@
 import type { WorkflowReloadReport } from "./workflow-reload-report.js";
 
 type ReloadBatch = {
-  readonly discoveryGeneration: number;
-  requestCount: number;
-  readonly promise: Promise<WorkflowReloadReport>;
-  readonly resolve: (report: WorkflowReloadReport) => void;
-  readonly reject: (error: Error) => void;
+	readonly discoveryGeneration: number;
+	requestCount: number;
+	readonly promise: Promise<WorkflowReloadReport>;
+	readonly resolve: (report: WorkflowReloadReport) => void;
+	readonly reject: (error: Error) => void;
 };
 
 export interface WorkflowReloadCoordinator {
-  request(discoveryGeneration: number): Promise<WorkflowReloadReport>;
+	request(discoveryGeneration: number): Promise<WorkflowReloadReport>;
 }
 
 function createBatch(discoveryGeneration: number): ReloadBatch {
-  let resolve: (report: WorkflowReloadReport) => void = () => undefined;
-  let reject: (error: Error) => void = () => undefined;
-  const promise = new Promise<WorkflowReloadReport>((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise;
-    reject = (error) => rejectPromise(error);
-  });
-  return { discoveryGeneration, requestCount: 0, promise, resolve, reject };
+	let resolve: (report: WorkflowReloadReport) => void = () => undefined;
+	let reject: (error: Error) => void = () => undefined;
+	const promise = new Promise<WorkflowReloadReport>((resolvePromise, rejectPromise) => {
+		resolve = resolvePromise;
+		reject = (error) => rejectPromise(error);
+	});
+	return { discoveryGeneration, requestCount: 0, promise, resolve, reject };
 }
 
 /**
@@ -27,40 +27,40 @@ function createBatch(discoveryGeneration: number): ReloadBatch {
  * from the same session generation; generation boundaries remain ordered.
  */
 export function createWorkflowReloadCoordinator(
-  reload: (discoveryGeneration: number, coalescedRequests: number) => Promise<WorkflowReloadReport>,
+	reload: (discoveryGeneration: number, coalescedRequests: number) => Promise<WorkflowReloadReport>,
 ): WorkflowReloadCoordinator {
-  const pending: ReloadBatch[] = [];
-  let draining = false;
+	const pending: ReloadBatch[] = [];
+	let draining = false;
 
-  const drain = async (): Promise<void> => {
-    if (draining) return;
-    draining = true;
-    try {
-      while (pending.length > 0) {
-        const batch = pending.shift()!;
-        try {
-          const report = await reload(batch.discoveryGeneration, batch.requestCount);
-          batch.resolve(report);
-        } catch (error) {
-          batch.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-      }
-    } finally {
-      draining = false;
-      if (pending.length > 0) void drain();
-    }
-  };
+	const drain = async (): Promise<void> => {
+		if (draining) return;
+		draining = true;
+		try {
+			while (pending.length > 0) {
+				const batch = pending.shift()!;
+				try {
+					const report = await reload(batch.discoveryGeneration, batch.requestCount);
+					batch.resolve(report);
+				} catch (error) {
+					batch.reject(error instanceof Error ? error : new Error(String(error)));
+				}
+			}
+		} finally {
+			draining = false;
+			if (pending.length > 0) void drain();
+		}
+	};
 
-  return {
-    request(discoveryGeneration): Promise<WorkflowReloadReport> {
-      let batch = pending.at(-1);
-      if (batch?.discoveryGeneration !== discoveryGeneration) {
-        batch = createBatch(discoveryGeneration);
-        pending.push(batch);
-      }
-      batch.requestCount += 1;
-      queueMicrotask(() => void drain());
-      return batch.promise;
-    },
-  };
+	return {
+		request(discoveryGeneration): Promise<WorkflowReloadReport> {
+			let batch = pending.at(-1);
+			if (batch?.discoveryGeneration !== discoveryGeneration) {
+				batch = createBatch(discoveryGeneration);
+				pending.push(batch);
+			}
+			batch.requestCount += 1;
+			queueMicrotask(() => void drain());
+			return batch.promise;
+		},
+	};
 }

package/dist/builtin/workflows/src/extension/workflow-reload-report.ts

@@ -2,38 +2,41 @@ import type { ConfigDiagnostic } from "./config-loader.js";
 import type { DiscoveryDiagnostic } from "./discovery.js";
 
 export type WorkflowReloadDiagnostic =
-  | (ConfigDiagnostic & { readonly phase: "config" })
-  | (DiscoveryDiagnostic & { readonly phase: "discovery" });
+	| (ConfigDiagnostic & { readonly phase: "config" })
+	| (DiscoveryDiagnostic & { readonly phase: "discovery" });
 
 type WorkflowReloadReportState = {
-  readonly generation: number;
-  readonly workflowCount: number;
-  readonly coalescedRequests: number;
-  readonly diagnostics: WorkflowReloadDiagnostic[];
+	readonly generation: number;
+	readonly workflowCount: number;
+	readonly coalescedRequests: number;
+	readonly diagnostics: WorkflowReloadDiagnostic[];
 };
 
-export type WorkflowReloadReport = WorkflowReloadReportState & (
-  | { readonly outcome: "applied" }
-  | { readonly outcome: "failed"; readonly error: string }
-  | { readonly outcome: "superseded" }
-);
+export type WorkflowReloadReport = WorkflowReloadReportState &
+	(
+		| { readonly outcome: "applied" }
+		| { readonly outcome: "failed"; readonly error: string }
+		| { readonly outcome: "superseded" }
+	);
 
-export function normalizeWorkflowReloadReport(report: WorkflowReloadReport | void): WorkflowReloadReport {
-  return report ?? {
-    outcome: "applied",
-    generation: 0,
-    workflowCount: 0,
-    coalescedRequests: 1,
-    diagnostics: [],
-  };
+export function normalizeWorkflowReloadReport(report: WorkflowReloadReport | undefined): WorkflowReloadReport {
+	return (
+		report ?? {
+			outcome: "applied",
+			generation: 0,
+			workflowCount: 0,
+			coalescedRequests: 1,
+			diagnostics: [],
+		}
+	);
 }
 
 export function workflowReloadDiagnostics(
-  configDiagnostics: readonly ConfigDiagnostic[],
-  discoveryDiagnostics: readonly DiscoveryDiagnostic[],
+	configDiagnostics: readonly ConfigDiagnostic[],
+	discoveryDiagnostics: readonly DiscoveryDiagnostic[],
 ): WorkflowReloadDiagnostic[] {
-  return [
-    ...configDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "config" as const })),
-    ...discoveryDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "discovery" as const })),
-  ];
+	return [
+		...configDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "config" as const })),
+		...discoveryDiagnostics.map((diagnostic) => ({ ...diagnostic, phase: "discovery" as const })),
+	];
 }