@petepetrash/circuit 0.1.0

package/dist/flows/composition/evaluate.js

@@ -0,0 +1,373 @@
+// Flow-shape composition (experimental, default-OFF): the eval predicates.
+//
+// These compute the locked rubric axes from the pre-registration
+// (docs/ideas/flow-composition-preregistration.md):
+//   - VALID    — run the composed spec through the SAME fail-closed path the
+//                engine runs (assemble → compile → catalog gate) and bind a
+//                primary result. Validity is the engine's verdict, never the
+//                harness's: this module only reports what the real gates do.
+//   - NOVEL    — the (block, executionKind) sequence is not any built-in's.
+//   - SENSIBLE — contract closure, intent closure, no orphan, goal-reaching.
+//
+// Pure analysis over the assembled schematic; no model spend. Used by the Phase
+// 0 make-or-break test and the Phase 1 breadth harness alike.
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { compileSchematicToCompiledFlow } from '../compile-schematic-to-flow.js';
+import { findCloseBuilder, resolveCloseReadPaths } from '../registries/close-writers/registry.js';
+import { findComposeBuilder, resolveComposeReadPaths, } from '../registries/compose-writers/registry.js';
+import { findVerificationWriter, resolveVerificationReadPaths, } from '../registries/verification-writers/registry.js';
+import { collectSchematicCatalogIssues } from '../schematic-catalog-check.js';
+import { blockIntent } from './intent.js';
+function asString(value) {
+    return value;
+}
+// A step's output is a READABLE contract — something a downstream step can read
+// as typed input — only when the step writes a report_path or a result_path.
+// This is the engine's own truth: the compiler's read-path resolution binds a
+// reader to a producer's report_path/result_path. A checkpoint that writes only
+// its request/response paths produces a routing decision, not a readable
+// contract; a checkpoint that ALSO writes a report_path (the shipping build
+// flow's frame-step does) produces a readable contract like any other step. So
+// the predicate keys on the WRITE, never on execution.kind.
+export function outputIsReadableContract(writes) {
+    if (writes === undefined)
+        return false;
+    return writes.report_path !== undefined || writes.result_path !== undefined;
+}
+export function blockSequence(schematic) {
+    return schematic.items.map((item) => ({
+        block: asString(item.block),
+        executionKind: item.execution.kind,
+    }));
+}
+function sequenceKey(sequence) {
+    return sequence.map((step) => `${step.block}:${step.executionKind}`).join(' > ');
+}
+function extractPrimaryResult(compiled) {
+    const flow = compiled.kind === 'single' ? compiled.flow : [...compiled.flows.values()][0];
+    const primary = flow?.runtime_surface?.primary_result;
+    if (primary === undefined)
+        return undefined;
+    return { schema: asString(primary.schema_name) };
+}
+// Run the real gates. VALID iff: assembly + compile both succeed, the catalog
+// gate returns zero issues, and the compiled flow binds a primary result.
+export function evaluateValidity(spec) {
+    let schematic;
+    try {
+        schematic = assembleFlowSchematic(spec);
+    }
+    catch (error) {
+        return {
+            valid: false,
+            catalogIssueCount: -1,
+            catalogIssues: [],
+            compiles: false,
+            boundPrimaryResult: false,
+            error: `assemble: ${errorMessage(error)}`,
+        };
+    }
+    const catalogIssues = collectSchematicCatalogIssues(schematic).map((issue) => issue.message);
+    let primary;
+    let compiles = true;
+    let compileError;
+    try {
+        primary = extractPrimaryResult(compileSchematicToCompiledFlow(schematic));
+    }
+    catch (error) {
+        compiles = false;
+        compileError = `compile: ${errorMessage(error)}`;
+    }
+    const valid = compiles && catalogIssues.length === 0 && primary !== undefined;
+    return {
+        valid,
+        catalogIssueCount: catalogIssues.length,
+        catalogIssues,
+        compiles,
+        boundPrimaryResult: primary !== undefined,
+        ...(primary === undefined ? {} : { primaryResultSchema: primary.schema }),
+        ...(compileError === undefined ? {} : { error: compileError }),
+        schematic,
+    };
+}
+// Present a compiled flow as the minimal runtime-index shape the read-path
+// resolvers consume. A compiled step already carries `reads: string[]` and
+// `writes.report: { path, schema }` — exactly what reportPathForSchemaInRuntimeFlow
+// and the compose/close resolvers read — so this is an identity on the fields that
+// matter. Keeping it here (a flows/ module) avoids importing the runtime/ adapter
+// chain (fromCompiledFlow + buildRuntimePackageIndex), which would invert the
+// engine boundary (runtime depends on flows, never the reverse). The FIDELITY test
+// in composition-runnability.test.ts pins this against the engine's real
+// CompiledFlow -> RuntimePackageIndex path so the shortcut cannot silently drift.
+function runtimeIndexShape(flow) {
+    return {
+        id: flow.id,
+        version: flow.version,
+        stages: [],
+        steps: flow.steps,
+    };
+}
+function reportSchemaOf(step) {
+    const report = step.writes.report;
+    if (typeof report !== 'object' || report === null)
+        return undefined;
+    return report;
+}
+// RUNNABLE — would the composed flow survive its compose/close writers, or abort
+// the instant one runs? evaluateValidity proves a spec is STRUCTURALLY sound
+// (assemble + compile + catalog + a bound primary result), but a compose or close
+// builder also declares REQUIRED upstream reads by family schema, and the runtime
+// aborts the step the moment a required read has no producer (the writer-coupling
+// wall). This runs the SAME resolvers the runtime uses — resolveComposeReadPaths /
+// resolveCloseReadPaths — against the compiled flow, offline, and reports every
+// step that would throw. Closing the false-negative the floor was blind to.
+//
+// SCOPE: compose and close writers declare their reads as static `reads`
+// descriptors, so they are inspectable without invocation. EVERY source-coupled
+// VERIFICATION writer now does too — each writer whose loadCommands sources its
+// command list from an upstream report (fix.verification reads fix.brief@v1;
+// build.verification reads build.plan@v1; prototype.verification reads
+// prototype.plan@v1 + artifact; pursuit.verification reads pursuit.contract@v1;
+// prototype.variant-verification reads the variant aggregate + provider evidence)
+// declares that source as a static `reads` descriptor, so all of them are resolved
+// here. That closes the blind spot a composed verification step hit when its source
+// went unwired (the live composed-arm abort), for every family the composer can
+// select, not just fix/build. A verification writer with NO source coupling
+// (explainer.verification — its commands are intrinsic) declares no `reads` and is
+// correctly skipped: there is nothing to resolve. The
+// verification-writer-source-coverage test locks that pairing so a future writer
+// cannot reintroduce the silent-skip gap.
+export function evaluateRunnability(spec) {
+    let schematic;
+    try {
+        schematic = assembleFlowSchematic(spec);
+    }
+    catch (error) {
+        return {
+            runnable: false,
+            aborts: [],
+            checkedSteps: 0,
+            error: `assemble: ${errorMessage(error)}`,
+        };
+    }
+    let compiled;
+    try {
+        compiled = compileSchematicToCompiledFlow(schematic);
+    }
+    catch (error) {
+        return {
+            runnable: false,
+            aborts: [],
+            checkedSteps: 0,
+            error: `compile: ${errorMessage(error)}`,
+        };
+    }
+    const flows = compiled.kind === 'single' ? [compiled.flow] : [...compiled.flows.values()];
+    const aborts = [];
+    let checkedSteps = 0;
+    for (const compiledFlow of flows) {
+        const flow = runtimeIndexShape(compiledFlow);
+        for (const step of flow.steps) {
+            const report = reportSchemaOf(step);
+            if (report === undefined)
+                continue;
+            const composeBuilder = findComposeBuilder(report.schema);
+            const closeBuilder = findCloseBuilder(report.schema);
+            const verificationBuilder = findVerificationWriter(report.schema);
+            // Relay writers are not in any of these registries. A verification writer
+            // that declares no `reads` (its imperative source coupling not modeled) is
+            // likewise skipped — there is nothing to resolve. Skip — not abort.
+            const verificationDeclaresReads = verificationBuilder !== undefined && verificationBuilder.reads !== undefined;
+            if (composeBuilder === undefined &&
+                closeBuilder === undefined &&
+                !verificationDeclaresReads) {
+                continue;
+            }
+            checkedSteps += 1;
+            try {
+                if (composeBuilder !== undefined) {
+                    resolveComposeReadPaths(composeBuilder, flow, step);
+                }
+                else if (closeBuilder !== undefined) {
+                    resolveCloseReadPaths(closeBuilder, flow, step);
+                }
+                else if (verificationBuilder !== undefined) {
+                    resolveVerificationReadPaths(verificationBuilder, flow, step);
+                }
+            }
+            catch (error) {
+                aborts.push({ stepId: step.id, schema: report.schema, reason: errorMessage(error) });
+            }
+        }
+    }
+    return { runnable: aborts.length === 0, aborts, checkedSteps };
+}
+function multiset(sequence) {
+    const counts = new Map();
+    for (const step of sequence) {
+        const key = `${step.block}:${step.executionKind}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
+function jaccard(a, b) {
+    const keys = new Set([...a.keys(), ...b.keys()]);
+    let intersection = 0;
+    let union = 0;
+    for (const key of keys) {
+        const av = a.get(key) ?? 0;
+        const bv = b.get(key) ?? 0;
+        intersection += Math.min(av, bv);
+        union += Math.max(av, bv);
+    }
+    return union === 0 ? 0 : intersection / union;
+}
+// NOVEL iff the composed (block, executionKind) sequence equals no built-in's.
+export function evaluateNovelty(schematic, definitions) {
+    const sequence = blockSequence(schematic);
+    const key = sequenceKey(sequence);
+    const composedMultiset = multiset(sequence);
+    let matches;
+    let closest;
+    for (const definition of definitions) {
+        if (definition.id === asString(schematic.id))
+            continue;
+        const builtinSequence = blockSequence(definition.schematic);
+        if (sequenceKey(builtinSequence) === key)
+            matches = definition.id;
+        const score = jaccard(composedMultiset, multiset(builtinSequence));
+        if (closest === undefined || score > closest.jaccard) {
+            closest = { flowId: definition.id, jaccard: score };
+        }
+    }
+    return {
+        novel: matches === undefined,
+        sequence: key,
+        ...(matches === undefined ? {} : { matches }),
+        ...(closest === undefined ? {} : { closest }),
+    };
+}
+// Read the route graph of an assembled schematic. A route target is a graph
+// edge unless it is a terminal ('@complete', '@stop', '@handoff', ...). An edge
+// to a step at index <= the producer's is a back-edge (loop); a step with two or
+// more distinct forward edges is a branch point. The signature folds the block
+// sequence together with the loops and branches so topology-distinct flows are
+// distinguishable.
+export function evaluateTopology(schematic) {
+    const items = schematic.items;
+    const indexById = new Map();
+    items.forEach((item, i) => indexById.set(asString(item.id), i));
+    const blockByIndex = items.map((item) => asString(item.block));
+    const backEdges = [];
+    const branchPoints = [];
+    items.forEach((item, i) => {
+        const forwardTargets = new Set();
+        for (const [route, target] of Object.entries(item.routes)) {
+            const t = asString(target);
+            if (t.startsWith('@'))
+                continue; // terminal sink, not a graph edge
+            const j = indexById.get(t);
+            if (j === undefined)
+                continue; // unresolved id — the compiler gate owns this
+            if (j <= i)
+                backEdges.push({ from: asString(item.id), to: t, route });
+            else
+                forwardTargets.add(j);
+        }
+        if (forwardTargets.size >= 2) {
+            branchPoints.push({ step: asString(item.id), forwardTargets: forwardTargets.size });
+        }
+    });
+    const blockOf = (id) => blockByIndex[indexById.get(id) ?? -1] ?? id;
+    const seqSig = items.map((item) => `${asString(item.block)}:${item.execution.kind}`).join('>');
+    const loopSig = backEdges
+        .map((edge) => `${blockOf(edge.from)}-${edge.route}->${blockOf(edge.to)}`)
+        .sort()
+        .join(',');
+    const branchSig = branchPoints
+        .map((branch) => `${blockOf(branch.step)}*${branch.forwardTargets}`)
+        .sort()
+        .join(',');
+    const signature = `seq:[${seqSig}]|loops:[${loopSig}]|branches:[${branchSig}]`;
+    return {
+        stepCount: items.length,
+        backEdges,
+        branchPoints,
+        hasLoop: backEdges.length > 0,
+        hasBranch: branchPoints.length > 0,
+        signature,
+    };
+}
+// SENSIBLE iff all four sub-checks hold over the assembled schematic.
+export function evaluateSensibility(schematic, options) {
+    const failures = [];
+    const initialContracts = new Set(schematic.initial_contracts.map(asString));
+    // Contract closure: every input actual is produced by an earlier step or is
+    // an initial contract.
+    const producedSoFar = new Set();
+    let contractClosure = true;
+    for (const item of schematic.items) {
+        for (const value of Object.values(item.input)) {
+            const contract = asString(value);
+            if (!producedSoFar.has(contract) && !initialContracts.has(contract)) {
+                contractClosure = false;
+                failures.push(`contract closure: step '${asString(item.id)}' reads '${contract}' with no upstream producer or initial contract`);
+            }
+        }
+        producedSoFar.add(asString(item.output));
+    }
+    // Intent closure: every block's semantic preconditions are established by an
+    // upstream block's postconditions (or hold initially).
+    const established = new Set();
+    let intentClosure = true;
+    for (const item of schematic.items) {
+        const intent = blockIntent(item.block);
+        if (intent === undefined) {
+            intentClosure = false;
+            failures.push(`intent closure: block '${asString(item.block)}' has no declared intent`);
+            continue;
+        }
+        for (const pre of intent.precondition) {
+            if (!established.has(pre)) {
+                intentClosure = false;
+                failures.push(`intent closure: step '${asString(item.id)}' (${asString(item.block)}) needs '${pre}' which no upstream block establishes`);
+            }
+        }
+        for (const post of intent.postcondition)
+            established.add(post);
+    }
+    // No orphan: every step's output is consumed downstream, except a terminal
+    // close step's result.
+    const consumed = new Set();
+    for (const item of schematic.items) {
+        for (const value of Object.values(item.input))
+            consumed.add(asString(value));
+    }
+    let noOrphan = true;
+    schematic.items.forEach((item, index) => {
+        const output = asString(item.output);
+        const isLast = index === schematic.items.length - 1;
+        const reachesComplete = Object.values(item.routes).some((target) => asString(target) === '@complete');
+        // Only a readable output can be consumed as a typed contract downstream, so
+        // only a readable output can be an orphan. A step that writes no readable
+        // contract — e.g. a checkpoint that writes only its request/response paths,
+        // whose decision the engine consumes structurally by picking a route —
+        // produces nothing to orphan. A checkpoint that ALSO writes a report_path
+        // (build's frame-step does) IS readable and must be consumed or terminal.
+        // Key on the readable write, not the execution kind.
+        const readable = outputIsReadableContract(item.writes);
+        if (readable && !consumed.has(output) && !(isLast || reachesComplete)) {
+            noOrphan = false;
+            failures.push(`no orphan: step '${asString(item.id)}' output '${output}' is never consumed and is not a terminal`);
+        }
+    });
+    const goalReaching = options.boundPrimaryResult;
+    if (!goalReaching)
+        failures.push('goal-reaching: no bound primary_result');
+    const sensible = contractClosure && intentClosure && noOrphan && goalReaching;
+    return { sensible, contractClosure, intentClosure, noOrphan, goalReaching, failures };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/flows/composition/evaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.js","sourceRoot":"","sources":["../../../src/flows/composition/evaluate.ts"],"names":[],"mappings":"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"}

package/dist/flows/composition/index.d.ts

@@ -0,0 +1,8 @@
+export { composeFlow, keyFor, RESEARCH_THEN_BUILD, GOAL_THEN_FIX, GOAL_CLARIFY_THEN_FIX, FANOUT_PARALLEL_BUILD, BUILD_LINEAR_FULL, type CompositionRole, type CompositionRoleSet, type CompositionWall, type ComposeOutcome, type ComposedSelection, type ConvergeUntilSpec, type FanoutBranchRole, type RelayRole, } from './composer.js';
+export { deriveActualMenu, entryIsRegisteredFor, type MenuEntry, type ExecutionKind, } from './actual-menu.js';
+export { evaluateValidity, evaluateRunnability, evaluateNovelty, evaluateSensibility, evaluateTopology, blockSequence, outputIsReadableContract, type ValidityVerdict, type RunnabilityVerdict, type RunnabilityAbort, type NoveltyVerdict, type SensibilityVerdict, type TopologyVerdict, type TopologyBackEdge, type TopologyBranch, type SequenceStep, } from './evaluate.js';
+export { BLOCK_INTENT, blockIntent, type BlockIntent, type IntentState } from './intent.js';
+export { proposeFlow, type ProposeOptions, type ProposeOutcome, type ProposeRound, type ProposeStage, } from './propose.js';
+export { PROPOSER_PROMPT, REPAIR_GUIDANCE } from './propose-prompts.js';
+export { EQUIPMENT_PROFILES, EQUIPMENT_PROFILE_IDS, EquipmentProfileId, isEquipmentProfileId, profileToScope, renderEquipmentProfileMenu, } from './equipment-profiles.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/flows/composition/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flows/composition/index.ts"],"names":[],"mappings":"AASA,OAAO,EACL,WAAW,EACX,MAAM,EACN,mBAAmB,EACnB,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,SAAS,GACf,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,SAAS,EACd,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,wBAAwB,EACxB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,YAAY,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5F,OAAO,EACL,WAAW,EACX,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC"}

package/dist/flows/composition/index.js

@@ -0,0 +1,16 @@
+// Flow-shape composition (experimental, default-OFF).
+//
+// Public surface of the composer. Importing this module is inert: nothing here
+// runs unless a caller invokes composeFlow. The stable task-aware assembler and
+// the eight built-ins do not import it, so their compiled output is unaffected
+// (proven by the equivalence + drift tests). Integration behind the experimental
+// flag wires it into the assembler; until then it is reachable only from the
+// eval harness and tests.
+export { composeFlow, keyFor, RESEARCH_THEN_BUILD, GOAL_THEN_FIX, GOAL_CLARIFY_THEN_FIX, FANOUT_PARALLEL_BUILD, BUILD_LINEAR_FULL, } from './composer.js';
+export { deriveActualMenu, entryIsRegisteredFor, } from './actual-menu.js';
+export { evaluateValidity, evaluateRunnability, evaluateNovelty, evaluateSensibility, evaluateTopology, blockSequence, outputIsReadableContract, } from './evaluate.js';
+export { BLOCK_INTENT, blockIntent } from './intent.js';
+export { proposeFlow, } from './propose.js';
+export { PROPOSER_PROMPT, REPAIR_GUIDANCE } from './propose-prompts.js';
+export { EQUIPMENT_PROFILES, EQUIPMENT_PROFILE_IDS, EquipmentProfileId, isEquipmentProfileId, profileToScope, renderEquipmentProfileMenu, } from './equipment-profiles.js';
+//# sourceMappingURL=index.js.map

package/dist/flows/composition/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/flows/composition/index.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,+EAA+E;AAC/E,iFAAiF;AACjF,6EAA6E;AAC7E,0BAA0B;AAE1B,OAAO,EACL,WAAW,EACX,MAAM,EACN,mBAAmB,EACnB,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,GASlB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GAGrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,aAAa,EACb,wBAAwB,GAUzB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAsC,MAAM,aAAa,CAAC;AAC5F,OAAO,EACL,WAAW,GAKZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC"}

package/dist/flows/composition/intent.d.ts

@@ -0,0 +1,10 @@
+import type { FlowBlockId } from '../../schemas/flow-blocks.js';
+export type IntentState = 'task-framed' | 'context-gathered' | 'diagnosed' | 'plan-formed' | 'change-made' | 'change-verified' | 'change-reviewed' | 'decision-made' | 'result-emitted';
+export interface BlockIntent {
+    readonly role: string;
+    readonly precondition: readonly IntentState[];
+    readonly postcondition: readonly IntentState[];
+}
+export declare const BLOCK_INTENT: Partial<Record<FlowBlockId, BlockIntent>>;
+export declare function blockIntent(blockId: FlowBlockId): BlockIntent | undefined;
+//# sourceMappingURL=intent.d.ts.map

package/dist/flows/composition/intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../../src/flows/composition/intent.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAKhE,MAAM,MAAM,WAAW,GACnB,aAAa,GACb,kBAAkB,GAClB,WAAW,GACX,aAAa,GACb,aAAa,GACb,iBAAiB,GACjB,iBAAiB,GACjB,eAAe,GACf,gBAAgB,CAAC;AAErB,MAAM,WAAW,WAAW;IAE1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAC;IAE9C,QAAQ,CAAC,aAAa,EAAE,SAAS,WAAW,EAAE,CAAC;CAChD;AAMD,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAoGlE,CAAC;AAEF,wBAAgB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAEzE"}

package/dist/flows/composition/intent.js

@@ -0,0 +1,125 @@
+// Flow-shape composition (experimental, default-OFF): per-block INTENT.
+//
+// The block catalog (FLOW_BLOCK_DEFINITIONS) describes each block's CONTRACT
+// surface — the typed inputs it reads and the output it produces. That is
+// enough for the fail-closed gates to prove a flow is wire-valid, but it is not
+// enough to prove the flow MAKES SENSE: contracts can close while the intents
+// behind them do not belong in that order (e.g. a review before any change
+// exists). This module adds the missing layer — a small, additive,
+// catalog-independent map of each block's semantic PRE/POST-conditions, stated
+// as state tokens rather than contracts. It is read only by the experimental
+// composer + its sensibility checker; the eight built-ins and the block catalog
+// are untouched, so nothing here can change a shipped flow.
+//
+// The tokens are a deliberately tiny controlled vocabulary describing the
+// research-then-build family the Phase 0 milestone targets. Phase 1 broadens
+// the vocabulary as it broadens block coverage.
+// Phase 0 enrichment: the blocks the research-then-build milestone composes,
+// plus the close-adjacent blocks needed to terminate a flow. Each entry is
+// additive metadata; none of it is consulted by the stable assembler or the
+// gates.
+export const BLOCK_INTENT = {
+    frame: {
+        role: 'Capture the task boundary as a brief',
+        precondition: [],
+        postcondition: ['task-framed'],
+    },
+    'review-intake': {
+        role: 'Capture the review scope as a brief',
+        precondition: [],
+        postcondition: ['task-framed'],
+    },
+    clarify: {
+        // The frame analog for an ambiguous ask: clarify reads the raw operator
+        // intake (catalog input task.intake@v1 — no prior brief) and turns it into a
+        // precise task, so its precondition is empty and it establishes the same
+        // 'task-framed' state `frame` and `goal` do. A flow that opens with clarify
+        // (a vague bug report) instead of frame therefore still closes its intent.
+        role: 'Clarify an ambiguous request into a precise task',
+        precondition: [],
+        postcondition: ['task-framed'],
+    },
+    'gather-context': {
+        role: 'Collect the code and context the task touches',
+        precondition: ['task-framed'],
+        postcondition: ['context-gathered'],
+    },
+    diagnose: {
+        role: 'Find the root cause / analyze the problem',
+        precondition: ['task-framed'],
+        postcondition: ['diagnosed'],
+    },
+    plan: {
+        role: 'Form a strategy before acting',
+        precondition: ['task-framed'],
+        postcondition: ['plan-formed'],
+    },
+    act: {
+        role: 'Make the implementation change',
+        precondition: ['task-framed'],
+        postcondition: ['change-made'],
+    },
+    'run-verification': {
+        // Precondition is 'task-framed', NOT 'change-made': the catalog uses
+        // run-verification both AFTER a change (fix/build verify steps) and BEFORE
+        // one (build-baseline captures a pre-change snapshot; a gather-then-verify
+        // flow checks the existing suite). 'change-made' would be a false universal.
+        // The post-change ordering, where it applies, is carried by the CONTRACT
+        // layer instead: a verification that means to check a change reads
+        // change.evidence, which only an upstream act produces.
+        role: 'Run verification — of a change just made, or of the existing state',
+        precondition: ['task-framed'],
+        postcondition: ['change-verified'],
+    },
+    review: {
+        // Precondition is 'task-framed', NOT 'change-made': the built-in `review`
+        // flow audits pre-existing code (frame -> review -> close) with no in-flow
+        // change at all. Requiring 'change-made' would reject that real pattern.
+        // When a review means to audit a change, its CONTRACT (reads change.evidence
+        // + verification.result) ties it to the upstream act, not its intent.
+        role: 'Independently audit a change, or the existing code',
+        precondition: ['task-framed'],
+        postcondition: ['change-reviewed'],
+    },
+    'human-decision': {
+        role: 'Pause for an operator go/no-go',
+        precondition: ['task-framed'],
+        postcondition: ['decision-made'],
+    },
+    goal: {
+        // The sub-run analog of `frame`: instead of a brief, it captures the task as
+        // a goal CONTRACT a child flow can be delegated against. It establishes the
+        // same 'task-framed' state `frame` does, so a downstream close/verify/review
+        // precondition is satisfied whether the flow opened with a brief or a goal.
+        role: 'Capture the task as a goal contract for delegation',
+        precondition: [],
+        postcondition: ['task-framed'],
+    },
+    'goal-child-run': {
+        // Delegates the whole task to a child flow and is admitted back only through
+        // the child's result verdict. It needs the goal framed (the contract the
+        // delegation rides on) but establishes no UNIVERSAL downstream state: the
+        // child may fix (change made + verified), build, explore (no change), or
+        // review, so claiming any one post-state would be a false universal — the same
+        // reasoning that keeps run-verification/review preconditions minimal. What the
+        // child produced is carried by the CONTRACT layer (its result_path), which the
+        // terminal close consumes, not by an intent token.
+        role: 'Delegate the task to a child flow and admit its verdict',
+        precondition: ['task-framed'],
+        postcondition: [],
+    },
+    'close-with-evidence': {
+        role: 'Compose the terminal result with evidence',
+        precondition: ['task-framed'],
+        postcondition: ['result-emitted'],
+    },
+    handoff: {
+        role: 'Persist a handoff for a later session',
+        precondition: ['task-framed'],
+        postcondition: ['result-emitted'],
+    },
+};
+export function blockIntent(blockId) {
+    return BLOCK_INTENT[blockId];
+}
+//# sourceMappingURL=intent.js.map

package/dist/flows/composition/intent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent.js","sourceRoot":"","sources":["../../../src/flows/composition/intent.ts"],"names":[],"mappings":"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"}

package/dist/flows/composition/propose-prompts.d.ts

@@ -0,0 +1,3 @@
+export declare const PROPOSER_PROMPT = "# Flow proposer \u2014 turn a task into a flow shape\n\nYou are designing a **developer workflow** for one specific task. A workflow is an\nordered list of **steps**. Each step runs one **block** (a unit of work) in one\n**execution kind**. The engine runs your steps in order, threading each step's\noutput to later steps, and closes with a result.\n\nYour job: read the TASK, then emit a JSON **role set** \u2014 the ordered list of steps\nthat best fits this task. Pick the shape the task actually needs. Do not pad.\n\n## The block menu (this is the whole vocabulary \u2014 you may only use these)\n\nEach entry is `block / executionKind` and what it is for. Stages run in this order:\n**frame \u2192 analyze \u2192 plan \u2192 act \u2192 verify \u2192 review \u2192 close**. A step's `stage` must\nbe one of these and steps must be in stage order (a stage may repeat or be skipped,\nbut never go backwards).\n\n**frame (open the flow \u2014 pick exactly one opener):**\n- `frame / compose` \u2014 state the task and success criteria (the standard opener).\n- `frame / checkpoint` \u2014 same, but pause for an operator OK before proceeding (use when the work is expensive or risky to start).\n- `review-intake / compose` \u2014 opener for an **audit-only** task (no code change).\n- `goal / compose` \u2014 opener for a **supervisor** task that will delegate to a whole child flow.\n\n**analyze (understand before acting):**\n- `gather-context / relay` (relayRole: `researcher`) \u2014 a worker collects the relevant code/context.\n- `diagnose / relay` (relayRole: `researcher`) \u2014 a worker roots-causes the problem.\n- `diagnose / compose` \u2014 model-only analysis (use when no worker delegation is needed, e.g. a research/decision task).\n\n**plan (decide the approach \u2014 optional):**\n- `plan / compose` \u2014 write the approach/strategy before acting.\n\n**act (do the work \u2014 pick what fits):**\n- `act / relay` (relayRole: `implementer`) \u2014 a worker makes the change (the standard \"do it\" step).\n- `act / fanout` \u2014 run **2+ child flows in parallel** as competing candidates, then keep the survivors. Requires `fanoutBranches: [{branchId, flowId, goalText}, ...]` with \u22652 branches. Use for \"compare N approaches / generate variants.\"\n- `goal-child-run / sub-run` \u2014 run **one entire child flow** as this step. Requires `flowId` (one of `fix|build|review|explore|pursue`) and `goalText`. Use when a sub-task is itself a whole flow (supervisor/delegation).\n\n**verify (prove it works):**\n- `run-verification / verification` \u2014 run the checks/tests. Add `loopBackTo: \"act\"` to **retry the change** when verification fails (a bounded recovery loop). Use the loop when failure is likely and worth re-attempting.\n\n**review (independent second look \u2014 optional):**\n- `review / relay` (relayRole: `reviewer`) \u2014 a different worker reviews the change before close.\n\n**close (terminate \u2014 pick exactly one, mark it `terminal: true`):**\n- `close-with-evidence / compose` \u2014 close with a result + evidence (the standard close for most flows).\n- `goal-close / compose` \u2014 close for a `goal`-opened supervisor flow.\n\n## The four shapes you can build\n\n1. **Linear** \u2014 frame \u2192 analyze \u2192 act \u2192 verify \u2192 close. The default. Most tasks are this.\n2. **Loop** \u2014 a linear flow whose verify step has `loopBackTo: \"act\"` so a failed verification retries the change. Use when verification is likely to fail and retrying helps.\n3. **Fanout** \u2014 an `act / fanout` step running 2+ competing child flows in parallel. Use for \"compare/try N approaches.\"\n4. **Sub-run** \u2014 a `goal-child-run / sub-run` step running a whole child flow. Use when a sub-task is itself a full flow (delegation/supervision).\n\n## House patterns (lean toward these)\n\n- Default to the linear spine; only add steps the task needs. A 5\u20136 step linear flow is normal; a 2-step flow is almost always too thin.\n- frame/plan/close \u2192 `compose`; analyze/act \u2192 `relay` (researcher then implementer); verify \u2192 `verification`; review \u2192 `relay` reviewer.\n- Always end at a `close` step marked `terminal: true`.\n- Reach for loop / fanout / sub-run ONLY when the task shape calls for it. Picking the right shape matters more than using a fancy one.\n\n## Equipment (optional \u2014 scope each worker step's tools)\n\nBy default every step's worker gets the full tool surface. You may give a worker\nstep (analyze / act / verify) a tighter scope with an `equipment` field, so the\nstep is steered toward the tools its job needs. The scope is offered to the worker\nas guidance, not a hard limit. Pick ONE profile per step from this closed list, or\nomit `equipment` to keep the full surface:\n\n- `read-only` \u2014 read, search, and list files; no edits or commands. For steps that investigate or gather context.\n- `editor` \u2014 read, search, and edit or write files; no shell commands. For steps that change code or docs.\n- `tester` \u2014 read, search, and run commands like tests and builds; no file edits. For steps that verify.\n- `full` \u2014 the full tool surface (the default): read, edit, and run commands. For steps that need everything.\n\nFit the profile to the step: `read-only` for `gather-context`/`diagnose`, `editor`\nfor `act`, `tester` for `run-verification`. Leave it off when a step truly needs\neverything.\n\n## Output format\n\nEmit ONLY this JSON (no prose, no markdown fence), filling in the roles:\n\n```\n{\n  \"id\": \"kebab-case-id\",\n  \"title\": \"Short title\",\n  \"purpose\": \"One sentence: what this flow does for the task.\",\n  \"roles\": [\n    { \"stage\": \"frame\", \"block\": \"frame\", \"executionKind\": \"compose\" },\n    { \"stage\": \"analyze\", \"block\": \"gather-context\", \"executionKind\": \"relay\", \"relayRole\": \"researcher\", \"equipment\": \"read-only\" },\n    { \"stage\": \"act\", \"block\": \"act\", \"executionKind\": \"relay\", \"relayRole\": \"implementer\", \"equipment\": \"editor\" },\n    { \"stage\": \"verify\", \"block\": \"run-verification\", \"executionKind\": \"verification\", \"equipment\": \"tester\" },\n    { \"stage\": \"close\", \"block\": \"close-with-evidence\", \"executionKind\": \"compose\", \"terminal\": true }\n  ]\n}\n```\n\nPer-role fields: `stage`, `block`, `executionKind` always; add `relayRole` for relay\nsteps; `loopBackTo` to make a verify step retry; `flowId`+`goalText` for a sub-run;\n`fanoutBranches` for a fanout; `terminal: true` on the close step; `equipment`\n(read-only | editor | tester | full) to scope a worker step's tools.\n\n## Common mistakes to avoid\n\n- Use ONLY the exact block ids and execution kinds from the menu above. The close\n  block is `close-with-evidence`, not `close`. `run-verification` runs as\n  `verification`, not `relay`. Every `stage` must be one of: frame, analyze, plan,\n  act, verify, review, close.\n\nOutput ONLY the JSON object for the TASK below. No explanation.\n";
+export declare const REPAIR_GUIDANCE = "# Repairing a rejected flow\n\nA verifier checked the flow you proposed and REJECTED it. The cause is specific:\nit might be a step whose required input no earlier step produces, OR a step that\nuses a name outside the allowed vocabulary (a wrong stage, block id, or execution\nkind). Read the verifier's exact error, match it to a rule below, and change only\nwhat the error names. Revise your role set so it passes.\n\nYou will be given: the original task, the flow you proposed, and the verifier's\nexact error(s). Read the error and apply the matching rule below.\n\n## Error \u2192 fix\n\n- **\"expected exactly one report writer for schema 'X.brief@v1'\" or \"'X.intake@v1'\", found 0**\n  A step you chose is tied to a specific family (\"X\") and needs that family's\n  opening report, which your flow does not produce. Usually the culprit is an\n  optional step. Fixes, in order of preference:\n  1. Remove the step that triggers it. `plan` and model-only `diagnose / compose`\n     analyze steps are OPTIONAL \u2014 drop them for a leaner flow.\n  2. If you truly need that step, open the flow with the matching opener.\n\n- **\"no input set satisfiable ... needs one of [flow.brief@v1, diagnosis.result@v1] OR [flow.brief@v1, plan.strategy@v1]\"** (on an `act` step)\n  Your `act` step has nothing to act on. Put a `diagnose` (relay, researcher)\n  step OR a `plan` (compose) step BEFORE the `act` step, so the implementer has a\n  diagnosis or a plan to work from.\n\n- **\"no input set satisfiable ... needs one of [goal.contract@v1]\"** (on a `goal-child-run` step)\n  A sub-run step requires the supervisor opener. Use `goal / compose` as your\n  `frame` step whenever you use one or more `goal-child-run` sub-run steps.\n\n- **\"run-verification ... requires reading 'prototype.variant-aggregate@v1'\"** (after a fanout)\n  After an `act / fanout` step, a separate `run-verification` step is tied to the\n  fanout's internals and will not bind. For a fanout flow, do NOT add a\n  `run-verification` step \u2014 go from the `act / fanout` step to a `review` step\n  (relay, reviewer) and then `close`. The fanout's branches verify themselves.\n\n- **\"Invalid option: expected one of ...\" (naming the stage names)**\n  A step's `stage` is not one of the seven allowed stages. Set every step's `stage`\n  to one of, and keep them in this order: frame, analyze, plan, act, verify,\n  review, close.\n\n- **\"... unknown block id\"**\n  A step's `block` is not in the menu. Use only these exact block ids: frame,\n  review-intake, goal, gather-context, diagnose, plan, act, run-verification,\n  review, close-with-evidence, goal-close, goal-child-run. Do not invent a block \u2014\n  the close block is `close-with-evidence`, not `close`.\n\n- **\"equipment profile 'X' is not in the allowed set [...]\"**\n  A step's `equipment` names a profile that does not exist. Use exactly one of:\n  `read-only`, `editor`, `tester`, `full` \u2014 or remove the `equipment` field to\n  leave that step at the full tool surface.\n\n- **\"no registered actual for <block>/<kind> ...\"**\n  The block is real but paired with the wrong execution kind. The fixed kinds are:\n  frame \u2192 compose or checkpoint; plan \u2192 compose; gather-context, act, and review \u2192\n  relay; diagnose \u2192 relay or compose; run-verification \u2192 verification (NOT relay);\n  close-with-evidence and goal-close \u2192 compose; goal-child-run \u2192 sub-run; a parallel\n  act \u2192 fanout. Set this step's `executionKind` to the one its block supports.\n\n## General principles\n\n- A runnable flow keeps its steps in ONE coherent family wherever possible. The\n  cleanest runnable shapes are: frame \u2192 (gather-context) \u2192 diagnose \u2192 act \u2192\n  run-verification \u2192 close, optionally with `loopBackTo: \"act\"` on verify.\n- Leaner is safer. If a step is optional and triggers an error, remove it.\n- Always end at a `close` step marked `terminal: true`.\n\nOutput ONLY the revised JSON role set (same format as before). No prose.\n";
+//# sourceMappingURL=propose-prompts.d.ts.map

package/dist/flows/composition/propose-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propose-prompts.d.ts","sourceRoot":"","sources":["../../../src/flows/composition/propose-prompts.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,eAAe,42NA6G3B,CAAC;AAEF,eAAO,MAAM,eAAe,+8HAoE3B,CAAC"}