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

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

@@ -1,311 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { mkdirSync } from "node:fs";
-import { tmpdir, userInfo } from "node:os";
-import { join } from "node:path";
-import { Type } from "typebox";
-import { createChildProcessEnvironment } from "@bastani/atomic";
-import type { WorkflowTaskResult } from "../src/shared/types.js";
-
-
-export const OUTPUT_TYPES = [
-  "prototype",
-  "wireframe",
-  "page",
-  "component",
-  "theme",
-  "tokens",
-] as const;
-export type OutputType = (typeof OUTPUT_TYPES)[number];
-export const DEFAULT_OUTPUT_TYPE: OutputType = "prototype";
-
-type PromptSection = readonly [tag: string, content: string];
-
-export function taggedPrompt(sections: readonly PromptSection[]): string {
-  return sections
-    .map(([tag, content]) => {
-      const trimmed = content.trim();
-      return `<${tag}>\n${trimmed}\n</${tag}>`;
-    })
-    .join("\n\n");
-}
-
-
-export function normalizeOutputType(value: string | undefined): OutputType {
-  return value !== undefined &&
-    (OUTPUT_TYPES as readonly string[]).includes(value)
-    ? (value as OutputType)
-    : DEFAULT_OUTPUT_TYPE;
-}
-
-export function isUrl(value: string): boolean {
-  return /^https?:\/\//i.test(value.trim());
-}
-
-export function isFileLike(value: string): boolean {
-  const trimmed = value.trim();
-  return trimmed.length > 0 && !isUrl(trimmed);
-}
-
-/**
- * Whether the browser-centric workflow should exit early instead of generating
- * artifacts no one can review interactively. True only when the playwright-cli
- * browser is unavailable AND we are not under the test harness (`NODE_ENV=test`,
- * which always skips the global install and runs headlessly to completion).
- */
-export function shouldEarlyExitForBrowser(
-  browserAvailable: boolean,
-  nodeEnv: string | undefined,
-): boolean {
-  return !browserAvailable && nodeEnv !== "test";
-}
-
-export type DiscoveryDecision = {
-  readonly brief: string;
-  readonly output_type: OutputType;
-  readonly references: readonly string[];
-};
-
-export const discoveryDecisionSchema = Type.Object(
-  {
-    brief: Type.String(),
-    output_type: Type.Union([...OUTPUT_TYPES].map((value) => Type.Literal(value))),
-    references: Type.Array(Type.String()),
-  },
-  { additionalProperties: false },
-);
-
-/**
- * Parse the discovery stage's structured result, tolerating a missing/invalid
- * structured payload (headless / mock runs) by falling back to the raw prompt as
- * the brief, the default output type, and an empty reference list.
- */
-export function discoveryDecisionFromResult(
-  result: WorkflowTaskResult,
-  fallbackBrief: string,
-): DiscoveryDecision {
-  const decision = result.structured as Partial<DiscoveryDecision> | undefined;
-  const brief =
-    typeof decision?.brief === "string" && decision.brief.trim().length > 0
-      ? decision.brief.trim()
-      : fallbackBrief;
-  const references = Array.isArray(decision?.references)
-    ? decision.references
-        .filter((ref): ref is string => typeof ref === "string")
-        .map((ref) => ref.trim())
-        .filter((ref) => ref.length > 0)
-    : [];
-  return {
-    brief,
-    output_type: normalizeOutputType(decision?.output_type),
-    references,
-  };
-}
-
-export function joinResults(results: readonly WorkflowTaskResult[]): string {
-  return results
-    .map((result) => `### ${result.name}\n\n${result.text}`)
-    .join("\n\n---\n\n");
-}
-
-/**
- * Per-user tmpdir base for run artifacts. Namespacing by username avoids
- * EACCES collisions on shared hosts where another user already owns a plain
- * `<tmpdir>/open-claude-design` directory.
- */
-function tmpArtifactBase(): string {
-  let user = "default";
-  try {
-    user = userInfo().username.replace(/[^A-Za-z0-9._-]/g, "_") || "default";
-  } catch {
-    // keep the "default" namespace when the username is unavailable
-  }
-  return join(tmpdir(), `open-claude-design-${user}`);
-}
-
-/**
- * Compute (and best-effort create) a per-run artifact directory.
- * Prefers `<cwd>/.atomic/workflows/open-claude-design/<runId>` so the artifacts
- * stay next to the project and are discoverable by pi. Falls back to a
- * per-user OS tmpdir when the project tree is not writable (CI sandboxes,
- * mocks, etc.).
- */
-export function prepareArtifactDir(cwd = process.cwd()): {
-  readonly runId: string;
-  readonly artifactDir: string;
-  readonly previewPath: string;
-  readonly specPath: string;
-} {
-  const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
-  // Under automated tests, prefer the OS tmpdir so a full `d.run()` does not
-  // pollute the project's `specs/design/` tree with per-run artifact folders.
-  const tmpCandidates = [
-    join(tmpArtifactBase(), runId),
-    join(tmpdir(), "open-claude-design", runId),
-  ];
-  const candidates =
-    process.env.NODE_ENV === "test"
-      ? tmpCandidates
-      : [join(cwd, "specs", "design", runId), ...tmpCandidates];
-  for (const candidate of candidates) {
-    try {
-      mkdirSync(candidate, { recursive: true });
-      return {
-        runId,
-        artifactDir: candidate,
-        previewPath: join(candidate, "preview.html"),
-        specPath: join(candidate, "spec.html"),
-      };
-    } catch {
-      // try next fallback
-    }
-  }
-  // Last-resort: synthesize paths even if mkdir failed; downstream agents will
-  // recreate parents using their Write tool.
-  const fallback = join(tmpArtifactBase(), runId);
-  return {
-    runId,
-    artifactDir: fallback,
-    previewPath: join(fallback, "preview.html"),
-    specPath: join(fallback, "spec.html"),
-  };
-}
-
-export const HTML_PREVIEW_RULES = [
-  "Produce one self-contained HTML document: inline CSS in <style> and JS in <script>; make no external requests except explicitly required Google Fonts.",
-  "Use realistic brief-specific content, not Lorem ipsum or obvious placeholders.",
-  "Render well from 360px to 1440px with sensible container or media-query breakpoints.",
-  "Include default and hover/focus states for every interactive element, plus empty, loading, and error states where relevant.",
-  "Use semantic landmarks, labeled controls, WCAG AA contrast, visible focus, and prefers-reduced-motion.",
-  "Add HTML comments marking sections, states, and design-system token references for engineering handoff.",
-].join("\n");
-
-export const ANTI_SLOP_RULES = [
-  "Avoid generic AI palettes and structures: purple/indigo or blue-to-pink gradients, neon glassmorphism stacks, and nested card grids.",
-  "Avoid impeccable catalog clichés: gradient emphasis text, side-tab borders, three-font headers, and decorative shadows in flat-by-default systems.",
-  "Commit to a specific aesthetic rather than generic SaaS defaults.",
-].join("\n");
-
-/** Reference-import precedence note shared by import, generation, and refinement. */
-export const REFERENCE_PRECEDENCE =
-  "User references in <reference_context> are the PRIMARY visual authority and override conflicting DESIGN.md/PRODUCT.md guidance. DESIGN.md governs uncovered design decisions; PRODUCT.md still governs strategic register/voice.";
-
-export type PlaywrightCliStatus = {
-  /** Whether the `playwright-cli` command is expected to be available to downstream stages. */
-  readonly available: boolean;
-  /** True when the command was already on PATH and no install was attempted. */
-  readonly alreadyPresent: boolean;
-  /** True when this step installed the command via `npm install -g @playwright/cli@latest`. */
-  readonly installed: boolean;
-  /** Human-readable, single-line outcome surfaced as a workflow output. */
-  readonly summary: string;
-  /** Raw failure reason when the install could not complete; absent on success. */
-  readonly error?: string;
-};
-
-/**
- * Initial deterministic setup step (no LLM): ensure the playwright-cli skill's
- * `playwright-cli` command is available before any design stage runs. Mirrors the
- * playwright-cli skill's documented bootstrap (`npx --no-install playwright-cli
- * --version` || `npm install -g @playwright/cli@latest`) but performs it once,
- * deterministically, instead of relying on each stage to probe/install it.
- * The PATH probe always runs, but the actual global install is skipped under
- * automated tests (`NODE_ENV=test`) to avoid slow, networked, environment-
- * mutating side effects.
- *
- * Best-effort by contract: it never throws and never blocks the workflow. When
- * the command cannot be located or installed, downstream stages keep their graceful
- * degradation path (surface the manual preview path / URL).
- */
-export function ensurePlaywrightCli(): PlaywrightCliStatus {
-  const isWindows = process.platform === "win32";
-  const onPath = (): boolean => {
-    try {
-      const probe = spawnSync(isWindows ? "where" : "which", ["playwright-cli"], {
-        stdio: "ignore",
-        timeout: 15_000,
-        shell: isWindows,
-        env: createChildProcessEnvironment(),
-      });
-      return probe.status === 0;
-    } catch {
-      return false;
-    }
-  };
-
-  if (onPath()) {
-    return {
-      available: true,
-      alreadyPresent: true,
-      installed: false,
-      summary: "playwright-cli already on PATH; skipped install.",
-    };
-  }
-
-  // Never perform a real global `npm install` during automated tests: it is
-  // slow, network-dependent, and would mutate the test runner's global
-  // environment. The PATH probe above and the prompt guidance below are still
-  // exercised; only the install side effect is skipped.
-  if (process.env.NODE_ENV === "test") {
-    return {
-      available: false,
-      alreadyPresent: false,
-      installed: false,
-      summary:
-        "playwright-cli not found; skipped global install under the test environment.",
-      error: "global install skipped during tests",
-    };
-  }
-
-  try {
-    const install = spawnSync("npm", ["install", "-g", "@playwright/cli@latest"], {
-      stdio: "ignore",
-      timeout: 180_000,
-      shell: isWindows,
-      env: createChildProcessEnvironment(),
-    });
-    if (install.status === 0) {
-      return {
-        available: true,
-        alreadyPresent: false,
-        installed: true,
-        summary: "Installed playwright-cli via `npm install -g @playwright/cli@latest`.",
-      };
-    }
-    const reason =
-      install.error?.message ??
-      (typeof install.status === "number"
-        ? `npm install -g @playwright/cli@latest exited with code ${install.status}`
-        : "npm install -g @playwright/cli@latest did not complete");
-    return {
-      available: false,
-      alreadyPresent: false,
-      installed: false,
-      summary: `Could not install playwright-cli (${reason}); stages will degrade gracefully.`,
-      error: reason,
-    };
-  } catch (error) {
-    const reason =
-      error instanceof Error ? error.message : String(error);
-    return {
-      available: false,
-      alreadyPresent: false,
-      installed: false,
-      summary: `Could not install playwright-cli (${reason}); stages will degrade gracefully.`,
-      error: reason,
-    };
-  }
-}
-
-/** Build browser guidance for downstream stage prompts. */
-export function buildPlaywrightCliBootstrapRules(status: PlaywrightCliStatus): string {
-  const probeRule = status.available
-    ? "The playwright-cli skill's `playwright-cli` command is on PATH. Do not reinstall it unless a command reports it missing; then probe with `which playwright-cli` (or `npx --no-install playwright-cli --version`), run `npm install -g @playwright/cli@latest` once, and retry. Do not add project dependencies."
-    : `The playwright-cli skill's \`playwright-cli\` command failed setup: "${status.error ?? "unknown error"}". Probe with \`which playwright-cli\` (or \`npx --no-install playwright-cli --version\`) and retry once with \`npm install -g @playwright/cli@latest\`. For permission errors, use a user-writable global prefix; report missing npm/Node or network/registry errors plainly. If still unavailable, surface the manual file path / URL. Do not add project dependencies.`;
-  return [
-    probeRule,
-    "Use `playwright-cli open <url>` to show a local preview; use `playwright-cli snapshot` and `playwright-cli screenshot --filename=<file>` for review evidence.",
-    "If a `playwright-cli` command reports a missing browser executable, run `npx playwright install chromium` once and retry.",
-    "If `playwright-cli` is unavailable after three attempts or the browser runtime still fails, surface the manual file path / URL.",
-  ].join("\n");
-}
-

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

@@ -1,57 +0,0 @@
-/**
- * Builtin workflow: open-claude-design
- *
- * Adapts Atomic SDK's Claude Design workflow to the local workflow SDK:
- * combined discovery/init, design-system/reference research, one generation,
- * one live review session, export, and final display run through
- * ctx.task()/ctx.parallel().
- *
- * Every stage prompt invokes the specific impeccable sub-skill that maps to
- * its role (see https://github.com/pbakaus/impeccable/tree/main/site/content/skills):
- *
- *   onboarding     → impeccable `document` / `extract` / `audit`
- *   import         → impeccable `extract`
- *   generate-1     → impeccable `craft` (HTML preview)
- *   live review    → impeccable `live` (unbounded browser review session)
- *   exporter       → impeccable `document` (rich HTML spec)
- *   final-display  → opens/surfaces the exported HTML spec
- */
-
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.js";
-import { runOpenClaudeDesignWorkflow } from "./open-claude-design-runner.js";
-
-export default workflow({
-  name: "open-claude-design",
-  description: "AI-powered design workflow: combined discovery/init → design-system/reference research → curated reference discovery → HTML generation → one live review session → rich HTML handoff. The discovery stage asks what to build, the output type, and which references to emulate, then runs impeccable init for PRODUCT.md/DESIGN.md (references take precedence over project context). The user reviews the generated HTML in one live session.",
-  // Disabled: this workflow is driven by the user reviewing generated HTML,
-  // so the parent chat is already the thing holding it to its goal. A periodic
-  // alignment steer would interrupt that review rather than inform it.
-  heartbeatIntervalMinutes: 0,
-  inputs: {
-    prompt: Type.String({
-      description: "What to design (for example, a dashboard, page, component, or prototype). The discovery stage refines this into a confirmed brief and asks for the output type and references.",
-    }),
-    discover_references: Type.Boolean({
-      default: true,
-      description:
-        "Discover beautiful, current reference designs from notable design websites (Awwwards, recent.design, Dribbble, Monet, Motionsites) and feed them to generation. Set false to skip the network/browser reference pass.",
-    }),
-  },
-  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: the project-derived design system." })),
-    artifact: Type.Optional(Type.String({ description: "Latest final design summary from the final preview artifact." })),
-    handoff: Type.Optional(Type.String({ description: "Final rich HTML spec and implementation handoff summary." })),
-    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(withSteeringPropagationContext(ctx)),
-});

package/dist/builtin/workflows/builtin/pattern-artifact-root.ts

@@ -1,28 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import type { WorkflowRunContext } from "../src/shared/types.js";
-
-/**
- * Durable per-run artifact root under `<cwd>/.atomic/workflows/runs`.
- *
- * The random directory name is generated exactly once through `ctx.tool`, so
- * a durable resume replays the original path instead of computing a fresh
- * per-process root. Replayed stages therefore keep reading artifacts written
- * before the interruption. The `mkdir` stays outside the durable checkpoint
- * and is idempotent, so both fresh runs and resumes converge on an existing
- * directory.
- */
-export async function stableArtifactRoot(
-  ctx: Pick<WorkflowRunContext, "cwd" | "tool">,
-  workflowName: string,
-): Promise<string> {
-  const cwd = ctx.cwd ?? process.cwd();
-  const artifactDir = await ctx.tool(
-    "artifact-root",
-    { workflow: workflowName },
-    async () => join(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID()}`),
-  );
-  await mkdir(artifactDir, { recursive: true });
-  return artifactDir;
-}

package/dist/builtin/workflows/builtin/progress-scoring.ts

@@ -1,230 +0,0 @@
-/**
- * Observation-grounded trajectory scoring and pure trend evidence.
- *
- * Progress is a monitoring magnitude only. The prompt asks about the supplied
- * current state, and the trend result carries evidence without an action.
- */
-import { Type } from "typebox";
-import type { WorkflowRunContext, WorkflowSerializableObject, WorkflowSerializableValue } from "../src/shared/types.js";
-import { VERIFICATION_SCALE } from "./verification-criteria.js";
-
-export const DEFAULT_TREND_WINDOW = 3;
-export const DEFAULT_RISE_DELTA = 1.5;
-export const DEFAULT_FALL_DELTA = -1.5;
-
-const DEFAULT_REPEATS = 1;
-const 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.",
-] as const;
-const PROGRESS_SCALE_ORIENTATION = `${VERIFICATION_SCALE.min} = certainly would not satisfy the acceptance criteria … ${VERIFICATION_SCALE.max} = verified satisfaction with observed output`;
-
-export interface ProgressPromptInput {
-	readonly problem: string;
-	readonly steps: readonly string[];
-	readonly checkpoints: readonly number[];
-}
-
-export interface ProgressScoreInput {
-	readonly problem: string;
-	readonly steps: readonly string[];
-	readonly checkpoints?: readonly number[];
-	readonly repeats?: number;
-}
-
-export type ProgressScoringContext = Pick<WorkflowRunContext, "task">;
-
-export type ProgressCurve = {
-	checkpoints: number[];
-	scores: (number | null)[];
-	perRepeat: (number | null)[][];
-};
-
-export type TrendConfig = {
-	window?: number;
-	riseDelta?: number;
-	fallDelta?: number;
-};
-
-export type Trend = "rising" | "flat" | "regressing";
-
-export type TrendResult = {
-	trend: Trend;
-	evidence: {
-		series: readonly number[];
-		window: number;
-		delta: number;
-	};
-};
-
-const progressSchema = Type.Object({
-	scores: Type.Array(Type.Object({
-		checkpoint: Type.Integer({ minimum: 1 }),
-		score: VERIFICATION_SCALE.schema,
-	}, { additionalProperties: false })),
-}, { additionalProperties: false });
-
-type ProgressStructuredOutput = {
-	readonly scores: readonly WorkflowSerializableValue[];
-};
-
-function isRecord(value: WorkflowSerializableValue | undefined): value is WorkflowSerializableObject {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function isProgressStructuredOutput(value: WorkflowSerializableValue | undefined): value is ProgressStructuredOutput {
-	if (!isRecord(value) || Object.keys(value).length !== 1 || !Object.hasOwn(value, "scores")) return false;
-	return Array.isArray(value.scores);
-}
-
-function nullScores(checkpointCount: number): (number | null)[] {
-	return Array.from({ length: checkpointCount }, () => null);
-}
-
-function defaultCheckpoints(stepCount: number): number[] {
-	const result: number[] = [];
-	for (let checkpoint = 2; checkpoint <= stepCount - 1; checkpoint += 1) result.push(checkpoint);
-	return result;
-}
-
-function validateCheckpoints(checkpoints: readonly number[], stepCount: number): void {
-	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: WorkflowSerializableValue | undefined,
-	checkpoints: readonly number[],
-): (number | null)[] {
-	if (!isProgressStructuredOutput(value)) return nullScores(checkpoints.length);
-	const requested = new Set(checkpoints);
-	const seen = new Set<number>();
-	const scoresByCheckpoint = new Map<number, number>();
-	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);
-}
-
-/**
- * Score all requested checkpoints in one structured stage call for one repeat.
- * A failed or malformed call is an invalid repeat and leaves every checkpoint
- * in that repeat null.
- */
-async function scoreRepeat(
-	ctx: ProgressScoringContext,
-	input: ProgressScoreInput,
-	checkpoints: readonly number[],
-	repeat: number,
-): Promise<(number | null)[]> {
-	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);
-	}
-}
-
-/** Score every requested checkpoint once per repeat, returning null-safe means. */
-export async function score_progress(
-	ctx: ProgressScoringContext,
-	input: ProgressScoreInput,
-): Promise<ProgressCurve> {
-	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: (number | null)[][] = [];
-	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 is number => score !== null);
-		if (valid.length === 0) return null;
-		return valid.reduce((total, score) => total + score, 0) / valid.length;
-	});
-	return { checkpoints, scores, perRepeat };
-}
-
-/**
- * Build a progress prompt with V3's shared-head/varying-tail layout. Steps are
- * part of the cacheable head; only the requested checkpoint list varies at the
- * tail.
- */
-export function build_progress_prompt(input: ProgressPromptInput): string {
-	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("\n");
-	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("\n");
-	return `${sharedHead}\n\n${checkpointTail}`;
-}
-
-function mean(values: readonly number[]): number {
-	if (values.length === 0) return 0;
-	return values.reduce((total, value) => total + value, 0) / values.length;
-}
-
-/**
- * Classify a score series using a deterministic hysteresis delta. The trailing
- * 2*window values are split into equal leading/trailing halves; an odd sample
- * drops its middle value. Thresholds are inclusive at +riseDelta and -fallDelta.
- */
-export function classify_trend(series: readonly number[], config: TrendConfig = {}): TrendResult {
-	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: Trend = delta >= riseDelta ? "rising" : delta <= fallDelta ? "regressing" : "flat";
-	return { trend, evidence: { series, window, delta } };
-}