@petepetrash/circuit 0.1.0

package/dist/flows/composition/propose-prompts.js

@@ -0,0 +1,196 @@
+// Flow-shape composition (experimental, default-OFF): the proposer prompts.
+//
+// These two constants are the EXACT bytes of the method artifacts that were
+// validated by the proposer spike:
+//   experiments/flow-lab/_proposer-prompt.md  -> PROPOSER_PROMPT
+//   experiments/flow-lab/_repair-guidance.md  -> REPAIR_GUIDANCE
+//
+// They are inlined here (not read from disk) on purpose: propose.ts ships in the
+// built package under dist/, and `tsc` does not copy .md files, so a runtime
+// fs read would fail in the installed plugin. Importing this module is inert —
+// it only defines two strings.
+//
+// A byte-equality test (tests/contracts/composition-propose.test.ts) pins these
+// constants to the .md files, so any future edit to a prompt that is not mirrored
+// here fails CI. The .md file stays the human-readable canonical copy; this is the
+// shippable mirror.
+export const PROPOSER_PROMPT = `# Flow proposer — turn a task into a flow shape
+
+You are designing a **developer workflow** for one specific task. A workflow is an
+ordered list of **steps**. Each step runs one **block** (a unit of work) in one
+**execution kind**. The engine runs your steps in order, threading each step's
+output to later steps, and closes with a result.
+
+Your job: read the TASK, then emit a JSON **role set** — the ordered list of steps
+that best fits this task. Pick the shape the task actually needs. Do not pad.
+
+## The block menu (this is the whole vocabulary — you may only use these)
+
+Each entry is \`block / executionKind\` and what it is for. Stages run in this order:
+**frame → analyze → plan → act → verify → review → close**. A step's \`stage\` must
+be one of these and steps must be in stage order (a stage may repeat or be skipped,
+but never go backwards).
+
+**frame (open the flow — pick exactly one opener):**
+- \`frame / compose\` — state the task and success criteria (the standard opener).
+- \`frame / checkpoint\` — same, but pause for an operator OK before proceeding (use when the work is expensive or risky to start).
+- \`review-intake / compose\` — opener for an **audit-only** task (no code change).
+- \`goal / compose\` — opener for a **supervisor** task that will delegate to a whole child flow.
+
+**analyze (understand before acting):**
+- \`gather-context / relay\` (relayRole: \`researcher\`) — a worker collects the relevant code/context.
+- \`diagnose / relay\` (relayRole: \`researcher\`) — a worker roots-causes the problem.
+- \`diagnose / compose\` — model-only analysis (use when no worker delegation is needed, e.g. a research/decision task).
+
+**plan (decide the approach — optional):**
+- \`plan / compose\` — write the approach/strategy before acting.
+
+**act (do the work — pick what fits):**
+- \`act / relay\` (relayRole: \`implementer\`) — a worker makes the change (the standard "do it" step).
+- \`act / fanout\` — run **2+ child flows in parallel** as competing candidates, then keep the survivors. Requires \`fanoutBranches: [{branchId, flowId, goalText}, ...]\` with ≥2 branches. Use for "compare N approaches / generate variants."
+- \`goal-child-run / sub-run\` — 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).
+
+**verify (prove it works):**
+- \`run-verification / verification\` — 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.
+
+**review (independent second look — optional):**
+- \`review / relay\` (relayRole: \`reviewer\`) — a different worker reviews the change before close.
+
+**close (terminate — pick exactly one, mark it \`terminal: true\`):**
+- \`close-with-evidence / compose\` — close with a result + evidence (the standard close for most flows).
+- \`goal-close / compose\` — close for a \`goal\`-opened supervisor flow.
+
+## The four shapes you can build
+
+1. **Linear** — frame → analyze → act → verify → close. The default. Most tasks are this.
+2. **Loop** — 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.
+3. **Fanout** — an \`act / fanout\` step running 2+ competing child flows in parallel. Use for "compare/try N approaches."
+4. **Sub-run** — a \`goal-child-run / sub-run\` step running a whole child flow. Use when a sub-task is itself a full flow (delegation/supervision).
+
+## House patterns (lean toward these)
+
+- Default to the linear spine; only add steps the task needs. A 5–6 step linear flow is normal; a 2-step flow is almost always too thin.
+- frame/plan/close → \`compose\`; analyze/act → \`relay\` (researcher then implementer); verify → \`verification\`; review → \`relay\` reviewer.
+- Always end at a \`close\` step marked \`terminal: true\`.
+- 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.
+
+## Equipment (optional — scope each worker step's tools)
+
+By default every step's worker gets the full tool surface. You may give a worker
+step (analyze / act / verify) a tighter scope with an \`equipment\` field, so the
+step is steered toward the tools its job needs. The scope is offered to the worker
+as guidance, not a hard limit. Pick ONE profile per step from this closed list, or
+omit \`equipment\` to keep the full surface:
+
+- \`read-only\` — read, search, and list files; no edits or commands. For steps that investigate or gather context.
+- \`editor\` — read, search, and edit or write files; no shell commands. For steps that change code or docs.
+- \`tester\` — read, search, and run commands like tests and builds; no file edits. For steps that verify.
+- \`full\` — the full tool surface (the default): read, edit, and run commands. For steps that need everything.
+
+Fit the profile to the step: \`read-only\` for \`gather-context\`/\`diagnose\`, \`editor\`
+for \`act\`, \`tester\` for \`run-verification\`. Leave it off when a step truly needs
+everything.
+
+## Output format
+
+Emit ONLY this JSON (no prose, no markdown fence), filling in the roles:
+
+\`\`\`
+{
+  "id": "kebab-case-id",
+  "title": "Short title",
+  "purpose": "One sentence: what this flow does for the task.",
+  "roles": [
+    { "stage": "frame", "block": "frame", "executionKind": "compose" },
+    { "stage": "analyze", "block": "gather-context", "executionKind": "relay", "relayRole": "researcher", "equipment": "read-only" },
+    { "stage": "act", "block": "act", "executionKind": "relay", "relayRole": "implementer", "equipment": "editor" },
+    { "stage": "verify", "block": "run-verification", "executionKind": "verification", "equipment": "tester" },
+    { "stage": "close", "block": "close-with-evidence", "executionKind": "compose", "terminal": true }
+  ]
+}
+\`\`\`
+
+Per-role fields: \`stage\`, \`block\`, \`executionKind\` always; add \`relayRole\` for relay
+steps; \`loopBackTo\` to make a verify step retry; \`flowId\`+\`goalText\` for a sub-run;
+\`fanoutBranches\` for a fanout; \`terminal: true\` on the close step; \`equipment\`
+(read-only | editor | tester | full) to scope a worker step's tools.
+
+## Common mistakes to avoid
+
+- Use ONLY the exact block ids and execution kinds from the menu above. The close
+  block is \`close-with-evidence\`, not \`close\`. \`run-verification\` runs as
+  \`verification\`, not \`relay\`. Every \`stage\` must be one of: frame, analyze, plan,
+  act, verify, review, close.
+
+Output ONLY the JSON object for the TASK below. No explanation.
+`;
+export const REPAIR_GUIDANCE = `# Repairing a rejected flow
+
+A verifier checked the flow you proposed and REJECTED it. The cause is specific:
+it might be a step whose required input no earlier step produces, OR a step that
+uses a name outside the allowed vocabulary (a wrong stage, block id, or execution
+kind). Read the verifier's exact error, match it to a rule below, and change only
+what the error names. Revise your role set so it passes.
+
+You will be given: the original task, the flow you proposed, and the verifier's
+exact error(s). Read the error and apply the matching rule below.
+
+## Error → fix
+
+- **"expected exactly one report writer for schema 'X.brief@v1'" or "'X.intake@v1'", found 0**
+  A step you chose is tied to a specific family ("X") and needs that family's
+  opening report, which your flow does not produce. Usually the culprit is an
+  optional step. Fixes, in order of preference:
+  1. Remove the step that triggers it. \`plan\` and model-only \`diagnose / compose\`
+     analyze steps are OPTIONAL — drop them for a leaner flow.
+  2. If you truly need that step, open the flow with the matching opener.
+
+- **"no input set satisfiable ... needs one of [flow.brief@v1, diagnosis.result@v1] OR [flow.brief@v1, plan.strategy@v1]"** (on an \`act\` step)
+  Your \`act\` step has nothing to act on. Put a \`diagnose\` (relay, researcher)
+  step OR a \`plan\` (compose) step BEFORE the \`act\` step, so the implementer has a
+  diagnosis or a plan to work from.
+
+- **"no input set satisfiable ... needs one of [goal.contract@v1]"** (on a \`goal-child-run\` step)
+  A sub-run step requires the supervisor opener. Use \`goal / compose\` as your
+  \`frame\` step whenever you use one or more \`goal-child-run\` sub-run steps.
+
+- **"run-verification ... requires reading 'prototype.variant-aggregate@v1'"** (after a fanout)
+  After an \`act / fanout\` step, a separate \`run-verification\` step is tied to the
+  fanout's internals and will not bind. For a fanout flow, do NOT add a
+  \`run-verification\` step — go from the \`act / fanout\` step to a \`review\` step
+  (relay, reviewer) and then \`close\`. The fanout's branches verify themselves.
+
+- **"Invalid option: expected one of ..." (naming the stage names)**
+  A step's \`stage\` is not one of the seven allowed stages. Set every step's \`stage\`
+  to one of, and keep them in this order: frame, analyze, plan, act, verify,
+  review, close.
+
+- **"... unknown block id"**
+  A step's \`block\` is not in the menu. Use only these exact block ids: frame,
+  review-intake, goal, gather-context, diagnose, plan, act, run-verification,
+  review, close-with-evidence, goal-close, goal-child-run. Do not invent a block —
+  the close block is \`close-with-evidence\`, not \`close\`.
+
+- **"equipment profile 'X' is not in the allowed set [...]"**
+  A step's \`equipment\` names a profile that does not exist. Use exactly one of:
+  \`read-only\`, \`editor\`, \`tester\`, \`full\` — or remove the \`equipment\` field to
+  leave that step at the full tool surface.
+
+- **"no registered actual for <block>/<kind> ..."**
+  The block is real but paired with the wrong execution kind. The fixed kinds are:
+  frame → compose or checkpoint; plan → compose; gather-context, act, and review →
+  relay; diagnose → relay or compose; run-verification → verification (NOT relay);
+  close-with-evidence and goal-close → compose; goal-child-run → sub-run; a parallel
+  act → fanout. Set this step's \`executionKind\` to the one its block supports.
+
+## General principles
+
+- A runnable flow keeps its steps in ONE coherent family wherever possible. The
+  cleanest runnable shapes are: frame → (gather-context) → diagnose → act →
+  run-verification → close, optionally with \`loopBackTo: "act"\` on verify.
+- Leaner is safer. If a step is optional and triggers an error, remove it.
+- Always end at a \`close\` step marked \`terminal: true\`.
+
+Output ONLY the revised JSON role set (same format as before). No prose.
+`;
+//# sourceMappingURL=propose-prompts.js.map

package/dist/flows/composition/propose-prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"propose-prompts.js","sourceRoot":"","sources":["../../../src/flows/composition/propose-prompts.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,4EAA4E;AAC5E,mCAAmC;AACnC,iEAAiE;AACjE,iEAAiE;AACjE,EAAE;AACF,iFAAiF;AACjF,6EAA6E;AAC7E,+EAA+E;AAC/E,+BAA+B;AAC/B,EAAE;AACF,gFAAgF;AAChF,kFAAkF;AAClF,mFAAmF;AACnF,oBAAoB;AAEpB,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6G9B,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE9B,CAAC"}

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

@@ -0,0 +1,36 @@
+import type { ResolvedSelection } from '../../schemas/selection-policy.js';
+import type { RelayFn } from '../../shared/relay-runtime-types.js';
+import type { FlowSchematicAssemblySpec } from '../assemble-flow-schematic.js';
+import type { FlowDefinition } from '../flow-definition.js';
+import { type CompositionRoleSet } from './composer.js';
+export interface ProposeOptions {
+    readonly task: string;
+    readonly relay: RelayFn;
+    readonly resolvedSelection?: ResolvedSelection;
+    readonly definitions?: readonly FlowDefinition[];
+    readonly maxRepair?: number;
+    readonly timeoutMs?: number;
+}
+export type ProposeStage = 'compose' | 'validity' | 'runnability' | 'runnable' | 'parse' | 'relay';
+export interface ProposeRound {
+    readonly round: number;
+    readonly errorsFedBack: readonly string[];
+    readonly stage: ProposeStage;
+    readonly runnable: boolean;
+    readonly note?: string;
+}
+export type ProposeOutcome = {
+    readonly ok: true;
+    readonly roleSet: CompositionRoleSet;
+    readonly spec: FlowSchematicAssemblySpec;
+    readonly convergedRound: number;
+    readonly rounds: readonly ProposeRound[];
+} | {
+    readonly ok: false;
+    readonly reason: 'parse' | 'relay' | 'wall';
+    readonly roleSet?: CompositionRoleSet;
+    readonly errors: readonly string[];
+    readonly rounds: readonly ProposeRound[];
+};
+export declare function proposeFlow(options: ProposeOptions): Promise<ProposeOutcome>;
+//# sourceMappingURL=propose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"propose.d.ts","sourceRoot":"","sources":["../../../src/flows/composition/propose.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,qCAAqC,CAAC;AAC/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,KAAK,kBAAkB,EAAe,MAAM,eAAe,CAAC;AAUrE,MAAM,WAAW,cAAc;IAE7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAIxB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IAG/C,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;IAEjD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,GAAG,aAAa,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAKnG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAElB,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IAErC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IAEzC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C,GACD;IACE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAGnB,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;IAE5C,QAAQ,CAAC,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAEtC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;CAC1C,CAAC;AA8KN,wBAAsB,WAAW,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAmGlF"}

package/dist/flows/composition/propose.js

@@ -0,0 +1,275 @@
+// Flow-shape composition (experimental, default-OFF): proposeFlow.
+//
+// THE PROPOSE HALF OF THE NORTH STAR, AS A CALLABLE.
+// ==================================================
+// The north star is a fully-generated, task-fitted flow. It has two halves:
+//
+//   PROPOSE — turn a task into a flow shape (a CompositionRoleSet). Shown to
+//             work by the proposer spike (experiments/flow-lab/proposer-spike.ts).
+//   VERIFY  — prove a composed flow is good. Shipped and test-locked: the floor
+//             composeFlow -> evaluateValidity -> evaluateRunnability is the SAME
+//             gate sequence the live composed arm passed, so "RUNNABLE offline"
+//             is a proven predictor of live-runnability.
+//
+// proposeFlow connects the two: it asks an injected relay (a model) to PROPOSE a
+// role set, runs the floor, and on a wall feeds the verifier's EXACT errors back
+// for a bounded number of repair rounds. It returns either a runnable flow (the
+// role set + the composed spec the caller can compile and run) or an honest
+// failure (parse / relay / wall) the caller can fall back from.
+//
+// BOUNDARIES.
+//   - This module never edits src/runtime/. It is reachable only from tests and
+//     experiment drivers; nothing in the shipped flow set imports it.
+//   - Importing it is inert: it defines functions and reads two prompt strings.
+//     No model call, no flow run, no I/O happens until proposeFlow is invoked.
+//   - It is selection-agnostic: the caller resolves the model (the session power
+//     dial) and passes a ResolvedSelection. proposeFlow imports nothing from
+//     src/selection or src/runtime.
+//   - The model is reached only through the injected RelayFn. proposeFlow does
+//     not import a connector; tests pass a stub, production passes a wrapper over
+//     the real connector relay.
+import { flowDefinitions } from '../catalog.js';
+import { composeFlow } from './composer.js';
+import { evaluateRunnability, evaluateValidity } from './evaluate.js';
+import { PROPOSER_PROMPT, REPAIR_GUIDANCE } from './propose-prompts.js';
+// Four repair rounds: the proposer-spike re-probe found the runnable rate keeps
+// climbing past two rounds (~9/16 at 2 → ~11/16 at 4) because the floor's errors
+// genuinely steer the model. Two was the spike's measurement budget, not a ceiling.
+const DEFAULT_MAX_REPAIR = 4;
+const DEFAULT_TIMEOUT_MS = 90_000;
+// Grade an ALREADY-COMPOSED spec through the floor's validity + runnability +
+// vacuity gates. Each gate is wrapped because a malformed spec can make evaluate*
+// THROW rather than return a verdict; a throw is just another fail-closed verdict
+// with a message we can feed back. Extracted so the primary composition and the
+// heal-retry composition are held to the identical bar.
+function gradeSpec(spec) {
+    let validity;
+    try {
+        validity = evaluateValidity(spec);
+    }
+    catch (err) {
+        return { runnable: false, stage: 'validity', errors: [`validity threw: ${msg(err)}`] };
+    }
+    if (!validity.valid || !validity.compiles) {
+        const errors = validity.catalogIssues.length > 0
+            ? [...validity.catalogIssues]
+            : [validity.error ?? 'offline-invalid'];
+        return { runnable: false, stage: 'validity', errors };
+    }
+    let runnability;
+    try {
+        runnability = evaluateRunnability(spec);
+    }
+    catch (err) {
+        return { runnable: false, stage: 'runnability', errors: [`runnability threw: ${msg(err)}`] };
+    }
+    if (!runnability.runnable) {
+        return {
+            runnable: false,
+            stage: 'runnability',
+            errors: runnability.aborts.map((a) => `${a.stepId}(${a.schema}): ${a.reason}`),
+        };
+    }
+    // Defense-in-depth: a runnability verdict that checked zero steps is vacuous,
+    // not a genuine pass. Unreachable for any role set the composer accepts (a valid
+    // terminal always resolves a close writer, incrementing checkedSteps), but the
+    // assertion forecloses a theoretical false-positive.
+    if (runnability.checkedSteps <= 0) {
+        return {
+            runnable: false,
+            stage: 'runnability',
+            errors: ['runnability check was vacuous (0 steps checked)'],
+        };
+    }
+    return { runnable: true, spec };
+}
+function runFloor(roleSet, definitions) {
+    let outcome;
+    try {
+        outcome = composeFlow(roleSet, { definitions });
+    }
+    catch (err) {
+        return { runnable: false, stage: 'compose', errors: [`compose threw: ${msg(err)}`] };
+    }
+    if (!outcome.ok) {
+        return {
+            runnable: false,
+            stage: 'compose',
+            errors: outcome.walls.map((w) => `${w.block}: ${w.reason}`),
+        };
+    }
+    const graded = gradeSpec(outcome.spec);
+    if (graded.runnable)
+        return graded;
+    // Self-heal the producibility wall, but only on the SLOW PATH. A composed build
+    // arc that opens with a plain compose frame leaves build.brief@v1 (a
+    // checkpoint-only contract its `plan` reads) unproduced, so it grades
+    // runnable:false — the proposer hits this about one time in three by omitting the
+    // blessed-brief checkpoint opener. The opt-in enforceRunnability composition knows
+    // how to promote that frame to the checkpoint; retry under it and adopt the result
+    // ONLY if it grades runnable. A working proposal already returned above, so the
+    // flag never touches it — its compiled bytes stay identical — and the flag's
+    // family-coherence look-ahead is pure upside on an already-failing proposal. A
+    // genuinely un-healable proposal falls through to its ORIGINAL verdict and error
+    // labels, so the verifier-driven repair loop still sees the real wall to feed back.
+    if (graded.stage === 'runnability') {
+        let healed;
+        try {
+            healed = composeFlow(roleSet, { definitions, enforceRunnability: true });
+        }
+        catch {
+            healed = undefined;
+        }
+        if (healed?.ok) {
+            const healedGrade = gradeSpec(healed.spec);
+            if (healedGrade.runnable)
+                return healedGrade;
+        }
+    }
+    return graded;
+}
+function msg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+// --- tolerant JSON extraction ---------------------------------------------
+// The prompt asks for raw JSON with no fence, but models sometimes wrap it.
+// Strip a ```json fence, else take the first balanced {...}. An unparseable emit
+// is a genuine propose failure, surfaced as a parse error (and repairable).
+function extractRoleSet(raw) {
+    let text = raw.trim();
+    const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence?.[1] !== undefined)
+        text = fence[1].trim();
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end === -1 || end <= start) {
+        return { ok: false, error: 'no JSON object found in model output' };
+    }
+    const slice = text.slice(start, end + 1);
+    try {
+        const parsed = JSON.parse(slice);
+        if (!Array.isArray(parsed.roles)) {
+            return { ok: false, error: 'parsed JSON has no `roles` array' };
+        }
+        return { ok: true, roleSet: parsed };
+    }
+    catch (err) {
+        return { ok: false, error: `JSON.parse failed: ${msg(err)}` };
+    }
+}
+// --- the model channel ------------------------------------------------------
+async function callModel(relay, prompt, resolvedSelection, timeoutMs) {
+    // Build the relay input without a `resolvedSelection: undefined` key:
+    // exactOptionalPropertyTypes rejects an explicit undefined on an optional prop,
+    // and the relay treats an absent selection as "use your default".
+    const base = { prompt, toolAllowList: [], timeoutMs };
+    const input = resolvedSelection === undefined ? base : { ...base, resolvedSelection };
+    try {
+        const result = await relay.relay(input);
+        return { ok: true, body: result.result_body };
+    }
+    catch (err) {
+        return { ok: false, error: `relay failed: ${msg(err)}` };
+    }
+}
+function proposePrompt(task) {
+    return `${PROPOSER_PROMPT}\n\n## TASK\n\n${task}\n`;
+}
+function repairPrompt(task, proposed, errors) {
+    const proposedJson = JSON.stringify(proposed, null, 2);
+    const errorList = errors.map((e) => `- ${e}`).join('\n');
+    return `${REPAIR_GUIDANCE}\n\n## ORIGINAL TASK\n\n${task}\n\n## THE FLOW YOU PROPOSED\n\n${proposedJson}\n\n## THE VERIFIER'S EXACT ERROR(S)\n\n${errorList}\n`;
+}
+// --- the propose + verifier-driven repair loop ------------------------------
+export async function proposeFlow(options) {
+    const { task, relay, resolvedSelection } = options;
+    const definitions = options.definitions ?? flowDefinitions;
+    const maxRepair = options.maxRepair ?? DEFAULT_MAX_REPAIR;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const rounds = [];
+    // Round 0 — the initial proposal.
+    const proposal = await callModel(relay, proposePrompt(task), resolvedSelection, timeoutMs);
+    if (!proposal.ok) {
+        rounds.push({
+            round: 0,
+            errorsFedBack: [],
+            stage: 'relay',
+            runnable: false,
+            note: proposal.error,
+        });
+        return { ok: false, reason: 'relay', errors: [proposal.error], rounds };
+    }
+    const parsed = extractRoleSet(proposal.body);
+    if (!parsed.ok) {
+        // A round-0 parse failure is terminal: there is no role set to repair against.
+        rounds.push({
+            round: 0,
+            errorsFedBack: [],
+            stage: 'parse',
+            runnable: false,
+            note: parsed.error,
+        });
+        return { ok: false, reason: 'parse', errors: [parsed.error], rounds };
+    }
+    let current = parsed.roleSet;
+    const rawVerdict = runFloor(current, definitions);
+    rounds.push({
+        round: 0,
+        errorsFedBack: [],
+        stage: rawVerdict.runnable ? 'runnable' : rawVerdict.stage,
+        runnable: rawVerdict.runnable,
+    });
+    if (rawVerdict.runnable) {
+        return { ok: true, roleSet: current, spec: rawVerdict.spec, convergedRound: 0, rounds };
+    }
+    // Repair rounds 1..maxRepair — feed the verifier's exact errors back each time.
+    let lastErrors = rawVerdict.errors;
+    for (let round = 1; round <= maxRepair; round += 1) {
+        const repair = await callModel(relay, repairPrompt(task, current, lastErrors), resolvedSelection, timeoutMs);
+        if (!repair.ok) {
+            // The model channel failed mid-repair. We still hold a parsed proposal, so
+            // this is a wall (not a total relay failure): record it and fall through.
+            rounds.push({
+                round,
+                errorsFedBack: lastErrors,
+                stage: 'relay',
+                runnable: false,
+                note: repair.error,
+            });
+            break;
+        }
+        const reparsed = extractRoleSet(repair.body);
+        if (!reparsed.ok) {
+            // Junk in a repair round: record it, then ask for a clean re-emission with
+            // a reset instruction (keeping the same target task) and try the next round.
+            rounds.push({
+                round,
+                errorsFedBack: lastErrors,
+                stage: 'parse',
+                runnable: false,
+                note: reparsed.error,
+            });
+            lastErrors = [
+                `Your previous output did not parse: ${reparsed.error}. Emit ONLY the JSON role set.`,
+            ];
+            continue;
+        }
+        current = reparsed.roleSet;
+        const verdict = runFloor(current, definitions);
+        rounds.push({
+            round,
+            errorsFedBack: lastErrors,
+            stage: verdict.runnable ? 'runnable' : verdict.stage,
+            runnable: verdict.runnable,
+        });
+        if (verdict.runnable) {
+            return { ok: true, roleSet: current, spec: verdict.spec, convergedRound: round, rounds };
+        }
+        lastErrors = verdict.errors;
+    }
+    // Exhausted the repair budget (or the channel failed mid-repair) without a
+    // runnable flow. Hand back the best proposal + the last verifier errors so the
+    // caller can fall back to a proven template.
+    return { ok: false, reason: 'wall', roleSet: current, errors: lastErrors, rounds };
+}
+//# sourceMappingURL=propose.js.map

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

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

package/dist/flows/contract-body-signature.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+export declare function fieldSignature(schema: z.ZodType): string;
+export declare function resolveFieldSignature(contractName: string): string | null;
+//# sourceMappingURL=contract-body-signature.d.ts.map

package/dist/flows/contract-body-signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-body-signature.d.ts","sourceRoot":"","sources":["../../src/flows/contract-body-signature.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAyD7B,wBAAgB,cAAc,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,GAAG,MAAM,CAExD;AAsFD,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGzE"}