@gr8ful/spf 0.1.6 → 0.2.1

package/dist/chains/adw_build_review.js

@@ -1,55 +0,0 @@
-/**
- * ADW Build Review — implement, then confirm it is what was asked for.
- *
- * Usage:
- *   spf build-review "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> builder -> reviewer [-> builder(revise) -> reviewer ... bounded]
- *
- * Review is not testing. Tests answer "does it run"; the reviewer answers "is this
- * the thing that was asked for" — it reads the spec (`plan.md` from a prior plan
- * phase if the session has one, else the prompt verbatim), reads the code that was
- * written, and rules on each requirement.
- *
- * Like the tester, the reviewer's phase succeeds when it RUNS and REPORTS. A
- * rejection does not fail the phase; it fails the run, checked at the end, after
- * the bounded revise loop has had its chances.
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as session from "../core/session.js";
-import { BuildOutput, ReviewOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["builder", "reviewer"];
-export const REQUIRED_SUITES = [];
-const MAX_REVISION_LOOPS = 3;
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    let previous = await run.phase(makePhaseParams({ name: "build", kind: "agent", owner: "builder", description: "Implement the request" }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, gates: [gates.diffMatchesClaims] })));
-    let review = null;
-    for (let i = 1; i <= MAX_REVISION_LOOPS; i++) {
-        review = await run.phase(makePhaseParams({
-            name: `review_${i}`,
-            kind: "agent",
-            owner: "reviewer",
-            description: "Rule on every requirement in the spec, against the code on disk",
-        }), (ph) => ph.call(makeAgentCall({ output_type: ReviewOutput, prompt, previous, gates: [gates.artifactsExist, gates.verdictConsistent] })));
-        if (review.approved)
-            break;
-        if (i === MAX_REVISION_LOOPS)
-            break;
-        previous = await run.phase(makePhaseParams({
-            name: `revise_${i}`,
-            kind: "agent",
-            owner: "builder",
-            retries: 1,
-            description: "Close every blocking finding the reviewer named",
-        }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: review, gates: [gates.diffMatchesClaims] })));
-    }
-    return run.finish(review !== null && review.approved, `the reviewer never approved after ${MAX_REVISION_LOOPS} revision(s)`);
-}

package/dist/chains/adw_build_test.d.ts

@@ -1,21 +0,0 @@
-/**
- * ADW Build Test — implement, then verify; failures flow back into the builder.
- *
- * Usage:
- *   spf build-test "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> builder -> code(test) [-> builder(fix) -> code(test) ... bounded]
- *
- * Testing is CODE. The suite's command is written down in core/quality.ts,
- * so running it needs no judgement — only repairing it does. Failures reach the
- * builder as an envelope through `quality.asEnvelope`, which is the same door an
- * agent's report came through, so the repair loop is unchanged.
- *
- * A failing suite does NOT fail its phase: the runner did its job, the code is
- * what failed. It fails the run, checked at the end, after the bounded fix loop
- * has had its chances.
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_build_test.js

@@ -1,67 +0,0 @@
-/**
- * ADW Build Test — implement, then verify; failures flow back into the builder.
- *
- * Usage:
- *   spf build-test "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> builder -> code(test) [-> builder(fix) -> code(test) ... bounded]
- *
- * Testing is CODE. The suite's command is written down in core/quality.ts,
- * so running it needs no judgement — only repairing it does. Failures reach the
- * builder as an envelope through `quality.asEnvelope`, which is the same door an
- * agent's report came through, so the repair loop is unchanged.
- *
- * A failing suite does NOT fail its phase: the runner did its job, the code is
- * what failed. It fails the run, checked at the end, after the bounded fix loop
- * has had its chances.
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as quality from "../core/quality.js";
-import * as session from "../core/session.js";
-import { BuildOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["builder"];
-export const REQUIRED_SUITES = ["test"];
-const MAX_FIX_LOOPS = 3;
-function record(ph, result) {
-    const passed = result.checks.filter((c) => c.passed).length;
-    ph.log({ passed: result.passed, checks: `${passed}/${result.checks.length}`, artifacts: result.artifacts.join(", ") });
-}
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    await run.phase(makePhaseParams({ name: "build", kind: "agent", owner: "builder", description: "Implement the request" }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, gates: [gates.diffMatchesClaims] })));
-    let test = null;
-    for (let i = 1; i <= MAX_FIX_LOOPS; i++) {
-        test = await run.phase(makePhaseParams({
-            name: `test_${i}`,
-            kind: "code",
-            owner: "quality",
-            description: "Run the suite — a known command, so code runs it and no agent has to rediscover it",
-        }), async (ph) => {
-            const result = quality.runTests(run);
-            record(ph, result);
-            return result;
-        });
-        if (test.passed)
-            break;
-        await run.phase(makePhaseParams({
-            name: `fix_${i}`,
-            kind: "agent",
-            owner: "builder",
-            retries: 1,
-            description: "Repair what the suite reported, from its verbatim output",
-        }), (ph) => ph.call(makeAgentCall({
-            output_type: BuildOutput,
-            prompt,
-            previous: quality.asEnvelope(test, "tests"),
-            gates: [gates.diffMatchesClaims],
-        })));
-    }
-    return run.finish(test !== null && test.passed, `the suite still failed after ${MAX_FIX_LOOPS} fix attempt(s)`);
-}

package/dist/chains/adw_document.d.ts

@@ -1,23 +0,0 @@
-/**
- * ADW Document — write up the work that was just done, from the diff.
- *
- * Usage:
- *   spf document "<prompt or path/to/prompt.md>" [--base main] [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> code(changes) -> documenter
- *
- * This runs AFTER a build, and the guard is structural rather than advisory: the
- * change capture is a code phase, and an empty diff raises there — before the
- * documenter is ever spawned. There is nothing to document until something was
- * built, and the phase says so instead of paying an agent to discover it.
- *
- * `git diff` against `--base` (main by default) is what "the latest changes"
- * means here; see core/changes.ts for how the base commit is resolved on a
- * branch, on main, and on a clean tree right after a chain committed.
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext, options?: {
-    base?: string;
-}): Promise<number>;

package/dist/chains/adw_document.js

@@ -1,59 +0,0 @@
-/**
- * ADW Document — write up the work that was just done, from the diff.
- *
- * Usage:
- *   spf document "<prompt or path/to/prompt.md>" [--base main] [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> code(changes) -> documenter
- *
- * This runs AFTER a build, and the guard is structural rather than advisory: the
- * change capture is a code phase, and an empty diff raises there — before the
- * documenter is ever spawned. There is nothing to document until something was
- * built, and the phase says so instead of paying an agent to discover it.
- *
- * `git diff` against `--base` (main by default) is what "the latest changes"
- * means here; see core/changes.ts for how the base commit is resolved on a
- * branch, on main, and on a clean tree right after a chain committed.
- */
-import * as agents from "../core/agents.js";
-import * as changes from "../core/changes.js";
-import * as gates from "../core/gates.js";
-import * as session from "../core/session.js";
-import { DocumentOutput, makeAgentCall, makeChangeCapture, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["documenter"];
-export const REQUIRED_SUITES = [];
-const DOCUMENT_NOTES = "Read diff_path in full before writing. Document only what the diff shows, then copy the write-up into app_docs/ as your task describes.";
-export async function main(ctx, options = {}) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const base = options.base ?? "main";
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    const changeset = await run.phase(makePhaseParams({ name: "changes", kind: "code", owner: "git", description: `Diff the working tree against ${base} — the change to be written up` }), async (ph) => {
-        const result = changes.capture(run, makeChangeCapture({ base }));
-        ph.log({
-            base: `${result.base.label} @ ${result.base.commit.slice(0, 7)}`,
-            reason: result.base.reason,
-            files: result.files.length + result.untracked.length,
-            lines: `+${result.insertions} -${result.deletions}`,
-            diff: result.diff_path,
-        });
-        if (result.empty) {
-            throw new Error(`nothing changed since ${result.base.label} (${result.base.reason}) — documenting runs after a build. ` +
-                `Build something first, or point --base at the ref the work should be measured from.`);
-        }
-        return result;
-    });
-    await run.phase(makePhaseParams({ name: "document", kind: "agent", owner: "documenter", retries: 1, description: "Turn the captured diff into a write-up an engineer can read" }), async (ph) => {
-        await ph.call(makeAgentCall({
-            output_type: DocumentOutput,
-            prompt,
-            previous: changes.asEnvelope(changeset, DOCUMENT_NOTES),
-            gates: [gates.artifactsExist, gates.filesNonEmpty],
-        }));
-    });
-    return run.finish();
-}

package/dist/chains/adw_plan.d.ts

@@ -1,12 +0,0 @@
-/**
- * ADW Plan — one-shot planning workflow.
- *
- * Usage:
- *   spf plan "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_plan.js

@@ -1,27 +0,0 @@
-/**
- * ADW Plan — one-shot planning workflow.
- *
- * Usage:
- *   spf plan "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as session from "../core/session.js";
-import { PlanOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["planner"];
-export const REQUIRED_SUITES = [];
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    await run.phase(makePhaseParams({ name: "plan", kind: "agent", owner: "planner", description: "Turn the request into an implementable plan" }), async (ph) => {
-        await ph.call(makeAgentCall({ output_type: PlanOutput, prompt, gates: [gates.artifactsExist, gates.filesNonEmpty] }));
-    });
-    return run.finish();
-}

package/dist/chains/adw_plan_build.d.ts

@@ -1,12 +0,0 @@
-/**
- * ADW Plan Build — two-agent chain: planner -> envelope -> builder.
- *
- * Usage:
- *   spf plan-build "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> git(commit)
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_plan_build.js

@@ -1,30 +0,0 @@
-/**
- * ADW Plan Build — two-agent chain: planner -> envelope -> builder.
- *
- * Usage:
- *   spf plan-build "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> git(commit)
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as session from "../core/session.js";
-import { BuildOutput, PlanOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["planner", "builder"];
-export const REQUIRED_SUITES = [];
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    const plan = await run.phase(makePhaseParams({ name: "plan", kind: "agent", owner: "planner", description: "Turn the request into an implementable plan" }), (ph) => ph.call(makeAgentCall({ output_type: PlanOutput, prompt, gates: [gates.artifactsExist, gates.filesNonEmpty] })));
-    const build = await run.phase(makePhaseParams({ name: "build", kind: "agent", owner: "builder", description: "Implement the plan exactly" }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: plan, gates: [gates.diffMatchesClaims] })));
-    await run.phase(makePhaseParams({ name: "commit", kind: "code", owner: "git", description: "Land the builder's changes, using the message it wrote" }), async (ph) => {
-        const message = build.commit_message || `spf(${run.adw_id}): ${build.summary}`;
-        ph.log({ sha: run.git.commitAll(message), message });
-    });
-    return run.finish();
-}

package/dist/chains/adw_plan_build_test.d.ts

@@ -1,16 +0,0 @@
-/**
- * ADW Plan Build Test — the full starter chain.
- *
- * Usage:
- *   spf plan-build-test "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> code(test) [-> builder(fix) -> code(test) ... bounded] -> git(commit)
- *
- * Testing is CODE: the suite's command lives in core/quality.ts, so no
- * agent spends a context window rediscovering it. Failures flow back to the
- * builder as an envelope, and only an exhausted fix loop fails the run.
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_plan_build_test.js

@@ -1,65 +0,0 @@
-/**
- * ADW Plan Build Test — the full starter chain.
- *
- * Usage:
- *   spf plan-build-test "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> code(test) [-> builder(fix) -> code(test) ... bounded] -> git(commit)
- *
- * Testing is CODE: the suite's command lives in core/quality.ts, so no
- * agent spends a context window rediscovering it. Failures flow back to the
- * builder as an envelope, and only an exhausted fix loop fails the run.
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as quality from "../core/quality.js";
-import * as session from "../core/session.js";
-import { BuildOutput, PlanOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["planner", "builder"];
-export const REQUIRED_SUITES = ["test"];
-const MAX_FIX_LOOPS = 3;
-function record(ph, result) {
-    const passed = result.checks.filter((c) => c.passed).length;
-    ph.log({ passed: result.passed, checks: `${passed}/${result.checks.length}`, artifacts: result.artifacts.join(", ") });
-}
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    const plan = await run.phase(makePhaseParams({ name: "plan", kind: "agent", owner: "planner", description: "Turn the request into an implementable plan" }), (ph) => ph.call(makeAgentCall({ output_type: PlanOutput, prompt, gates: [gates.artifactsExist, gates.filesNonEmpty] })));
-    let previous = await run.phase(makePhaseParams({ name: "build", kind: "agent", owner: "builder", description: "Implement the plan exactly" }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: plan, gates: [gates.artifactsExist] })));
-    let test = null;
-    for (let i = 1; i <= MAX_FIX_LOOPS; i++) {
-        test = await run.phase(makePhaseParams({
-            name: `test_${i}`,
-            kind: "code",
-            owner: "quality",
-            description: "Run the suite — a known command, so code runs it and no agent has to rediscover it",
-        }), async (ph) => {
-            const result = quality.runTests(run);
-            record(ph, result);
-            return result;
-        });
-        if (test.passed)
-            break;
-        previous = await run.phase(makePhaseParams({
-            name: `fix_${i}`,
-            kind: "agent",
-            owner: "builder",
-            retries: 1,
-            description: "Repair what the suite reported, from its verbatim output",
-        }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: quality.asEnvelope(test, "tests"), gates: [gates.artifactsExist] })));
-    }
-    // Only tested work gets committed — a red suite leaves the tree uncommitted.
-    if (test !== null && test.passed) {
-        await run.phase(makePhaseParams({ name: "commit", kind: "code", owner: "git", description: "Land the code only after the suite came back green" }), async (ph) => {
-            const message = previous.commit_message || `spf(${run.adw_id}): ${previous.summary}`;
-            ph.log({ sha: run.git.commitAll(message), message });
-        });
-    }
-    return run.finish(test !== null && test.passed, `the suite still failed after ${MAX_FIX_LOOPS} fix attempt(s)`);
-}

package/dist/chains/adw_plan_build_test_quality.d.ts

@@ -1,18 +0,0 @@
-/**
- * ADW Plan Build Test Quality — full agent chain plus deterministic quality.
- *
- * Usage:
- *   spf plan-build-test-quality "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> [code(verify) -> code(test) -> builder(fix)] bounded -> git(commit)
- *
- * Verify and test are CODE, not agents. Their commands are known, so running them
- * needs no judgement — only repairing them does. A failing block does not fail its
- * phase: the runner did its job, the code is what failed. The failure becomes an
- * envelope and flows back into the builder, and only an exhausted repair loop
- * fails the run.
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_plan_build_test_quality.js

@@ -1,66 +0,0 @@
-/**
- * ADW Plan Build Test Quality — full agent chain plus deterministic quality.
- *
- * Usage:
- *   spf plan-build-test-quality "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> planner -> builder -> [code(verify) -> code(test) -> builder(fix)] bounded -> git(commit)
- *
- * Verify and test are CODE, not agents. Their commands are known, so running them
- * needs no judgement — only repairing them does. A failing block does not fail its
- * phase: the runner did its job, the code is what failed. The failure becomes an
- * envelope and flows back into the builder, and only an exhausted repair loop
- * fails the run.
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as quality from "../core/quality.js";
-import * as session from "../core/session.js";
-import { BuildOutput, PlanOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["planner", "builder"];
-export const REQUIRED_SUITES = ["all"];
-const MAX_FIX_LOOPS = 3;
-function record(ph, result) {
-    const passed = result.checks.filter((c) => c.passed).length;
-    ph.log({ passed: result.passed, checks: `${passed}/${result.checks.length}`, artifacts: result.artifacts.join(", ") });
-}
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    const plan = await run.phase(makePhaseParams({ name: "plan", kind: "agent", owner: "planner", description: "Turn the request into an implementable plan" }), (ph) => ph.call(makeAgentCall({ output_type: PlanOutput, prompt, gates: [gates.artifactsExist, gates.filesNonEmpty] })));
-    let previous = await run.phase(makePhaseParams({ name: "build", kind: "agent", owner: "builder", description: "Implement the plan exactly" }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: plan, gates: [gates.diffMatchesClaims] })));
-    let testResult = null;
-    let qualityResult = null;
-    for (let i = 1; i <= MAX_FIX_LOOPS; i++) {
-        qualityResult = await run.phase(makePhaseParams({ name: `verify_${i}`, kind: "code", owner: "quality", description: "Lint, typecheck, and build before testing" }), async (ph) => {
-            const result = quality.runQuality(run);
-            record(ph, result);
-            return result;
-        });
-        // runQuality() already includes the test block; a repo that wants tests
-        // in their own phase can split them out the way this comment does.
-        testResult = qualityResult;
-        if (qualityResult.passed && testResult.passed)
-            break;
-        if (i === MAX_FIX_LOOPS)
-            break;
-        // Whichever block failed becomes the builder's spec — verbatim command
-        // output, no parser standing between the failure and the fix.
-        const broken = !qualityResult.passed ? qualityResult : testResult;
-        const what = !qualityResult.passed ? "verification" : "tests";
-        previous = await run.phase(makePhaseParams({ name: `fix_${i}`, kind: "agent", owner: "builder", retries: 1, description: `Resolve the reported ${what} failures` }), (ph) => ph.call(makeAgentCall({ output_type: BuildOutput, prompt, previous: quality.asEnvelope(broken, what), gates: [gates.diffMatchesClaims] })));
-    }
-    const verified = qualityResult !== null && qualityResult.passed && testResult !== null && testResult.passed;
-    if (verified) {
-        await run.phase(makePhaseParams({ name: "commit", kind: "code", owner: "git", description: "Commit the tested and quality-verified working tree" }), async (ph) => {
-            const message = previous.commit_message || `spf(${run.adw_id}): ${previous.summary}`;
-            ph.log({ sha: run.git.commitAll(message), message });
-        });
-    }
-    return run.finish(verified, `verify/test never came back clean after ${MAX_FIX_LOOPS} fix attempt(s)`);
-}

package/dist/chains/adw_prompt.d.ts

@@ -1,12 +0,0 @@
-/**
- * ADW Prompt — the smallest ADW: one agent, one prompt, traced end-to-end.
- *
- * Usage:
- *   spf prompt "<prompt or path/to/prompt.md>" [--agent builder] [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> <agent>
- */
-import type { ChainContext } from "./context.ts";
-export declare function main(ctx: ChainContext, options?: {
-    agent?: string;
-}): Promise<number>;

package/dist/chains/adw_prompt.js

@@ -1,25 +0,0 @@
-/**
- * ADW Prompt — the smallest ADW: one agent, one prompt, traced end-to-end.
- *
- * Usage:
- *   spf prompt "<prompt or path/to/prompt.md>" [--agent builder] [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> <agent>
- */
-import * as agents from "../core/agents.js";
-import * as session from "../core/session.js";
-import { GenericOutput, makeAgentCall, makePhaseParams } from "../core/data_types.js";
-export async function main(ctx, options = {}) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const agent = options.agent ?? "builder";
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, [agent], [], cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    await run.phase(makePhaseParams({ name: "prompt", kind: "agent", owner: agent, description: `Send the request straight to ${agent} and parse its envelope` }), async (ph) => {
-        await ph.call(makeAgentCall({ output_type: GenericOutput, prompt }));
-    });
-    return run.finish();
-}

package/dist/chains/adw_quality.d.ts

@@ -1,12 +0,0 @@
-/**
- * ADW Quality — lint, typecheck, and build the project.
- *
- * Usage:
- *   spf quality "<reason for the quality run>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> code(quality)
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_quality.js

@@ -1,32 +0,0 @@
-/**
- * ADW Quality — lint, typecheck, and build the project.
- *
- * Usage:
- *   spf quality "<reason for the quality run>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> code(quality)
- */
-import * as agents from "../core/agents.js";
-import * as quality from "../core/quality.js";
-import * as session from "../core/session.js";
-import { makePhaseParams } from "../core/data_types.js";
-export const REQUIRED_AGENTS = [];
-export const REQUIRED_SUITES = ["all"];
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture why quality verification was requested" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    await run.phase(makePhaseParams({ name: "quality", kind: "code", owner: "quality", description: "Run the deterministic quality blocks" }), async (ph) => {
-        const result = quality.runQuality(run);
-        const passed = result.checks.filter((c) => c.passed).length;
-        ph.log({ passed: result.passed, checks: `${passed}/${result.checks.length}`, artifacts: result.artifacts.join(", ") });
-        if (!result.passed) {
-            throw new Error("quality failed: " + result.failures.join("; "));
-        }
-    });
-    return run.finish();
-}

package/dist/chains/adw_scout.d.ts

@@ -1,12 +0,0 @@
-/**
- * ADW Scout — read-only recon workflow. Just looking for stuff.
- *
- * Usage:
- *   spf scout "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> scout
- */
-import type { ChainContext } from "./context.ts";
-export declare const REQUIRED_AGENTS: string[];
-export declare const REQUIRED_SUITES: string[];
-export declare function main(ctx: ChainContext): Promise<number>;

package/dist/chains/adw_scout.js

@@ -1,27 +0,0 @@
-/**
- * ADW Scout — read-only recon workflow. Just looking for stuff.
- *
- * Usage:
- *   spf scout "<prompt or path/to/prompt.md>" [--config <path>] [--adw-id a1b2c3d4]
- *
- * Phases: engineer(request) -> scout
- */
-import * as agents from "../core/agents.js";
-import * as gates from "../core/gates.js";
-import * as session from "../core/session.js";
-import { makeAgentCall, makePhaseParams, ScoutOutput } from "../core/data_types.js";
-export const REQUIRED_AGENTS = ["scout"];
-export const REQUIRED_SUITES = [];
-export async function main(ctx) {
-    const { prompt, config_paths, adw_id, cwd } = ctx;
-    const cfg = agents.loadConfig(config_paths);
-    agents.validate(cfg, REQUIRED_AGENTS, REQUIRED_SUITES, cwd);
-    const run = session.ensure(cfg, adw_id, cwd);
-    await run.phase(makePhaseParams({ name: "request", kind: "engineer", owner: run.engineer, description: "Capture the incoming ask" }), async (ph) => {
-        ph.log({ input: prompt });
-    });
-    await run.phase(makePhaseParams({ name: "scout", kind: "agent", owner: "scout", description: "Find and report where things live — change nothing" }), async (ph) => {
-        await ph.call(makeAgentCall({ output_type: ScoutOutput, prompt, gates: [gates.artifactsExist] }));
-    });
-    return run.finish();
-}