@petepetrash/circuit 0.1.0

package/dist/flows/contract-body-signature.js

@@ -0,0 +1,166 @@
+// M8 (first-class composition): structural signatures for contract bodies.
+//
+// The accommodation ledger surfaces multi-actual generics — one generic
+// contract name aliased to several distinct actuals within a flow. Until M8 the
+// ledger could only prove each actual had a real producer; it could NOT say
+// whether the bodies behind those actuals were the same shape. This module
+// closes that gap: it resolves an actual contract name to its Zod body and
+// reduces that body to a canonical STRUCTURAL SIGNATURE, so the ledger can
+// classify a multi-actual generic as uniform (all actuals share one shape) or
+// divergent (the shapes differ).
+//
+// The signature is an EQUALITY key, not a subtype relation. Two bodies share a
+// signature iff their JSON-Schema shape — field names with optionality,
+// recursively through object property values, union variants, and arrays — is
+// identical. (M9-A2 added the object-property-value recursion; before it, two
+// bodies with the same field names but different field types hashed equal.) This
+// is the report-only half of M8: it makes "needs split vs safe to unify" a
+// machine output. The fail-closed half (the anti-widening gate) is M8.4.
+//
+// Why JSON Schema and not raw Zod introspection: the report bodies mix
+// z.object, z.looseObject, discriminated unions, supersets, and `.extend`
+// chains. Reducing through the same draft-07 conversion the connectors already
+// use (responseJsonSchemaFromZod) gives one stable shape to read field names
+// from, instead of branching on Zod internals per construct.
+import { BUILTIN_REPORT_SCHEMAS } from '../schemas/builtin-report-schemas.js';
+import { RunResult } from '../schemas/result.js';
+import { BUILTIN_ROUTING_CONTRACT_SCHEMAS } from '../schemas/routing-contract-schemas.js';
+import { responseJsonSchemaFromZod } from '../shared/zod-to-response-schema.js';
+import { buildReportSchemaRegistry } from './catalog-derivations.js';
+import { flowPackages } from './catalog.js';
+import { GoalGate } from './goal/reports.js';
+import { ReviewRelayResult } from './review/reports.js';
+import { RuntimeProofCompose } from './runtime-proof/reports.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// Canonical signature of a JSON-Schema node. Object → its sorted field names
+// with `?` on the optional ones, EACH paired with the recursed signature of its
+// value (`name:<sig>` / `name?:<sig>`); union → its variant signatures, sorted so
+// declaration order does not matter; array → the element signature; anything
+// else → its JSON-Schema `type` (or `scalar` when untyped). Recursing through
+// object property values (M9-A2) is what stops two bodies with the same field
+// names but different field types from hashing equal — the signature-collision
+// seam an assembler would otherwise trip. Recursion through unions and arrays is
+// what makes a discriminated union compare equal to another union of the same
+// variants regardless of how each was authored.
+function signatureOfNode(node) {
+    if (!isRecord(node))
+        return 'unknown';
+    if (Array.isArray(node.anyOf)) {
+        const variants = node.anyOf.map(signatureOfNode).sort();
+        return `union(${variants.join('|')})`;
+    }
+    if (Array.isArray(node.allOf)) {
+        const parts = node.allOf.map(signatureOfNode).sort();
+        return `all(${parts.join('&')})`;
+    }
+    if (node.type === 'array') {
+        return `array<${signatureOfNode(node.items)}>`;
+    }
+    if (node.type === 'object' && isRecord(node.properties)) {
+        const required = new Set(Array.isArray(node.required) ? node.required : []);
+        const properties = node.properties;
+        const fields = Object.keys(properties)
+            .sort()
+            .map((key) => {
+            const label = required.has(key) ? key : `${key}?`;
+            return `${label}:${signatureOfNode(properties[key])}`;
+        });
+        return `{${fields.join(',')}}`;
+    }
+    if (typeof node.type === 'string')
+        return node.type;
+    return 'scalar';
+}
+// Reduce a Zod report body to its canonical structural signature.
+export function fieldSignature(schema) {
+    return signatureOfNode(responseJsonSchemaFromZod(schema));
+}
+// Uniform producer generics (M8.2). A producer generic is a block
+// output_contract realized by several actuals within one flow. When all those
+// actuals share one body the generic is UNIFORM, and its single canonical body
+// is that shared shape. Two ship today, both in goal:
+//   - goal.child-run@v1   → RunResult (the goal-child-run block; five child
+//                           results, all RunResult)
+//   - goal.gate-review@v1 → GoalGate  (the goal-gate-review block; two passes,
+//                           both GoalGate)
+// Only the actuals were typed (they are flow reports); the generic NAME they
+// collapse under was not, so resolveFieldSignature returned null for it. These
+// entries close that gap. The body is the SAME Zod schema the actuals use
+// (imported, never re-authored) so the two cannot drift apart silently — the
+// "canonical body equals every actual" invariant is pinned in
+// accommodation-ledger.test.ts. Divergent producer generics (goal.contract@v1,
+// the verification families) get NO entry here on purpose: they have no single
+// canonical body, which is what forces their split in M8.3.
+const UNIFORM_PRODUCER_GENERIC_SCHEMAS = {
+    'goal.child-run@v1': RunResult,
+    'goal.gate-review@v1': GoalGate,
+};
+// Raw consumed generics (M9-A1). A generic block output_contract that a flow
+// CONSUMES raw — read by an item input under the generic name, produced in-flow,
+// and NOT specialized to a flow-scoped actual — needs a canonical body so the
+// single-actual typing gate (collectUnregisteredConsumedContractIssues) can
+// verify the consumer reads a known shape. Two ship today, each consuming the
+// generic raw inside one flow:
+//   - plan.strategy@v1  → RuntimeProofCompose  (runtime-proof: compose-step
+//                          outputs it, relay-step reads it as `plan`)
+//   - review.verdict@v1 → ReviewRelayResult    (review: the reviewer relay
+//                          outputs it, verdict-step reads it as `review`)
+// The body is the SAME Zod schema the producing item writes — RuntimeProofCompose
+// is the compose writer's result (runtime-proof.compose@v1), ReviewRelayResult is
+// what the close step parses the reviewer relay against (review/writers/result.ts)
+// — so the registration matches runtime truth, never re-authoring a shape. Other
+// flows that reuse these generics alias them to flow-scoped actuals and read the
+// actual; this registration is consulted only where the generic is read raw,
+// which is exactly the two flows above. Divergent producer generics are NOT
+// listed (they have no single canonical body); the typing gate exempts them
+// because they are write-only umbrellas the anti-widening gate already guards.
+const RAW_CONSUMED_GENERIC_SCHEMAS = {
+    'plan.strategy@v1': RuntimeProofCompose,
+    'review.verdict@v1': ReviewRelayResult,
+};
+// Every body the engine can resolve by contract NAME, in three parts:
+//   1. report bodies — relay reports plus channel:'report' bodies (compose /
+//      close / verification / checkpoint / sub-run). The narrower relay-only
+//      registry that parseReport uses would miss most multi-actual actuals,
+//      which are channel:'report' compose/verification bodies, so the resolver
+//      builds over the broad relay+report coverage.
+//   2. routing-seam contracts (M8.1) — task.intake / route.decision /
+//      flow.catalog. These are engine built-ins, not flow-package reports, so
+//      they merge in separately.
+//   3. uniform producer generics (M8.2) — block output_contracts whose actuals
+//      all share one body (see above).
+//   4. raw consumed generics (M9-A1) — block output_contracts a flow consumes
+//      raw (under the generic name), whose canonical body is the producing item's
+//      report shape (see above).
+// A name collision across any two parts is a bug (a generic masquerading as a
+// flow report, or two sources claiming one name), so each merge throws on it.
+const BODY_REGISTRY = (() => {
+    const reports = buildReportSchemaRegistry(flowPackages, {
+        channels: 'relay+report',
+        fixtures: BUILTIN_REPORT_SCHEMAS,
+    });
+    const merged = { ...reports };
+    const mergeBuiltins = (source, kind) => {
+        for (const [name, schema] of Object.entries(source)) {
+            if (Object.hasOwn(merged, name)) {
+                throw new Error(`${kind} '${name}' collides with an already-registered contract body`);
+            }
+            merged[name] = schema;
+        }
+    };
+    mergeBuiltins(BUILTIN_ROUTING_CONTRACT_SCHEMAS, 'routing-seam contract');
+    mergeBuiltins(UNIFORM_PRODUCER_GENERIC_SCHEMAS, 'uniform producer generic');
+    mergeBuiltins(RAW_CONSUMED_GENERIC_SCHEMAS, 'raw consumed generic');
+    return Object.freeze(merged);
+})();
+// Resolve a contract/actual name to its body signature, or null when no
+// registered body exists for it (e.g. a routing-seam contract before M8.1
+// authors its body). Null is what the ledger reports as `unresolved`.
+export function resolveFieldSignature(contractName) {
+    if (!Object.hasOwn(BODY_REGISTRY, contractName))
+        return null;
+    return fieldSignature(BODY_REGISTRY[contractName]);
+}
+//# sourceMappingURL=contract-body-signature.js.map

package/dist/flows/contract-body-signature.js.map

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

package/dist/flows/converge-proof/assembly-spec.d.ts

@@ -0,0 +1,5 @@
+import type { FlowSchematicAssemblySpec } from '../assemble-flow-schematic.js';
+import type { BlockStepUse } from '../block-step-expansion.js';
+export declare const convergeProofBlockItems: readonly BlockStepUse[];
+export declare const convergeProofAssemblySpec: FlowSchematicAssemblySpec;
+//# sourceMappingURL=assembly-spec.d.ts.map

package/dist/flows/converge-proof/assembly-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-spec.d.ts","sourceRoot":"","sources":["../../../src/flows/converge-proof/assembly-spec.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAE,yBAAyB,EAAiB,MAAM,+BAA+B,CAAC;AAC9F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAe/D,eAAO,MAAM,uBAAuB,EAAE,SAAS,YAAY,EAyD1D,CAAC;AAQF,eAAO,MAAM,yBAAyB,EAAE,yBAwCvC,CAAC"}

package/dist/flows/converge-proof/assembly-spec.js

@@ -0,0 +1,115 @@
+const CONVERGE_PROOF_STAGE_PATH_RATIONALE = 'Converge Proof is a narrow until-loop proof flow; only plan, act, and review are needed to exercise a multi-step body that re-enters until the judge confirms the goal.';
+// Converge Proof's loop body, in route order: plan (head) -> act (intermediate)
+// -> review (tail / judge). The judge declares three routes, all NORMAL (never
+// recovery) keys: continue (the clean stop to @complete), advance (the loop
+// re-entry edge back to the head, the same key the slice loop re-enters on), and
+// close (the exhausted exit to the non-complete @stop terminal). The exhausted
+// exit must be a NORMAL route, not a recovery route like `escalate`: an exhausted
+// iteration takes its exit on a CLEAN pass (the judge completed its check), so a
+// recovery route would trip the WorkContract "selected recovery route without
+// failure evidence" guard and abort. `close` carries no recovery binding (it is
+// in NORMAL_ROUTE_IDS), so the run exits `stopped` via @stop as intended.
+export const convergeProofBlockItems = [
+    {
+        id: 'head-step',
+        title: 'Plan the next iteration',
+        stage: 'plan',
+        block: 'plan',
+        input: { brief: 'flow.brief@v1' },
+        execution: { kind: 'relay', role: 'researcher' },
+        protocol: 'converge-proof-plan@v1',
+        requestPath: 'reports/converge/plan.request.json',
+        receiptPath: 'reports/converge/plan.receipt.txt',
+        resultPath: 'reports/converge/plan.result.json',
+        pass: ['ok'],
+        routes: { continue: 'work-step' },
+    },
+    {
+        id: 'work-step',
+        title: 'Act on the plan',
+        stage: 'act',
+        block: 'act',
+        input: { brief: 'flow.brief@v1', plan: 'plan.strategy@v1' },
+        execution: { kind: 'relay', role: 'implementer' },
+        protocol: 'converge-proof-act@v1',
+        requestPath: 'reports/converge/act.request.json',
+        receiptPath: 'reports/converge/act.receipt.txt',
+        resultPath: 'reports/converge/act.result.json',
+        pass: ['ok'],
+        routes: { continue: 'judge-step' },
+    },
+    {
+        id: 'judge-step',
+        title: 'Judge whether the goal is met',
+        stage: 'review',
+        block: 'review',
+        // Reads brief only (a registered initial contract). The review block admits
+        // a brief-only input; reading work-step's change.evidence@v1 would force the
+        // generic contract to carry a registered Zod body it does not have, and the
+        // loop's behavior never depends on the judge reading the act result anyway.
+        input: { brief: 'flow.brief@v1' },
+        execution: { kind: 'relay', role: 'reviewer' },
+        protocol: 'converge-proof-review@v1',
+        // The stop-judge is bound to the strict judgment contract: the typed report
+        // is what the until corridor reads (stop_judge.report below), and the bound
+        // schema is what the shape-hint registry keys on, so the judge's prompt
+        // teaches exactly the shape the validator enforces. A bare acknowledgment
+        // body fails schema validation and can never close the loop.
+        output: 'converge.judgment@v1',
+        requestPath: 'reports/converge/judgment.request.json',
+        receiptPath: 'reports/converge/judgment.receipt.txt',
+        resultPath: 'reports/converge/judgment.result.json',
+        reportPath: 'reports/converge/judgment.report.json',
+        // All three schema verdicts are admissible: the verdict reports that the
+        // judge did its job; goal_met carries the judgment. An honest "reject" must
+        // route through the loop's disposition, not fail the relay check.
+        pass: ['accept', 'accept-with-fixes', 'reject'],
+        routes: { continue: '@complete', advance: 'head-step', close: '@stop' },
+    },
+];
+const convergeProofStageLabels = {
+    plan: { id: 'plan-stage', title: 'Plan' },
+    act: { id: 'act-stage', title: 'Act' },
+    review: { id: 'review-stage', title: 'Review' },
+};
+export const convergeProofAssemblySpec = {
+    id: 'converge-proof',
+    title: 'Converge Proof Schematic',
+    purpose: 'Converge Proof flow: re-enter a three-relay body (plan, act, review) until the review judge confirms the goal is met, so the until-loop primitive can be observed end-to-end through the runtime boundary.',
+    status: 'active',
+    version: '0.1.0',
+    initial_contracts: ['flow.brief@v1'],
+    // The judge-step overrides the review block's generic output with the strict
+    // judgment contract; the alias is what makes that override block-compatible
+    // (contractIsCompatible admits generic -> declared actual).
+    contract_aliases: [{ generic: 'review.verdict@v1', actual: 'converge.judgment@v1' }],
+    axes: {
+        allowed_depths: ['medium'],
+        supports_tournament: false,
+        supports_autonomous: true,
+        default: { depth: 'medium', tournament: false, tournament_n: 3, autonomous: false },
+    },
+    engine_flags: {
+        iterates_until_condition: {
+            head_step: 'head-step',
+            tail_step: 'judge-step',
+            body_steps: ['head-step', 'work-step', 'judge-step'],
+            reenter_route: 'advance',
+            max_iterations: 3,
+            stop_judge: {
+                // Read the TYPED report, not the raw result: the report file exists only
+                // when the body passed converge.judgment@v1 validation, so the corridor
+                // always disposes a schema-checked goal_met.
+                report: 'reports/converge/judgment.report.json',
+                goal_met_path: 'goal_met',
+                lesson_path: 'lesson',
+            },
+            needs_attention_route: 'close',
+            activate_when_depth_at_least: 'autonomous',
+        },
+    },
+    items: convergeProofBlockItems,
+    stageLabels: convergeProofStageLabels,
+    stagePathRationale: CONVERGE_PROOF_STAGE_PATH_RATIONALE,
+};
+//# sourceMappingURL=assembly-spec.js.map

package/dist/flows/converge-proof/assembly-spec.js.map

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