@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/chunk-5wgwscd0.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/builtin/workflows/builtin/chunk-6fqs7c01.js

@@ -0,0 +1,155 @@
+import {
+  VERIFICATION_SCALE
+} from "./chunk-cg9tmks0.js";
+
+// dist/builtin/workflows/builtin/progress-scoring.ts
+import { Type } from "typebox";
+var DEFAULT_TREND_WINDOW = 3;
+var DEFAULT_RISE_DELTA = 1.5;
+var DEFAULT_FALL_DELTA = -1.5;
+var DEFAULT_REPEATS = 1;
+var CALIBRATION_RULES = [
+  "Trust observed output, not the agent's narration.",
+  "Effort and step count are NOT progress.",
+  'Agent declarations of success ("done!", "all tests pass") are ZERO evidence.',
+  "Scores may plateau or fall; wrong approaches plateau, and regressions decrease."
+];
+var PROGRESS_SCALE_ORIENTATION = `${VERIFICATION_SCALE.min} = certainly would not satisfy the acceptance criteria … ${VERIFICATION_SCALE.max} = verified satisfaction with observed output`;
+var progressSchema = Type.Object({
+  scores: Type.Array(Type.Object({
+    checkpoint: Type.Integer({ minimum: 1 }),
+    score: VERIFICATION_SCALE.schema
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isProgressStructuredOutput(value) {
+  if (!isRecord(value) || Object.keys(value).length !== 1 || !Object.hasOwn(value, "scores"))
+    return false;
+  return Array.isArray(value.scores);
+}
+function nullScores(checkpointCount) {
+  return Array.from({ length: checkpointCount }, () => null);
+}
+function defaultCheckpoints(stepCount) {
+  const result = [];
+  for (let checkpoint = 2;checkpoint <= stepCount - 1; checkpoint += 1)
+    result.push(checkpoint);
+  return result;
+}
+function validateCheckpoints(checkpoints, stepCount) {
+  for (const checkpoint of checkpoints) {
+    if (!Number.isInteger(checkpoint) || checkpoint < 1 || checkpoint > stepCount) {
+      throw new RangeError(`Progress checkpoint ${checkpoint} is outside the step range 1..${stepCount}.`);
+    }
+  }
+}
+function scoresFromStructured(value, checkpoints) {
+  if (!isProgressStructuredOutput(value))
+    return nullScores(checkpoints.length);
+  const requested = new Set(checkpoints);
+  const seen = new Set;
+  const scoresByCheckpoint = new Map;
+  for (const candidate of value.scores) {
+    if (!isRecord(candidate) || Object.keys(candidate).length !== 2 || !Object.hasOwn(candidate, "checkpoint") || !Object.hasOwn(candidate, "score"))
+      continue;
+    const checkpoint = candidate.checkpoint;
+    const score = candidate.score;
+    if (typeof checkpoint !== "number" || !Number.isInteger(checkpoint) || seen.has(checkpoint))
+      continue;
+    if (!requested.has(checkpoint) || typeof score !== "number" || !Number.isInteger(score) || score < VERIFICATION_SCALE.min || score > VERIFICATION_SCALE.max)
+      continue;
+    seen.add(checkpoint);
+    scoresByCheckpoint.set(checkpoint, score);
+  }
+  return checkpoints.map((checkpoint) => scoresByCheckpoint.get(checkpoint) ?? null);
+}
+async function scoreRepeat(ctx, input, checkpoints, repeat) {
+  try {
+    const result = await ctx.task(`progress-score-${repeat + 1}`, {
+      prompt: build_progress_prompt({ ...input, checkpoints }),
+      context: "fresh",
+      schema: progressSchema
+    });
+    return scoresFromStructured(result.structured, checkpoints);
+  } catch {
+    return nullScores(checkpoints.length);
+  }
+}
+async function score_progress(ctx, input) {
+  if (input.steps.length === 0)
+    throw new RangeError("Progress scoring requires a non-empty step prefix.");
+  const checkpoints = Array.from(input.checkpoints ?? defaultCheckpoints(input.steps.length));
+  validateCheckpoints(checkpoints, input.steps.length);
+  const repeats = input.repeats ?? DEFAULT_REPEATS;
+  const perRepeat = [];
+  for (let repeat = 0;repeat < repeats; repeat += 1) {
+    perRepeat.push(await scoreRepeat(ctx, input, checkpoints, repeat));
+  }
+  const scores = checkpoints.map((_, checkpointIndex) => {
+    const valid = perRepeat.map((repeat) => repeat[checkpointIndex]).filter((score) => score !== null);
+    if (valid.length === 0)
+      return null;
+    return valid.reduce((total, score) => total + score, 0) / valid.length;
+  });
+  return { checkpoints, scores, perRepeat };
+}
+function build_progress_prompt(input) {
+  const numberedSteps = input.steps.map((step, index) => `${index + 1}. ${step}`);
+  const sharedHead = [
+    "<progress_head>",
+    "<problem>",
+    input.problem,
+    "</problem>",
+    "<steps>",
+    ...numberedSteps,
+    "</steps>",
+    "<calibration>",
+    ...CALIBRATION_RULES,
+    "</calibration>",
+    "<scale>",
+    `Use VERIFICATION_SCALE ${VERIFICATION_SCALE.min}..${VERIFICATION_SCALE.max} to answer: would the CURRENT state satisfy the acceptance criteria?`,
+    PROGRESS_SCALE_ORIENTATION,
+    "Score only the supplied current state from observed output.",
+    "</scale>",
+    "</progress_head>"
+  ].join(`
+`);
+  const checkpointTail = [
+    "<checkpoints>",
+    "Score each listed 1-indexed checkpoint.",
+    ...input.checkpoints.map((checkpoint) => `- ${checkpoint}`),
+    "</checkpoints>",
+    "<output_format>",
+    `Return structured_output with scores: [{ checkpoint, score }], using integer scores from ${VERIFICATION_SCALE.min} through ${VERIFICATION_SCALE.max}.`,
+    "</output_format>"
+  ].join(`
+`);
+  return `${sharedHead}
+
+${checkpointTail}`;
+}
+function mean(values) {
+  if (values.length === 0)
+    return 0;
+  return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function classify_trend(series, config = {}) {
+  const window = config.window ?? DEFAULT_TREND_WINDOW;
+  const riseDelta = config.riseDelta ?? DEFAULT_RISE_DELTA;
+  const fallDelta = config.fallDelta ?? DEFAULT_FALL_DELTA;
+  if (series.length < window + 1) {
+    return { trend: "flat", evidence: { series, window, delta: 0 } };
+  }
+  const sample = series.slice(-2 * window);
+  const usableLength = sample.length % 2 === 1 ? sample.length - 1 : sample.length;
+  const halfLength = usableLength / 2;
+  const leading = sample.slice(0, halfLength);
+  const trailing = sample.slice(sample.length - halfLength);
+  const delta = halfLength === 0 ? 0 : mean(trailing) - mean(leading);
+  const trend = delta >= riseDelta ? "rising" : delta <= fallDelta ? "regressing" : "flat";
+  return { trend, evidence: { series, window, delta } };
+}
+
+export { DEFAULT_RISE_DELTA, DEFAULT_FALL_DELTA, score_progress, classify_trend };

package/dist/builtin/workflows/builtin/chunk-7430zyas.js

@@ -0,0 +1,126 @@
+import {
+  VERIFICATION_SCALE
+} from "./chunk-cg9tmks0.js";
+
+// dist/builtin/workflows/builtin/verification-prompts.ts
+var MAX_INLINE_CANDIDATE_BYTES = 32 * 1024;
+var DEFAULT_WARM_CONCURRENCY = 4;
+var DEFAULT_OUTPUT_FORMAT = "Call structured_output with criterion_id, score (1–20), evidence, and findings containing finding and severity.";
+function inlineCandidates(head) {
+  return head.candidates.every((candidate) => Buffer.byteLength(candidate.body, "utf8") <= MAX_INLINE_CANDIDATE_BYTES);
+}
+function fallbackReadPaths(head) {
+  if (inlineCandidates(head))
+    return;
+  const paths = [];
+  for (const [index, candidate] of head.candidates.entries()) {
+    if (candidate.path === undefined) {
+      throw new TypeError(`Oversized candidate family requires a caller-bound path for every candidate; candidate ${index + 1} has no path.`);
+    }
+    paths.push(candidate.path);
+  }
+  return paths;
+}
+function candidateSection(head, readPaths) {
+  return head.candidates.map((candidate, index) => {
+    if (readPaths === undefined) {
+      return `<candidate index="${index + 1}">
+${candidate.body}
+</candidate>`;
+    }
+    return `<candidate index="${index + 1}" source="read">
+Read candidate from ${readPaths[index]}.
+</candidate>`;
+  }).join(`
+`);
+}
+function scoring_prompt_reads(head) {
+  return fallbackReadPaths(head) ?? [];
+}
+function build_scoring_prompt(head, criterion) {
+  const readPaths = fallbackReadPaths(head);
+  const sharedHead = [
+    "<scoring_head>",
+    "<task_statement>",
+    head.task,
+    "</task_statement>",
+    "<ground_truth_note>",
+    head.groundTruthNote,
+    "</ground_truth_note>",
+    "<candidates>",
+    candidateSection(head, readPaths),
+    "</candidates>",
+    "<scale_anchors>",
+    head.scaleAnchors ?? VERIFICATION_SCALE.anchors,
+    "</scale_anchors>"
+  ].join(`
+`);
+  const varyingTail = [
+    "<criterion>",
+    `<name>${criterion.name}</name>`,
+    `<description>${criterion.description}</description>`,
+    "</criterion>",
+    "<output_format>",
+    head.outputFormat ?? DEFAULT_OUTPUT_FORMAT,
+    "</output_format>"
+  ].join(`
+`);
+  return `${sharedHead}
+
+${varyingTail}`;
+}
+function boundedConcurrency(stepCount, phaseCap, inheritedCap) {
+  return Math.min(stepCount, phaseCap ?? stepCount, inheritedCap ?? stepCount);
+}
+async function warm_first_fan_out(ctx, steps, prefixKeyOf, options = {}) {
+  const warmIndices = [];
+  const restIndices = [];
+  const seen = new Set;
+  for (const [index, step] of steps.entries()) {
+    const prefixKey = prefixKeyOf(step, index);
+    if (seen.has(prefixKey))
+      restIndices.push(index);
+    else {
+      seen.add(prefixKey);
+      warmIndices.push(index);
+    }
+  }
+  const { warmConcurrency, ...parallelOptions } = options;
+  const inheritedConcurrency = parallelOptions.concurrency;
+  const resultsByIndex = new Map;
+  let warmFailure;
+  if (warmIndices.length > 0) {
+    const warmSteps = warmIndices.map((index) => steps[index]);
+    try {
+      const warmResults = await ctx.parallel(warmSteps, {
+        ...parallelOptions,
+        concurrency: boundedConcurrency(warmSteps.length, warmConcurrency ?? DEFAULT_WARM_CONCURRENCY, inheritedConcurrency),
+        failFast: false
+      });
+      for (const [resultIndex, result] of warmResults.entries()) {
+        const originalIndex = warmIndices[resultIndex];
+        if (originalIndex !== undefined)
+          resultsByIndex.set(originalIndex, result);
+      }
+    } catch (error) {
+      warmFailure = error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  if (restIndices.length > 0) {
+    const restSteps = restIndices.map((index) => steps[index]);
+    const restResults = await ctx.parallel(restSteps, {
+      ...parallelOptions,
+      concurrency: boundedConcurrency(restSteps.length, undefined, inheritedConcurrency)
+    });
+    for (const [resultIndex, result] of restResults.entries()) {
+      const originalIndex = restIndices[resultIndex];
+      if (originalIndex !== undefined)
+        resultsByIndex.set(originalIndex, result);
+    }
+  }
+  if (warmFailure !== undefined)
+    throw warmFailure;
+  return steps.map((_, index) => resultsByIndex.get(index)).filter((result) => result !== undefined);
+}
+
+export { scoring_prompt_reads, build_scoring_prompt, warm_first_fan_out };

package/dist/builtin/workflows/builtin/chunk-7at6dnkr.js

@@ -0,0 +1,33 @@
+// dist/builtin/workflows/builtin/verification-usage.ts
+function fold_usage(results) {
+  const totals = {
+    calls: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0
+  };
+  for (const result of results) {
+    for (const attempt of result.modelAttempts ?? []) {
+      totals.calls += 1;
+      const usage = attempt.usage;
+      if (usage === undefined)
+        continue;
+      totals.input += usage.input ?? 0;
+      totals.output += usage.output ?? 0;
+      totals.cacheRead += usage.cacheRead ?? 0;
+      totals.cacheWrite += usage.cacheWrite ?? 0;
+      totals.cost += usage.cost ?? 0;
+      totals.turns += usage.turns ?? 0;
+    }
+  }
+  const cacheDenominator = totals.input + totals.cacheRead;
+  return {
+    ...totals,
+    cacheHitRate: cacheDenominator === 0 ? 0 : totals.cacheRead / cacheDenominator
+  };
+}
+
+export { fold_usage };

package/dist/builtin/workflows/builtin/chunk-82ha8p41.js

@@ -0,0 +1,175 @@
+import {
+  stableArtifactRoot
+} from "./chunk-wpckd35c.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/classify-and-act.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/classify-and-act-runner.ts
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+
+// dist/builtin/workflows/builtin/classify-and-act-prompts.ts
+var GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+var READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
+function classifierPrompt(prompt, categories) {
+  return `<categories>
+${categories.map((category) => `- ${category}`).join(`
+`)}
+</categories>
+
+<role>
+You route a task to exactly one declared action category.
+</role>
+
+<success_criteria>
+The selected category is copied verbatim and supported by the task's concrete wording.
+</success_criteria>
+
+<decision_rules>
+Choose exactly one listed category. Use low confidence when the task is ambiguous or spans categories. Stop after making that single classification.
+</decision_rules>
+
+<output_format>
+Return only the structured result requested by the schema: category, confidence, and a concise evidence-based rationale in complete sentences.
+</output_format>
+
+<objective>
+Classify this task: ${prompt}
+</objective>`;
+}
+function actionPrompt(input) {
+  return `<evidence>
+Read the classification artifact at ${input.classificationPath}. Use only relevant evidence available to this stage; do not assume access to classifier conversation context.
+</evidence>
+
+<role>
+You are the isolated action agent for category "${input.category}".
+</role>
+
+<success_criteria>
+Complete the requested action for this category, distinguish verified facts from assumptions, and report concrete evidence, validation, and remaining risks.
+</success_criteria>
+
+<stop_rules>
+Stop when the category-specific action is complete or a remaining blocker is stated with its missing evidence.
+</stop_rules>
+
+<output_format>
+Markdown with Outcome, Evidence, Validation, and Remaining risks headings. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+${input.prompt}
+</objective>`;
+}
+
+// dist/builtin/workflows/builtin/classify-and-act-runner.ts
+var classificationSchema = Type.Object({
+  category: Type.String({ description: "One category copied verbatim from the supplied list." }),
+  confidence: Type.Number({ minimum: 0, maximum: 1 }),
+  rationale: Type.String()
+}, { additionalProperties: false });
+function safeName(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return normalized || "fallback";
+}
+function actionTools(category) {
+  const normalized = category.toLowerCase();
+  if (normalized.includes("implement") || normalized.includes("fix") || normalized.includes("code")) {
+    return ["read", "edit", "write", "bash"];
+  }
+  if (normalized.includes("research"))
+    return ["read", "web_search", "fetch_content"];
+  return ["read"];
+}
+async function resolveFallbackCategory(ctx, exactCategory) {
+  try {
+    const category = await ctx.ui.select("Classification is uncertain. Choose the action category.", ctx.inputs.categories);
+    return { category, fallbackMode: "interactive_select" };
+  } catch {
+    return { category: exactCategory ?? ctx.inputs.categories[0], fallbackMode: "deterministic" };
+  }
+}
+async function runClassifyAndAct(ctx) {
+  const artifactDir = await stableArtifactRoot(ctx, "classify-and-act");
+  const classified = await ctx.task("classifier", {
+    prompt: classifierPrompt(ctx.inputs.prompt, ctx.inputs.categories),
+    schema: classificationSchema,
+    context: "fresh",
+    tools: []
+  });
+  const value = classified.structured;
+  const proposedCategory = typeof value === "object" && value !== null && "category" in value ? String(value.category) : "";
+  const confidenceValue = typeof value === "object" && value !== null && "confidence" in value ? value.confidence : 0;
+  const confidence = typeof confidenceValue === "number" && Number.isFinite(confidenceValue) ? Math.max(0, Math.min(1, confidenceValue)) : 0;
+  const rationale = typeof value === "object" && value !== null && "rationale" in value ? String(value.rationale) : "Classifier did not provide a usable structured rationale.";
+  const exactCategory = ctx.inputs.categories.find((category2) => category2 === proposedCategory);
+  const needsFallback = exactCategory === undefined || confidence < ctx.inputs.confidence_threshold;
+  const fallback = needsFallback ? await resolveFallbackCategory(ctx, exactCategory) : undefined;
+  const category = fallback?.category ?? exactCategory;
+  const classificationPath = join(artifactDir, "classification.json");
+  await writeFile(classificationPath, JSON.stringify({
+    proposed_category: proposedCategory,
+    selected_category: category,
+    confidence,
+    threshold: ctx.inputs.confidence_threshold,
+    rationale,
+    fallback_used: needsFallback,
+    fallback_mode: fallback?.fallbackMode ?? "none"
+  }, null, 2));
+  const actionPath = join(artifactDir, `action-${safeName(category)}.md`);
+  const action = await ctx.task(`action-${safeName(category)}`, {
+    tools: actionTools(category),
+    prompt: actionPrompt({ prompt: ctx.inputs.prompt, category, classificationPath }),
+    context: "fresh",
+    reads: [classificationPath],
+    output: actionPath,
+    outputMode: "file-only"
+  });
+  const result = action.text;
+  return { result, category, confidence, action: action.stageName, classification_path: classificationPath, action_path: actionPath, artifact_dir: artifactDir };
+}
+
+// dist/builtin/workflows/builtin/classify-and-act.ts
+var DEFAULT_ACTION_CATEGORIES = ["analysis", "implementation", "research"];
+var classify_and_act_default = workflow({
+  name: "classify-and-act",
+  description: "Classify a task with structured confidence, route deterministically to an isolated category action, and ask for human selection when confidence is low.",
+  heartbeatIntervalMinutes: 15,
+  inputs: {
+    prompt: Type2.String({ description: "Task to classify and execute." }),
+    categories: Type2.Array(Type2.String({ minLength: 1 }), {
+      minItems: 1,
+      maxItems: 8,
+      default: [...DEFAULT_ACTION_CATEGORIES],
+      description: "Ordered action categories available to the classifier and fallback chooser."
+    }),
+    confidence_threshold: Type2.Number({
+      minimum: 0.5,
+      maximum: 0.99,
+      default: 0.75,
+      description: "Minimum structured confidence required to route without human selection."
+    })
+  },
+  outputs: {
+    result: Type2.String({ description: "Compact reference to the category-specific action report artifact; read `action_path` for the full report." }),
+    category: Type2.String({ description: "Selected category, including any human fallback selection." }),
+    confidence: Type2.Number({ minimum: 0, maximum: 1, description: "Classifier confidence before fallback." }),
+    action: Type2.String({ description: "Executed category-specific action stage name." }),
+    classification_path: Type2.String({ description: "Structured classification artifact path." }),
+    action_path: Type2.String({ description: "Category action report artifact path." }),
+    artifact_dir: Type2.String({ description: "Per-run artifact directory." })
+  },
+  run: async (ctx) => await runClassifyAndAct(withSteeringPropagationContext(ctx))
+});
+
+export { DEFAULT_ACTION_CATEGORIES, classify_and_act_default };

package/dist/builtin/workflows/builtin/chunk-bfkmzv9h.js

@@ -0,0 +1,156 @@
+// dist/builtin/workflows/src/authoring/workflow.ts
+import { basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// dist/builtin/workflows/src/shared/budget.ts
+function validateWorkflowBudget(value, label = "budget") {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return `"${label}" must be a JSON object, got ${JSON.stringify(typeof value)}`;
+  }
+  const budget = value;
+  for (const field of ["maxDurationMs", "maxTokens"]) {
+    const limit = budget[field];
+    if (field in budget && (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit < 0)) {
+      return `"${label}.${field}" must be a non-negative finite integer, got ${JSON.stringify(limit)}`;
+    }
+  }
+  for (const field of ["maxCost", "warnAtPercent"]) {
+    const limit = budget[field];
+    if (field in budget && (typeof limit !== "number" || !Number.isFinite(limit) || limit < 0)) {
+      return `"${label}.${field}" must be a non-negative finite number, got ${JSON.stringify(limit)}`;
+    }
+  }
+  return null;
+}
+function assertWorkflowBudget(value, label = "budget") {
+  if (value === undefined)
+    return;
+  const reason = validateWorkflowBudget(value, label);
+  if (reason !== null)
+    throw new TypeError(reason);
+}
+
+// dist/builtin/workflows/src/shared/workflow-heartbeat-contract.ts
+var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15;
+
+// dist/builtin/workflows/src/workflows/identity.ts
+function normalizeWorkflowName(name) {
+  if (!name || typeof name !== "string") {
+    throw new TypeError("normalizeWorkflowName: name must be a non-empty string");
+  }
+  return name.trim().toLowerCase().replace(/[\s_]+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
+
+// dist/builtin/workflows/src/authoring/workflow.ts
+var BRANDED_WORKFLOW_DEFINITIONS = new WeakSet;
+function stampWorkflowDefinition(definition) {
+  BRANDED_WORKFLOW_DEFINITIONS.add(definition);
+  return definition;
+}
+function requireNonEmptyString(value, label) {
+  if (value.trim().length === 0) {
+    throw new TypeError(`workflow: ${label} must be a non-empty string`);
+  }
+}
+function freezeSchemaMap(schemas) {
+  return Object.freeze({ ...schemas });
+}
+function stackFilePath(line) {
+  const fileUrlMatch = line.match(/\(?((?:file:\/\/)[^\s)]+?\.[cm]?[jt]sx?):\d+:\d+\)?/);
+  const rawPath = fileUrlMatch?.[1] ?? line.match(/\(?((?:\/|[A-Za-z]:[\\/])[^():]+?\.[cm]?[jt]sx?):\d+:\d+\)?/)?.[1];
+  if (rawPath === undefined)
+    return;
+  if (!rawPath.startsWith("file://"))
+    return rawPath;
+  try {
+    return fileURLToPath(rawPath);
+  } catch {
+    return;
+  }
+}
+function isWorkflowAuthoringImplementationFrame(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (!/\/authoring\/workflow\.[cm]?[jt]sx?$/.test(normalized))
+    return false;
+  return normalized.includes("/packages/workflows/") || normalized.includes("/node_modules/@bastani/workflows/") || normalized.includes("/dist/builtin/workflows/") || normalized.includes("/.atomic/agent/extensions/workflows/") || normalized.includes("/.pi/agent/extensions/workflows/");
+}
+function workflowNameFromCaller() {
+  const stack = new Error().stack;
+  if (stack === undefined)
+    return;
+  for (const line of stack.split(`
+`)) {
+    const filePath = stackFilePath(line);
+    if (filePath === undefined)
+      continue;
+    if (isWorkflowAuthoringImplementationFrame(filePath))
+      continue;
+    const base = basename(filePath.replace(/\\/g, "/")).replace(/\.[cm]?[jt]sx?$/, "");
+    if (base.length > 0)
+      return base;
+  }
+  return;
+}
+function resolveWorkflowName(name) {
+  const resolved = name ?? workflowNameFromCaller();
+  if (resolved === undefined) {
+    throw new TypeError("workflow: name must be provided when caller filename cannot be inferred");
+  }
+  requireNonEmptyString(resolved, "name");
+  return resolved;
+}
+function freezeInputBindings(binding) {
+  if (binding === undefined)
+    return;
+  return Object.freeze({
+    worktree: Object.freeze({ ...binding })
+  });
+}
+function freezeBudget(budget) {
+  return budget === undefined ? undefined : Object.freeze({ ...budget });
+}
+function workflow(spec) {
+  const specRun = spec.run;
+  if (typeof spec.description !== "string") {
+    throw new TypeError("workflow: description must be a string");
+  }
+  if (typeof specRun !== "function") {
+    throw new TypeError("workflow: run must be a function");
+  }
+  if (spec.outputs === undefined || spec.outputs === null || typeof spec.outputs !== "object" || Array.isArray(spec.outputs)) {
+    throw new TypeError("workflow: outputs must be a schema map");
+  }
+  if (spec.inputs !== undefined && (spec.inputs === null || typeof spec.inputs !== "object" || Array.isArray(spec.inputs))) {
+    throw new TypeError("workflow: inputs must be a schema map");
+  }
+  const heartbeatIntervalMinutes = spec.heartbeatIntervalMinutes === undefined ? DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES : spec.heartbeatIntervalMinutes;
+  if (!Number.isFinite(heartbeatIntervalMinutes) || heartbeatIntervalMinutes < 0) {
+    throw new TypeError("workflow: heartbeatIntervalMinutes must be a non-negative finite number");
+  }
+  assertWorkflowBudget(spec.budget, "workflow: budget");
+  const name = resolveWorkflowName(spec.name);
+  const normalizedName = normalizeWorkflowName(name);
+  requireNonEmptyString(normalizedName, "normalized name");
+  const frozenInputs = freezeSchemaMap(spec.inputs ?? {});
+  const frozenOutputs = freezeSchemaMap(spec.outputs);
+  const inputBindings = freezeInputBindings(spec.worktreeFromInputs);
+  const budget = freezeBudget(spec.budget);
+  const run = async (ctx) => specRun(ctx);
+  const definition = {
+    __piWorkflow: true,
+    name,
+    normalizedName,
+    description: spec.description,
+    ...spec.autoAttach === true ? { autoAttach: true } : {},
+    heartbeatIntervalMinutes,
+    inputs: frozenInputs,
+    outputs: frozenOutputs,
+    ...inputBindings !== undefined ? { inputBindings } : {},
+    ...budget !== undefined ? { budget } : {},
+    run
+  };
+  const branded = stampWorkflowDefinition(definition);
+  return Object.freeze(branded);
+}
+
+export { workflow };