@petepetrash/circuit 0.1.0

package/dist/flows/explore/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/flows/explore/data.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmKR,CAAC"}

package/dist/flows/explore/data.js

@@ -0,0 +1,174 @@
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { exploreAssemblySpec } from './assembly-spec.js';
+import { exploreComposeShapeHint, exploreReviewVerdictShapeHint, exploreTournamentProposalShapeHint, exploreTournamentReviewShapeHint, } from './relay-hints.js';
+import { ExploreAnalysis, ExploreBrief, ExploreCompose, ExploreDecision, ExploreDecisionOptions, ExploreResult, ExploreReviewVerdict, ExploreTournamentAggregate, ExploreTournamentProposal, ExploreTournamentReview, } from './reports.js';
+import { exploreAnalysisComposeBuilder } from './writers/analysis.js';
+import { exploreBriefComposeBuilder } from './writers/brief.js';
+import { exploreCloseBuilder } from './writers/close.js';
+import { exploreDecisionOptionsComposeBuilder } from './writers/decision-options.js';
+import { exploreDecisionComposeBuilder } from './writers/decision.js';
+export const exploreFlowData = {
+    id: 'explore',
+    visibility: 'public',
+    paths: {
+        schematic: 'src/flows/explore/schematic.json',
+        contract: 'src/flows/explore/contract.md',
+    },
+    // First-class composition (A5): explore is the assembler's most irregular
+    // production customer — a four-canonical partial spine with the act/review
+    // archetypes and the full decision tournament folded inside the canonical
+    // Plan stage, non-monotonic items, a dynamic proposal fanout, a tradeoff
+    // checkpoint, a custom diagnose block, a forward-read optional input, and two
+    // close steps sharing one result output. Its block sequence + scaffolding
+    // live in ./assembly-spec.ts; `assembleFlowSchematic` derives starts_at /
+    // stages / stage_path_policy and returns the validated FlowSchematic that used
+    // to be a hand-authored literal here. The prove-by-equivalence test proves
+    // byte-identity (schematic + compiled).
+    schematic: assembleFlowSchematic(exploreAssemblySpec),
+    canonicalStagePolicy: {
+        kind: 'enforce',
+        canonicals: ['frame', 'analyze', 'plan', 'close'],
+        omits: ['act', 'verify', 'review'],
+        optional_canonicals: [],
+        variants: [],
+        title: 'Frame → Analyze → Plan or Decision → Close',
+        authority: 'src/flows/explore/contract.md §Canonical stage set',
+    },
+    reports: [
+        {
+            schemaName: 'explore.compose@v1',
+            channel: 'relay',
+            schema: ExploreCompose,
+            relayHint: exploreComposeShapeHint.instruction,
+        },
+        {
+            schemaName: 'explore.review-verdict@v1',
+            channel: 'relay',
+            schema: ExploreReviewVerdict,
+            relayHint: exploreReviewVerdictShapeHint.instruction,
+        },
+        {
+            schemaName: 'explore.tournament-proposal@v1',
+            channel: 'relay',
+            schema: ExploreTournamentProposal,
+            relayHint: exploreTournamentProposalShapeHint.instruction,
+        },
+        {
+            schemaName: 'explore.tournament-review@v1',
+            channel: 'relay',
+            schema: ExploreTournamentReview,
+            relayHint: exploreTournamentReviewShapeHint.instruction,
+        },
+        {
+            schemaName: 'explore.brief@v1',
+            channel: 'report',
+            schema: ExploreBrief,
+            writers: { compose: [exploreBriefComposeBuilder] },
+        },
+        {
+            schemaName: 'explore.analysis@v1',
+            channel: 'report',
+            schema: ExploreAnalysis,
+            writers: { compose: [exploreAnalysisComposeBuilder] },
+        },
+        {
+            schemaName: 'explore.decision-options@v1',
+            channel: 'report',
+            schema: ExploreDecisionOptions,
+            writers: { compose: [exploreDecisionOptionsComposeBuilder] },
+        },
+        {
+            schemaName: 'explore.tournament-aggregate@v1',
+            channel: 'report',
+            schema: ExploreTournamentAggregate,
+        },
+        {
+            schemaName: 'explore.decision@v1',
+            channel: 'report',
+            schema: ExploreDecision,
+            writers: { compose: [exploreDecisionComposeBuilder] },
+        },
+        {
+            schemaName: 'explore.result@v1',
+            channel: 'report',
+            schema: ExploreResult,
+            writers: { close: [exploreCloseBuilder] },
+        },
+    ],
+    runtimeSurface: {
+        primaryResult: {
+            schemaName: 'explore.result@v1',
+            path: 'reports/explore-result.json',
+            label: 'Explore result',
+        },
+        progress: {
+            steps: [
+                {
+                    stepId: 'frame-step',
+                    taskTitle: 'Frame the work',
+                    activeText: 'Framing the work',
+                },
+                {
+                    stepId: 'analyze-step',
+                    taskTitle: 'Check the context',
+                    activeText: 'Checking the context',
+                },
+                {
+                    stepId: 'synthesize-step',
+                    taskTitle: 'Draft the recommendation',
+                    activeText: 'Drafting the recommendation',
+                    relayRole: 'implementer',
+                    relayStartedText: 'Asking the specialist to draft the recommendation...',
+                    relayCompletedText: 'Finished drafting the recommendation.',
+                },
+                {
+                    stepId: 'review-step',
+                    taskTitle: 'Check the recommendation',
+                    activeText: 'Checking the recommendation',
+                    relayRole: 'reviewer',
+                    relayStartedText: 'Asking the reviewer to check the recommendation...',
+                    relayCompletedText: 'Finished checking the recommendation.',
+                },
+                {
+                    stepId: 'decision-options-step',
+                    taskTitle: 'Draft the options',
+                    activeText: 'Drafting the options',
+                },
+                {
+                    stepId: 'proposal-fanout-step',
+                    taskTitle: 'Compare the options',
+                    activeText: 'Comparing the options',
+                },
+                {
+                    stepId: 'stress-proposals-step',
+                    taskTitle: 'Check the options',
+                    activeText: 'Checking the options',
+                    relayRole: 'reviewer',
+                    relayStartedText: 'Asking the reviewer to check the recommendation...',
+                    relayCompletedText: 'Finished checking the recommendation.',
+                },
+                {
+                    stepId: 'tradeoff-checkpoint-step',
+                    taskTitle: 'Compare the options',
+                    activeText: 'Comparing the options',
+                },
+                {
+                    stepId: 'decision-step',
+                    taskTitle: 'Draft the recommendation',
+                    activeText: 'Drafting the recommendation',
+                },
+                {
+                    stepId: 'close-tournament-step',
+                    taskTitle: 'Wrap up',
+                    activeText: 'Wrapping up',
+                },
+                {
+                    stepId: 'close-step',
+                    taskTitle: 'Wrap up',
+                    activeText: 'Wrapping up',
+                },
+            ],
+        },
+    },
+};
+//# sourceMappingURL=data.js.map

package/dist/flows/explore/data.js.map

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

package/dist/flows/explore/flow.d.ts

@@ -0,0 +1,2 @@
+export declare const exploreFlowDefinition: import("../flow-definition.js").FlowDefinition;
+//# sourceMappingURL=flow.d.ts.map

package/dist/flows/explore/flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/flows/explore/flow.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,gDAAkC,CAAC"}

package/dist/flows/explore/flow.js

@@ -0,0 +1,4 @@
+import { defineFlowData } from '../flow-definition.js';
+import { exploreFlowData } from './data.js';
+export const exploreFlowDefinition = defineFlowData(exploreFlowData);
+//# sourceMappingURL=flow.js.map

package/dist/flows/explore/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../../src/flows/explore/flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,MAAM,CAAC,MAAM,qBAAqB,GAAG,cAAc,CAAC,eAAe,CAAC,CAAC"}

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

@@ -0,0 +1,4 @@
+declare const compiledFlowPackage: import("../types.js").CompiledFlowPackage;
+export { compiledFlowPackage as exploreCompiledFlowPackage };
+export { exploreTournamentProjector } from './writers/tournament-html.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flows/explore/index.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,mBAAmB,2CAA+C,CAAC;AAEzE,OAAO,EAAE,mBAAmB,IAAI,0BAA0B,EAAE,CAAC;AAG7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/flows/explore/index.js

@@ -0,0 +1,8 @@
+import { compileFlowDefinition } from '../flow-definition.js';
+import { exploreFlowDefinition } from './flow.js';
+const compiledFlowPackage = compileFlowDefinition(exploreFlowDefinition);
+export { compiledFlowPackage as exploreCompiledFlowPackage };
+// Public surface: the flow's operator-summary HTML projector. The catalog
+// registers it into the shared registry; tests exercise it in isolation here.
+export { exploreTournamentProjector } from './writers/tournament-html.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/flows/explore/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,mBAAmB,GAAG,qBAAqB,CAAC,qBAAqB,CAAC,CAAC;AAEzE,OAAO,EAAE,mBAAmB,IAAI,0BAA0B,EAAE,CAAC;AAC7D,0EAA0E;AAC1E,8EAA8E;AAC9E,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/flows/explore/relay-hints.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaShapeHint } from '../registries/shape-hints/types.js';
+export declare const exploreComposeShapeHint: SchemaShapeHint;
+export declare const exploreReviewVerdictShapeHint: SchemaShapeHint;
+export declare const exploreTournamentProposalShapeHint: SchemaShapeHint;
+export declare const exploreTournamentReviewShapeHint: SchemaShapeHint;
+//# sourceMappingURL=relay-hints.d.ts.map

package/dist/flows/explore/relay-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.d.ts","sourceRoot":"","sources":["../../../src/flows/explore/relay-hints.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE1E,eAAO,MAAM,uBAAuB,EAAE,eAUrC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,eAW3C,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,eAUhD,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,eAS9C,CAAC"}

package/dist/flows/explore/relay-hints.js

@@ -0,0 +1,53 @@
+// Explore flow relay shape hints.
+//
+// These skeletons stay hand-written rather than rendered from Zod via
+// `renderShapeSkeleton` (as goal/build/fix do): the renderer cannot
+// reproduce the dynamic "<one-of-accepted-verdicts>" compose placeholder or
+// the explicit eight-key rubric_model_judgments enumeration (its record type
+// collapses to "<key>"), so a mechanical conversion would regress guidance.
+// Convert these only after those fields carry the describes the renderer needs.
+export const exploreComposeShapeHint = {
+    kind: 'schema',
+    schema: 'explore.compose@v1',
+    instruction: [
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "verdict": "<one-of-accepted-verdicts>", "subject": "<subject investigated>", "recommendation": "<primary conclusion or recommendation>", "success_condition_alignment": "<how the recommendation satisfies the brief success condition>", "supporting_aspects": [{ "aspect": "<analysis aspect name>", "contribution": "<how this aspect supports the recommendation>", "evidence_refs": ["<report path or file:line reference that supports this contribution>"] }] }',
+        'Ground claims in the provided reports or files you inspect. If the evidence is thin, say so in the recommendation instead of inventing certainty. When asked to score or grade, include the rubric in the recommendation and cite the evidence refs behind the score.',
+        'Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include any prose before or after the JSON object.',
+        'The runtime parses your response with JSON.parse, rejects verdicts the schema does not allow, and validates the full report body against explore.compose@v1 before writing reports/compose.json.',
+    ].join(' '),
+};
+export const exploreReviewVerdictShapeHint = {
+    kind: 'schema',
+    schema: 'explore.review-verdict@v1',
+    instruction: [
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "verdict": "<accept|accept-with-fold-ins|reject>", "overall_assessment": "<review summary>", "objections": ["<blocking or follow-up objection>"], "missed_angles": ["<important angle not covered>"] }',
+        'Use verdict "reject" when any objection is blocking: the compose routes back for one rework pass that reads this review, and a second reject stops the run. Use "accept-with-fold-ins" only for objections the operator can absorb without reworking the compose. A justified reject is a successful review.',
+        'Use empty arrays when there are no objections or missed angles. Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include any prose before or after the JSON object.',
+        'Audit the compose against the brief on these axes before deciding the verdict. Subject fidelity: the subject must match the brief; flag if it includes unrelated topics. Evidence groundedness: every evidence_ref must be a real path in the run; flag fabricated, missing, or unresolvable references. Internal consistency: the recommendation and supporting_aspects must not contradict each other or the verdict; flag self-negating or contradictory sentences. Epistemic calibration: confidence must match the evidence; flag overclaiming, false certainty, or assertions unsupported by the cited reports. Specifically flag mild readiness overclaims: if the compose says more proof, validation, repo inspection, or follow-up investigation is still needed, object to any claim that the result is enough, safe, or ready to proceed confidently or without follow-up. Success-condition alignment: the success_condition_alignment field must substantively explain how the recommendation satisfies the brief\'s success condition with specifics from the analysis; flag if it is generic, formulaic, vacuous, merely restates the brief, or could be pasted into any other compose unchanged ("This satisfies the brief." is the canonical failure).',
+        'The runtime parses your response with JSON.parse, rejects verdicts the schema does not allow, and validates the full report body against explore.review-verdict@v1 before writing reports/review-verdict.json.',
+    ].join(' '),
+};
+export const exploreTournamentProposalShapeHint = {
+    kind: 'schema',
+    schema: 'explore.tournament-proposal@v1',
+    instruction: [
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "verdict": "accept", "option_id": "<the generated option id for this branch>", "option_label": "<option label>", "case_summary": "<strongest case for this option>", "assumptions": ["<assumption>"], "evidence_refs": ["<report path or file:line reference>"], "risks": ["<risk>"], "next_action": "<next action if this option is selected>", "rubric_model_judgments": { "evidence_rigor": "<pass|concern|fail>", "actionability": "<pass|concern|fail>", "coverage_adequacy": "<pass|concern|fail>", "scope_discipline": "<pass|concern|fail>", "honest_calibration": "<pass|concern|fail>", "project_specificity": "<pass|concern|fail>", "insight_density": "<pass|concern|fail>", "branch_distinctness": "<pass|concern|fail>" } }',
+        'Set every rubric_model_judgments value from your own judgment of the branch case. Runtime checks may later veto evidence_rigor, actionability, coverage_adequacy, or scope_discipline; do not try to encode runtime_signal yourself.',
+        'Argue for the option named in the branch title. Set option_id to the branch option id named in the step id and title. Do not compare every option; make the strongest evidence-backed case for this branch. Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include prose before or after the JSON object.',
+        'The runtime parses your response with JSON.parse and validates the full report body against explore.tournament-proposal@v1 before writing the branch report.',
+    ].join(' '),
+};
+export const exploreTournamentReviewShapeHint = {
+    kind: 'schema',
+    schema: 'explore.tournament-review@v1',
+    instruction: [
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "verdict": "<recommend|no-clear-winner|needs-operator>", "recommended_option_id": "<one generated option id>", "comparison": "<comparative assessment>", "objections": ["<objection>"], "missing_evidence": ["<missing evidence>"], "tradeoff_question": "<specific choice the operator must make>", "confidence": "<low|medium|high>" }',
+        'Use the proposal aggregate and source reports. Treat this as the stress review inside the Decision stage, not as a separate canonical Review stage. Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include any prose before or after the JSON object.',
+        'The runtime parses your response with JSON.parse and validates the full report body against explore.tournament-review@v1 before writing reports/tournament-review.json.',
+    ].join(' '),
+};
+//# sourceMappingURL=relay-hints.js.map

package/dist/flows/explore/relay-hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.js","sourceRoot":"","sources":["../../../src/flows/explore/relay-hints.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,4EAA4E;AAC5E,6EAA6E;AAC7E,4EAA4E;AAC5E,gFAAgF;AAIhF,MAAM,CAAC,MAAM,uBAAuB,GAAoB;IACtD,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,oBAAoB;IAC5B,WAAW,EAAE;QACX,yEAAyE;QACzE,2cAA2c;QAC3c,uQAAuQ;QACvQ,8IAA8I;QAC9I,kMAAkM;KACnM,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,CAAC,MAAM,6BAA6B,GAAoB;IAC5D,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,2BAA2B;IACnC,WAAW,EAAE;QACX,yEAAyE;QACzE,0MAA0M;QAC1M,8SAA8S;QAC9S,8MAA8M;QAC9M,0sCAA0sC;QAC1sC,gNAAgN;KACjN,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,CAAC,MAAM,kCAAkC,GAAoB;IACjE,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,gCAAgC;IACxC,WAAW,EAAE;QACX,yEAAyE;QACzE,8sBAA8sB;QAC9sB,sOAAsO;QACtO,sVAAsV;QACtV,8JAA8J;KAC/J,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAoB;IAC/D,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,8BAA8B;IACtC,WAAW,EAAE;QACX,yEAAyE;QACzE,4UAA4U;QAC5U,kSAAkS;QAClS,yKAAyK;KAC1K,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC"}