@bastani/atomic 0.9.0-alpha.1 → 0.9.0-alpha.2

package/dist/builtin/workflows/builtin/goal-runner.ts

@@ -1,10 +1,11 @@
 import { join } from "node:path";
-import type { WorkflowTaskResult } from "../src/shared/types.js";
+import type { WorkflowParallelOptions, WorkflowTaskOptions, WorkflowTaskResult, WorkflowTaskStep } from "../src/shared/types.js";
 import { reviewDecisionSchema } from "./goal-schemas.js";
 import {
   DEFAULT_BLOCKER_THRESHOLD,
   DEFAULT_MAX_TURNS,
   DEFAULT_REVIEW_QUORUM,
+  type GoalWorkflowInputs,
   type GoalWorkflowOutputs,
   type ReviewRecord,
 } from "./goal-types.js";
@@ -63,22 +64,14 @@ function normalizeBranchInput(
     );
   return looksLikeSafeGitRef ? trimmed : fallback;
 }
-  type GoalRunnerContext = {
-  readonly inputs: {
-    readonly objective: string;
-    readonly max_turns?: number;
-    readonly base_branch?: string;
-  };
-  task(name: string, options: object): Promise<WorkflowTaskResult>;
-  parallel(
-    steps: readonly object[],
-    options: { readonly task: string; readonly failFast: false },
-  ): Promise<WorkflowTaskResult[]>;
+type GoalRunnerContext = {
+  readonly inputs: GoalWorkflowInputs;
+  task(name: string, options: WorkflowTaskOptions): Promise<WorkflowTaskResult>;
+  parallel(steps: readonly WorkflowTaskStep[], options: WorkflowParallelOptions): Promise<WorkflowTaskResult[]>;
 };
 
-export async function runGoalWorkflow(ctx: unknown): Promise<GoalWorkflowOutputs> {
-  const goalContext = ctx as GoalRunnerContext;
-    const inputs = goalContext.inputs;
+export async function runGoalWorkflow(ctx: GoalRunnerContext): Promise<GoalWorkflowOutputs> {
+    const inputs = ctx.inputs;
     const objective = inputs.objective.trim();
     if (!objective) {
       throw new Error("goal requires an objective input.");
@@ -169,7 +162,7 @@ export async function runGoalWorkflow(ctx: unknown): Promise<GoalWorkflowOutputs
 
       let worker: WorkflowTaskResult;
       try {
-        worker = await goalContext.task(`work-turn-${turn}`, {
+        worker = await ctx.task(`work-turn-${turn}`, {
           prompt: workerPrompt,
           reads: [ledgerPath, ...latestReviewArtifactPaths],
           output: workTurnPath,
@@ -249,7 +242,7 @@ export async function runGoalWorkflow(ctx: unknown): Promise<GoalWorkflowOutputs
 
       let reviewResults: WorkflowTaskResult[];
       try {
-        reviewResults = await goalContext.parallel(reviewerSteps, {
+        reviewResults = await ctx.parallel(reviewerSteps, {
           task: objective,
           failFast: false,
         });

package/dist/builtin/workflows/builtin/goal.ts

@@ -7,50 +7,45 @@
  */
 
 import { Type } from "typebox";
-import { defineWorkflow } from "../src/workflows/define-workflow.js";
+import { workflow } from "../src/authoring/workflow.js";
 import { runGoalWorkflow } from "./goal-runner.js";
 import { DEFAULT_MAX_TURNS } from "./goal-types.js";
 
-export default defineWorkflow("goal")
-  .description(
-    "Goal Runner workflow with bounded LM turns, ledger artifacts, parallel reviewers, and reducer-gated completion.",
-  )
-  .input("objective", Type.String({ description: "The objective for the Goal Runner workflow." }))
-  .input("max_turns", Type.Number({
-    default: DEFAULT_MAX_TURNS,
-    description: "Maximum worker/review turns before Goal Runner stops as needs_human.",
-  }))
-  .input("base_branch", Type.String({
-    default: "origin/main",
-    description: "Optional branch reviewers compare the current code delta against (default origin/main).",
-  }))
-  .output("result", Type.Optional(Type.String({ description: "Final report with objective, status, receipts, turns, and remaining work." })))
-  .output("status", Type.Optional(Type.Union(
-    [Type.Literal("complete"), Type.Literal("blocked"), Type.Literal("needs_human"), Type.Literal("active")],
-    { description: "Final reducer status: complete, blocked, needs_human, or active if externally interrupted." },
-  )))
-  .output("approved", Type.Optional(Type.Boolean({ description: "Whether the reducer reached complete." })))
-  .output("goal_id", Type.Optional(Type.String({ description: "Per-run goal identifier stored in the ledger." })))
-  .output("objective", Type.Optional(Type.String({ description: "Normalized goal objective used by the run." })))
-  .output("ledger_path", Type.Optional(Type.String({ description: "OS-temp path to goal-ledger.json with receipts, reviewer decisions, blockers, and lifecycle events." })))
-  .output("turns_completed", Type.Optional(Type.Number({ description: "Worker/review turns completed." })))
-  .output("iterations_completed", Type.Optional(Type.Number({ description: "Worker/review turns completed, retained for status summaries." })))
-  .output(
-    "receipts",
-    Type.Optional(
-      Type.Array(
-        Type.Object({
-          turn: Type.Number(),
-          stage: Type.String(),
-          artifact_path: Type.String(),
-          summary: Type.String(),
-        }),
-        { description: "Ledger receipt summaries and worker artifact paths." },
-      ),
-    ),
-  )
-  .output("remaining_work", Type.Optional(Type.String({ description: "Remaining gaps or blockers when incomplete, or none." })))
-  .output("review_report", Type.Optional(Type.String({ description: "Compact report pointing to the latest reviewer decision artifacts used by the reducer." })))
-  .output("review_report_path", Type.Optional(Type.String({ description: "JSON artifact path for the latest reviewer decision round." })))
-  .run(runGoalWorkflow)
-  .compile();
+export default workflow({
+  name: "goal",
+  description: "Goal Runner workflow with bounded LM turns, ledger artifacts, parallel reviewers, and reducer-gated completion.",
+  inputs: {
+    objective: Type.String({ description: "The objective for the Goal Runner workflow." }),
+    max_turns: Type.Number({
+      default: DEFAULT_MAX_TURNS,
+      description: "Maximum worker/review turns before Goal Runner stops as needs_human.",
+    }),
+    base_branch: Type.String({
+      default: "origin/main",
+      description: "Optional branch reviewers compare the current code delta against (default origin/main).",
+    }),
+  },
+  outputs: {
+    result: Type.Optional(Type.String({ description: "Final report with objective, status, receipts, turns, and remaining work." })),
+    status: Type.Optional(Type.Union(
+      [Type.Literal("complete"), Type.Literal("blocked"), Type.Literal("needs_human"), Type.Literal("active")],
+      { description: "Final reducer status: complete, blocked, needs_human, or active if externally interrupted." },
+    )),
+    approved: Type.Optional(Type.Boolean({ description: "Whether the reducer reached complete." })),
+    goal_id: Type.Optional(Type.String({ description: "Per-run goal identifier stored in the ledger." })),
+    objective: Type.Optional(Type.String({ description: "Normalized goal objective used by the run." })),
+    ledger_path: Type.Optional(Type.String({ description: "OS-temp path to goal-ledger.json with receipts, reviewer decisions, blockers, and lifecycle events." })),
+    turns_completed: Type.Optional(Type.Number({ description: "Worker/review turns completed." })),
+    iterations_completed: Type.Optional(Type.Number({ description: "Worker/review turns completed, retained for status summaries." })),
+    receipts: Type.Optional(Type.Array(Type.Object({
+      turn: Type.Number(),
+      stage: Type.String(),
+      artifact_path: Type.String(),
+      summary: Type.String(),
+    }), { description: "Ledger receipt summaries and worker artifact paths." })),
+    remaining_work: Type.Optional(Type.String({ description: "Remaining gaps or blockers when incomplete, or none." })),
+    review_report: Type.Optional(Type.String({ description: "Compact report pointing to the latest reviewer decision artifacts used by the reducer." })),
+    review_report_path: Type.Optional(Type.String({ description: "JSON artifact path for the latest reviewer decision round." })),
+  },
+  run: async (ctx) => await runGoalWorkflow(ctx),
+});

package/dist/builtin/workflows/builtin/index.d.ts

@@ -127,6 +127,7 @@ export type OpenClaudeDesignWorkflowOutputs = WorkflowOutputValues & {
   readonly preview_file_url?: string;
   readonly spec_path?: string;
   readonly spec_file_url?: string;
+  readonly playwright_cli_status?: string;
 };
 export type OpenClaudeDesignWorkflowDefinition = WorkflowDefinition<
   OpenClaudeDesignWorkflowInputs,

package/dist/builtin/workflows/builtin/open-claude-design-runner.ts

@@ -1,4 +1,4 @@
-import type { WorkflowTaskResult, WorkflowTaskStep } from "../src/shared/types.js";
+import type { WorkflowParallelOptions, WorkflowTaskOptions, WorkflowTaskResult, WorkflowTaskStep } from "../src/shared/types.js";
 import {
   ANTI_SLOP_RULES,
   DEFAULT_MAX_REFINEMENTS,
@@ -18,24 +18,22 @@ import {
 } from "./open-claude-design-utils.js";
 import { exportOpenClaudeDesign, refineOpenClaudeDesign } from "./open-claude-design-phases.js";
 
+type OpenClaudeDesignOutputs = {
+  readonly output_type?: string; readonly design_system?: string; readonly artifact?: string; readonly handoff?: string;
+  readonly approved_for_export?: boolean; readonly refinements_completed?: number; readonly import_context?: string; readonly run_id?: string;
+  readonly artifact_dir?: string; readonly preview_path?: string; readonly preview_file_url?: string; readonly spec_path?: string; readonly spec_file_url?: string;
+  readonly playwright_cli_status?: string;
+};
+
 type OpenClaudeDesignContext = {
-  readonly cwd: string;
-  readonly inputs: {
-    readonly prompt: string;
-    readonly reference?: string;
-    readonly output_type?: string;
-    readonly design_system?: string;
-    readonly max_refinements?: number;
-  };
-  task(name: string, options: object): Promise<WorkflowTaskResult>;
-  parallel(
-    steps: readonly WorkflowTaskStep[],
-    options: { readonly task: string },
-  ): Promise<WorkflowTaskResult[]>;
+  readonly cwd?: string;
+  readonly inputs: { readonly prompt: string; readonly reference?: string; readonly output_type?: string; readonly design_system?: string; readonly max_refinements?: number };
+  task(name: string, options: WorkflowTaskOptions): Promise<WorkflowTaskResult>;
+  parallel(steps: readonly WorkflowTaskStep[], options: WorkflowParallelOptions): Promise<WorkflowTaskResult[]>;
 };
 
-export async function runOpenClaudeDesignWorkflow(ctx: unknown): Promise<object> {
-  const designContext = ctx as OpenClaudeDesignContext;
+export async function runOpenClaudeDesignWorkflow(ctx: OpenClaudeDesignContext): Promise<OpenClaudeDesignOutputs> {
+  const designContext = ctx;
 
     // Initial deterministic setup step (no LLM): ensure the playwright-cli skill's
     // `playwright-cli` command is installed before any design stage runs. Best-effort —
@@ -55,8 +53,9 @@ export async function runOpenClaudeDesignWorkflow(ctx: unknown): Promise<object>
       DEFAULT_MAX_REFINEMENTS,
     );
 
+    const workflowCwd = designContext.cwd ?? process.cwd();
     const { runId, artifactDir, previewPath, specPath } = prepareArtifactDir(
-      designContext.cwd,
+      workflowCwd,
     );
     const previewFileUrl = `file://${previewPath}`;
     const specFileUrl = `file://${specPath}`;

package/dist/builtin/workflows/builtin/open-claude-design.d.ts

@@ -32,6 +32,7 @@ export type OpenClaudeDesignWorkflowOutputs = WorkflowOutputValues & {
   readonly preview_file_url?: string;
   readonly spec_path?: string;
   readonly spec_file_url?: string;
+  readonly playwright_cli_status?: string;
 };
 
 export type OpenClaudeDesignWorkflowDefinition = WorkflowDefinition<

package/dist/builtin/workflows/builtin/open-claude-design.ts

@@ -18,21 +18,10 @@
  *   pre-export     → impeccable `audit`
  *   forced-fix     → impeccable `harden`
  *   exporter       → impeccable `document` (rich HTML spec)
- *
- * The refinement loop has been re-shaped so that the artifact under review is
- * a real HTML page on disk (`preview.html`). The workflow attempts to open it
- * through the `playwright-cli` skill so the user can interactively review;
- * when browser automation is unavailable, the file path is surfaced so the user
- * can open it manually. Before any stage runs, an initial deterministic setup
- * step ensures the playwright-cli skill's `playwright-cli` command is available
- * (`npx --no-install playwright-cli --version`, then
- * `npm install -g @playwright/cli@latest` when missing); it is best-effort and
- * never blocks the run. The final exporter produces a rich `spec.html` that
- * embeds the agreed-upon design alongside the implementation handoff.
  */
 
-import { defineWorkflow } from "../src/workflows/define-workflow.js";
 import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
 import { runOpenClaudeDesignWorkflow } from "./open-claude-design-runner.js";
 import {
   DEFAULT_MAX_REFINEMENTS,
@@ -40,41 +29,44 @@ import {
   OUTPUT_TYPES,
 } from "./open-claude-design-utils.js";
 
-export default defineWorkflow("open-claude-design")
-  .description(
-    "AI-powered design workflow: design-system onboarding → reference import → HTML generation → impeccable-driven refinement → quality gate → rich HTML handoff. Each stage delegates to a specific impeccable sub-skill; the user can iteratively review the generated HTML through the playwright-cli skill.",
-  )
-  .input("prompt", Type.String({
-    description: "What to design (for example, a dashboard, page, component, or prototype).",
-  }))
-  .input("reference", Type.Optional(Type.String({
-    description: "URL, file path, screenshot path, or design doc to import as a reference.",
-  })))
-  .input("output_type", Type.Union(
-    [...OUTPUT_TYPES].map((value) => Type.Literal(value)),
-    { default: DEFAULT_OUTPUT_TYPE, description: "Kind of design artifact to produce." },
-  ))
-  .input("design_system", Type.Optional(Type.String({
-    description:
-      "Path(s) or description of an existing design system (DESIGN.md, PRODUCT.md, etc.); skips onboarding when provided.",
-  })))
-  .input("max_refinements", Type.Number({
-    default: DEFAULT_MAX_REFINEMENTS,
-    description: `Maximum critique/apply refinement iterations (default ${DEFAULT_MAX_REFINEMENTS}).`,
-  }))
-  .output("output_type", Type.Optional(Type.String({ description: "Kind of design artifact produced." })))
-  .output("design_system", Type.Optional(Type.String({ description: "Design system source used for generation: supplied input or project-derived design system." })))
-  .output("artifact", Type.Optional(Type.String({ description: "Latest final design summary from the approved preview artifact." })))
-  .output("handoff", Type.Optional(Type.String({ description: "Final rich HTML spec and implementation handoff summary." })))
-  .output("approved_for_export", Type.Optional(Type.Boolean({ description: "Whether refinement completed before the final export gate." })))
-  .output("refinements_completed", Type.Optional(Type.Number({ description: "Number of refinement iterations completed." })))
-  .output("import_context", Type.Optional(Type.String({ description: "Reference-import context used during generation." })))
-  .output("run_id", Type.Optional(Type.String({ description: "Per-run design workflow artifact identifier." })))
-  .output("artifact_dir", Type.Optional(Type.String({ description: "Directory containing preview and spec artifacts." })))
-  .output("preview_path", Type.Optional(Type.String({ description: "Absolute path to the generated preview.html file." })))
-  .output("preview_file_url", Type.Optional(Type.String({ description: "file:// URL for the generated preview.html file." })))
-  .output("spec_path", Type.Optional(Type.String({ description: "Absolute path to the generated spec.html file." })))
-  .output("spec_file_url", Type.Optional(Type.String({ description: "file:// URL for the generated spec.html file." })))
-  .output("playwright_cli_status", Type.Optional(Type.String({ description: "Outcome of the initial deterministic step that ensures the playwright-cli skill's `playwright-cli` command is installed." })))
-  .run(runOpenClaudeDesignWorkflow)
-  .compile();
+export default workflow({
+  name: "open-claude-design",
+  description: "AI-powered design workflow: design-system onboarding → reference import → HTML generation → impeccable-driven refinement → quality gate → rich HTML handoff. Each stage delegates to a specific impeccable sub-skill; the user can iteratively review the generated HTML through the playwright-cli skill.",
+  inputs: {
+    prompt: Type.String({
+      description: "What to design (for example, a dashboard, page, component, or prototype).",
+    }),
+    reference: Type.Optional(Type.String({
+      description: "URL, file path, screenshot path, or design doc to import as a reference.",
+    })),
+    output_type: Type.Union(
+      [...OUTPUT_TYPES].map((value) => Type.Literal(value)),
+      { default: DEFAULT_OUTPUT_TYPE, description: "Kind of design artifact to produce." },
+    ),
+    design_system: Type.Optional(Type.String({
+      description:
+        "Path(s) or description of an existing design system (DESIGN.md, PRODUCT.md, etc.); skips onboarding when provided.",
+    })),
+    max_refinements: Type.Number({
+      default: DEFAULT_MAX_REFINEMENTS,
+      description: `Maximum critique/apply refinement iterations (default ${DEFAULT_MAX_REFINEMENTS}).`,
+    }),
+  },
+  outputs: {
+    output_type: Type.Optional(Type.String({ description: "Kind of design artifact produced." })),
+    design_system: Type.Optional(Type.String({ description: "Design system source used for generation: supplied input or project-derived design system." })),
+    artifact: Type.Optional(Type.String({ description: "Latest final design summary from the approved preview artifact." })),
+    handoff: Type.Optional(Type.String({ description: "Final rich HTML spec and implementation handoff summary." })),
+    approved_for_export: Type.Optional(Type.Boolean({ description: "Whether refinement completed before the final export gate." })),
+    refinements_completed: Type.Optional(Type.Number({ description: "Number of refinement iterations completed." })),
+    import_context: Type.Optional(Type.String({ description: "Reference-import context used during generation." })),
+    run_id: Type.Optional(Type.String({ description: "Per-run design workflow artifact identifier." })),
+    artifact_dir: Type.Optional(Type.String({ description: "Directory containing preview and spec artifacts." })),
+    preview_path: Type.Optional(Type.String({ description: "Absolute path to the generated preview.html file." })),
+    preview_file_url: Type.Optional(Type.String({ description: "file:// URL for the generated preview.html file." })),
+    spec_path: Type.Optional(Type.String({ description: "Absolute path to the generated spec.html file." })),
+    spec_file_url: Type.Optional(Type.String({ description: "file:// URL for the generated spec.html file." })),
+    playwright_cli_status: Type.Optional(Type.String({ description: "Outcome of the initial deterministic step that ensures the playwright-cli skill's `playwright-cli` command is installed." })),
+  },
+  run: async (ctx) => await runOpenClaudeDesignWorkflow(ctx),
+});

package/dist/builtin/workflows/builtin/ralph.ts

@@ -1,7 +1,7 @@
 /** Builtin workflow: ralph */
 
-import { defineWorkflow } from "../src/workflows/define-workflow.js";
 import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
 import {
   DEFAULT_MAX_LOOPS,
   normalizeBranchInput,
@@ -9,46 +9,49 @@ import {
 } from "./ralph-core.js";
 import { runRalphWorkflow } from "./ralph-runner.js";
 
-export default defineWorkflow("ralph")
-  .description(
-    "Prompt-engineer → research → orchestrate → multi-model parallel review loop with bounded iteration.",
-  )
-  .input("prompt", Type.String({ description: "The task or goal to research, execute, and refine." }))
-  .input("max_loops", Type.Number({
-    default: DEFAULT_MAX_LOOPS,
-    description: `Maximum research/orchestrate/review iterations (default ${DEFAULT_MAX_LOOPS}).`,
-  }))
-  .input("base_branch", Type.String({
-    default: "origin/main",
-    description: "Branch reviewers compare the current code delta against (default origin/main).",
-  }))
-  .input("git_worktree_dir", Type.String({
-    default: "",
-    description:
-      "Optional Git worktree path. Must start inside a Git repo; absolute paths are used as-is, relative paths resolve from the repo root, existing Git worktrees from the invoking repository are reused/shared as-is, and missing paths are created from base_branch.",
-  }))
-  .input("create_pr", Type.Boolean({
-    default: false,
-    description:
-      "Whether to run the final pull-request creation stage. Defaults to false; prompt text alone does not opt in. Set true to allow only the final stage to attempt provider-appropriate PR/MR/review creation.",
-  }))
-  .worktreeFromInputs({
+export default workflow({
+  name: "ralph",
+  description: "Prompt-engineer → research → orchestrate → multi-model parallel review loop with bounded iteration.",
+  inputs: {
+    prompt: Type.String({ description: "The task or goal to research, execute, and refine." }),
+    max_loops: Type.Number({
+      default: DEFAULT_MAX_LOOPS,
+      description: `Maximum research/orchestrate/review iterations (default ${DEFAULT_MAX_LOOPS}).`,
+    }),
+    base_branch: Type.String({
+      default: "origin/main",
+      description: "Branch reviewers compare the current code delta against (default origin/main).",
+    }),
+    git_worktree_dir: Type.String({
+      default: "",
+      description:
+        "Optional Git worktree path. Must start inside a Git repo; absolute paths are used as-is, relative paths resolve from the repo root, existing Git worktrees from the invoking repository are reused/shared as-is, and missing paths are created from base_branch.",
+    }),
+    create_pr: Type.Boolean({
+      default: false,
+      description:
+        "Whether to run the final pull-request creation stage. Defaults to false; prompt text alone does not opt in. Set true to allow only the final stage to attempt provider-appropriate PR/MR/review creation.",
+    }),
+  },
+  outputs: {
+    result: Type.Optional(Type.String({ description: "Final implementation report from the orchestrator stage." })),
+    plan: Type.Optional(Type.String({ description: "Latest transformed research question." })),
+    plan_path: Type.Optional(Type.String({ description: "Backward-compatible alias for research_path." })),
+    research: Type.Optional(Type.String({ description: "Latest research report text or artifact reference." })),
+    research_path: Type.Optional(Type.String({ description: "Path to the latest generated research artifact under research/." })),
+    implementation_notes_path: Type.Optional(Type.String({ description: "OS-temp notes file containing decisions, deviations, blockers, and validation notes." })),
+    qa_video_path: Type.Optional(Type.String({ description: "Absolute path to the reviewable QA end-to-end proof video recorded with playwright-cli for UI-applicable changes, when one was produced." })),
+    pr_report: Type.Optional(Type.String({ description: "Pull-request report emitted only when create_pr=true and the final pull-request stage runs." })),
+    approved: Type.Optional(Type.Boolean({ description: "Whether the reviewer loop approved before completion or optional final handoff." })),
+    iterations_completed: Type.Optional(Type.Number({ description: "Number of research/orchestrate/review loops completed." })),
+    review_report: Type.Optional(Type.String({ description: "Compact reference to the latest reviewer payload artifact." })),
+    review_report_path: Type.Optional(Type.String({ description: "JSON artifact path for the latest review round." })),
+  },
+  worktreeFromInputs: {
     gitWorktreeDir: "git_worktree_dir",
     baseBranch: "base_branch",
-  })
-  .output("result", Type.Optional(Type.String({ description: "Final implementation report from the orchestrator stage." })))
-  .output("plan", Type.Optional(Type.String({ description: "Latest transformed research question." })))
-  .output("plan_path", Type.Optional(Type.String({ description: "Backward-compatible alias for research_path." })))
-  .output("research", Type.Optional(Type.String({ description: "Latest research report text or artifact reference." })))
-  .output("research_path", Type.Optional(Type.String({ description: "Path to the latest generated research artifact under research/." })))
-  .output("implementation_notes_path", Type.Optional(Type.String({ description: "OS-temp notes file containing decisions, deviations, blockers, and validation notes." })))
-  .output("qa_video_path", Type.Optional(Type.String({ description: "Absolute path to the reviewable QA end-to-end proof video recorded with playwright-cli for UI-applicable changes, when one was produced." })))
-  .output("pr_report", Type.Optional(Type.String({ description: "Pull-request report emitted only when create_pr=true and the final pull-request stage runs." })))
-  .output("approved", Type.Optional(Type.Boolean({ description: "Whether the reviewer loop approved before completion or optional final handoff." })))
-  .output("iterations_completed", Type.Optional(Type.Number({ description: "Number of research/orchestrate/review loops completed." })))
-  .output("review_report", Type.Optional(Type.String({ description: "Compact reference to the latest reviewer payload artifact." })))
-  .output("review_report_path", Type.Optional(Type.String({ description: "JSON artifact path for the latest review round." })))
-  .run(async (ctx) => {
+  },
+  run: async (ctx) => {
     const workflowCtx = ctx;
     const workflowStartCwd = workflowCtx.cwd ?? process.cwd();
     const inputs = workflowCtx.inputs;
@@ -66,5 +69,5 @@ export default defineWorkflow("ralph")
       workflowStartCwd,
       createPr,
     });
-  })
-  .compile();
+  },
+});

package/dist/builtin/workflows/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/workflows",
-  "version": "0.9.0-alpha.1",
+  "version": "0.9.0-alpha.2",
   "private": true,
   "description": "Atomic extension for multi-stage workflow authoring and execution.",
   "contributors": [
@@ -83,7 +83,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.79.7"
+    "@earendil-works/pi-tui": "^0.79.9"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/src/authoring/typebox-defaults.d.ts

@@ -0,0 +1,41 @@
+import type * as TypeBox from "typebox";
+import type { TAny, TArray, TArrayOptions, TBoolean, TEnum, TEnumValue, TInteger, TIntersect, TIntersectOptions, TLiteral, TLiteralValue, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOmit, TPartial, TPick, TProperties, TRequired, TSchema, TSchemaOptions, TString, TStringOptions, TTuple, TTupleOptions, TTypeScriptEnumLike, TTypeScriptEnumToEnumValues, TUnion, TUnknown } from "typebox";
+import type { WorkflowSerializableValue } from "../shared/authoring-contract.js";
+type TypeBoxDefaultOptions<TOptions> = TOptions & {
+    readonly default: WorkflowSerializableValue;
+};
+type TypeBoxDefaulted<TOptions extends {
+    readonly default: WorkflowSerializableValue;
+}> = {
+    readonly default: TOptions["default"];
+};
+type TypeBoxKeysToLiterals<TKeys extends readonly PropertyKey[], TResult extends TLiteral[] = []> = TKeys extends readonly [infer TLeft extends PropertyKey, ...infer TRight extends PropertyKey[]] ? TLeft extends TLiteralValue ? TypeBoxKeysToLiterals<TRight, [...TResult, TLiteral<TLeft>]> : TypeBoxKeysToLiterals<TRight, TResult> : TResult;
+type TypeBoxKeysToIndexer<TKeys extends readonly PropertyKey[]> = TUnion<TypeBoxKeysToLiterals<TKeys>>;
+type TypeBoxRecord<TKey extends TSchema, TValue extends TSchema> = ReturnType<typeof TypeBox.Type.Record<TKey, TValue>>;
+declare module "typebox" {
+    namespace Type {
+        function Any<const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(options: TOptions): TAny & TypeBoxDefaulted<TOptions>;
+        function Unknown<const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(options: TOptions): TUnknown & TypeBoxDefaulted<TOptions>;
+        function String<const TOptions extends TypeBoxDefaultOptions<TStringOptions>>(options: TOptions): TString & TypeBoxDefaulted<TOptions>;
+        function Number<const TOptions extends TypeBoxDefaultOptions<TNumberOptions>>(options: TOptions): TNumber & TypeBoxDefaulted<TOptions>;
+        function Integer<const TOptions extends TypeBoxDefaultOptions<TNumberOptions>>(options: TOptions): TInteger & TypeBoxDefaulted<TOptions>;
+        function Boolean<const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(options: TOptions): TBoolean & TypeBoxDefaulted<TOptions>;
+        function Literal<const TValue extends TLiteralValue, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(value: TValue, options: TOptions): TLiteral<TValue> & TypeBoxDefaulted<TOptions>;
+        function Enum<const TValues extends TEnumValue[], const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(values: readonly [...TValues], options: TOptions): TEnum<TValues> & TypeBoxDefaulted<TOptions>;
+        function Enum<const TEnumLike extends TTypeScriptEnumLike, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(value: TEnumLike, options: TOptions): TEnum<TTypeScriptEnumToEnumValues<TEnumLike>> & TypeBoxDefaulted<TOptions>;
+        function Array<const TItem extends TSchema, const TOptions extends TypeBoxDefaultOptions<TArrayOptions>>(items: TItem, options: TOptions): TArray<TItem> & TypeBoxDefaulted<TOptions>;
+        function Object<const TSchemaProperties extends TProperties, const TOptions extends TypeBoxDefaultOptions<TObjectOptions>>(properties: TSchemaProperties, options: TOptions): TObject<TSchemaProperties> & TypeBoxDefaulted<TOptions>;
+        function Partial<const TType extends TSchema, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, options: TOptions): TPartial<TType> & TypeBoxDefaulted<TOptions>;
+        function Pick<const TType extends TSchema, const TIndexer extends PropertyKey[], const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, indexer: readonly [...TIndexer], options: TOptions): TPick<TType, TypeBoxKeysToIndexer<TIndexer>> & TypeBoxDefaulted<TOptions>;
+        function Pick<const TType extends TSchema, const TIndexer extends TSchema, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, indexer: TIndexer, options: TOptions): TPick<TType, TIndexer> & TypeBoxDefaulted<TOptions>;
+        function Omit<const TType extends TSchema, const TIndexer extends PropertyKey[], const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, indexer: readonly [...TIndexer], options: TOptions): TOmit<TType, TypeBoxKeysToIndexer<TIndexer>> & TypeBoxDefaulted<TOptions>;
+        function Omit<const TType extends TSchema, const TIndexer extends TSchema, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, indexer: TIndexer, options: TOptions): TOmit<TType, TIndexer> & TypeBoxDefaulted<TOptions>;
+        function Required<const TType extends TSchema, const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(type: TType, options: TOptions): TRequired<TType> & TypeBoxDefaulted<TOptions>;
+        function Union<const TTypes extends TSchema[], const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(anyOf: [...TTypes], options: TOptions): TUnion<TTypes> & TypeBoxDefaulted<TOptions>;
+        function Intersect<const TTypes extends TSchema[], const TOptions extends TypeBoxDefaultOptions<TIntersectOptions>>(types: [...TTypes], options: TOptions): TIntersect<TTypes> & TypeBoxDefaulted<TOptions>;
+        function Record<const TKey extends TSchema, const TValue extends TSchema, const TOptions extends TypeBoxDefaultOptions<TObjectOptions>>(key: TKey, value: TValue, options: TOptions): TypeBoxRecord<TKey, TValue> & TypeBoxDefaulted<TOptions>;
+        function Tuple<const TTypes extends TSchema[], const TOptions extends TypeBoxDefaultOptions<TTupleOptions>>(types: [...TTypes], options: TOptions): TTuple<TTypes> & TypeBoxDefaulted<TOptions>;
+        function Null<const TOptions extends TypeBoxDefaultOptions<TSchemaOptions>>(options: TOptions): TNull & TypeBoxDefaulted<TOptions>;
+    }
+}
+export {};