@petepetrash/circuit 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/flows/build/data.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuJN,CAAC"}

package/dist/flows/build/data.js

@@ -0,0 +1,163 @@
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { buildAssemblySpec } from './assembly-spec.js';
+import { buildContextShapeHint, buildImplementationShapeHint, buildReviewShapeHint, } from './relay-hints.js';
+import { BuildBaselineSnapshot, BuildBrief, BuildContext, BuildImplementation, BuildPlan, BuildResult, BuildReview, BuildTouchArea, BuildVerification, } from './reports.js';
+import { buildBaselineSnapshotWriter } from './writers/baseline-snapshot.js';
+import { buildBriefCheckpointBuilder } from './writers/checkpoint-brief.js';
+import { buildCloseBuilder } from './writers/close.js';
+import { buildPlanComposeBuilder } from './writers/plan.js';
+import { buildTouchAreaWriter } from './writers/touch-area.js';
+import { buildVerificationWriter } from './writers/verification.js';
+export const buildFlowData = {
+    id: 'build',
+    visibility: 'public',
+    paths: {
+        schematic: 'src/flows/build/schematic.json',
+        contract: 'src/flows/build/contract.md',
+    },
+    // First-class composition (M9): build is the assembler's first production
+    // customer. Its block sequence and flow-level scaffolding live in
+    // ./assembly-spec.ts; `assembleFlowSchematic` derives the three sequence-level
+    // fields (starts_at, stages, stage_path_policy) and returns the validated
+    // FlowSchematic that used to be hand-authored as a literal here. The M9 truth
+    // test proves the assembled schematic is byte-identical to the former literal
+    // (schematic + compiled), and that the assembled-then-compiled build runs to
+    // @complete on the shared graph runner. The assembler is now a live producer,
+    // not a test-only artifact.
+    schematic: assembleFlowSchematic(buildAssemblySpec),
+    canonicalStagePolicy: {
+        kind: 'enforce',
+        canonicals: ['frame', 'analyze', 'plan', 'act', 'verify', 'review', 'close'],
+        omits: [],
+        optional_canonicals: [],
+        variants: [],
+        title: 'Frame → Analyze → Plan → Act → Verify → Review → Close',
+        authority: 'src/flows/build/contract.md §Build Flow Contract',
+    },
+    reports: [
+        {
+            schemaName: 'build.implementation@v1',
+            channel: 'relay',
+            schema: BuildImplementation,
+            relayHint: buildImplementationShapeHint.instruction,
+        },
+        {
+            schemaName: 'build.review@v1',
+            channel: 'relay',
+            schema: BuildReview,
+            relayHint: buildReviewShapeHint.instruction,
+        },
+        {
+            schemaName: 'build.context@v1',
+            channel: 'relay',
+            schema: BuildContext,
+            relayHint: buildContextShapeHint.instruction,
+        },
+        {
+            schemaName: 'build.brief@v1',
+            channel: 'report',
+            schema: BuildBrief,
+            writers: { checkpoint: [buildBriefCheckpointBuilder] },
+        },
+        {
+            schemaName: 'build.plan@v1',
+            channel: 'report',
+            schema: BuildPlan,
+            fileSurface: {
+                timing: 'before',
+                extractor: { kind: 'build-plan-and-slices-anticipated-file-extensions' },
+            },
+            writers: { compose: [buildPlanComposeBuilder] },
+        },
+        {
+            schemaName: 'build.verification@v1',
+            channel: 'report',
+            schema: BuildVerification,
+            writers: { verification: [buildVerificationWriter] },
+        },
+        {
+            schemaName: 'build.baseline-snapshot@v1',
+            channel: 'report',
+            schema: BuildBaselineSnapshot,
+            writers: { verification: [buildBaselineSnapshotWriter] },
+        },
+        {
+            schemaName: 'build.touch-area@v1',
+            channel: 'report',
+            schema: BuildTouchArea,
+            writers: { verification: [buildTouchAreaWriter] },
+        },
+        {
+            schemaName: 'build.result@v1',
+            channel: 'report',
+            schema: BuildResult,
+            writers: { close: [buildCloseBuilder] },
+        },
+    ],
+    runtimeSurface: {
+        primaryResult: {
+            schemaName: 'build.result@v1',
+            path: 'reports/build-result.json',
+            label: 'Build result',
+        },
+        progress: {
+            steps: [
+                {
+                    stepId: 'frame-step',
+                    taskTitle: 'Frame the work',
+                    activeText: 'Framing the work',
+                },
+                {
+                    stepId: 'analyze-step',
+                    taskTitle: 'Read the code',
+                    activeText: 'Reading the code',
+                    relayRole: 'researcher',
+                    relayStartedText: 'Asking the specialist to read the code...',
+                    relayCompletedText: 'Finished reading the code.',
+                },
+                {
+                    stepId: 'plan-step',
+                    taskTitle: 'Plan the work',
+                    activeText: 'Planning the work',
+                },
+                {
+                    stepId: 'build-baseline',
+                    taskTitle: 'Note the starting point',
+                    activeText: 'Noting the starting point',
+                },
+                {
+                    stepId: 'act-step',
+                    taskTitle: 'Make the change',
+                    activeText: 'Making the change',
+                    relayRole: 'implementer',
+                    relayStartedText: 'Asking the specialist to make the change...',
+                    relayCompletedText: 'Finished the specialist pass.',
+                },
+                {
+                    stepId: 'verify-step',
+                    taskTitle: 'Check the work',
+                    activeText: 'Checking the work',
+                },
+                {
+                    stepId: 'build-touch-area',
+                    taskTitle: 'Check what changed',
+                    activeText: 'Checking what changed',
+                },
+                {
+                    stepId: 'review-step',
+                    taskTitle: 'Check the result',
+                    activeText: 'Checking the result',
+                    relayRole: 'reviewer',
+                    relayStartedText: 'Asking the reviewer to check the result...',
+                    relayCompletedText: 'Finished checking the result.',
+                },
+                {
+                    stepId: 'close-step',
+                    taskTitle: 'Wrap up',
+                    activeText: 'Wrapping up',
+                },
+            ],
+        },
+    },
+};
+//# sourceMappingURL=data.js.map

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

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

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

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

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

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

package/dist/flows/build/flow.js

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flows/build/index.ts"],"names":[],"mappings":"AAGA,QAAA,MAAM,mBAAmB,2CAA6C,CAAC;AAEvE,OAAO,EAAE,mBAAmB,IAAI,wBAAwB,EAAE,CAAC;AAG3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC"}

package/dist/flows/build/index.js

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

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

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

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

@@ -0,0 +1,5 @@
+import type { SchemaShapeHint } from '../registries/shape-hints/types.js';
+export declare const buildContextShapeHint: SchemaShapeHint;
+export declare const buildImplementationShapeHint: SchemaShapeHint;
+export declare const buildReviewShapeHint: SchemaShapeHint;
+//# sourceMappingURL=relay-hints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.d.ts","sourceRoot":"","sources":["../../../src/flows/build/relay-hints.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAG1E,eAAO,MAAM,qBAAqB,EAAE,eAanC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,eAc1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,eAWlC,CAAC"}

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

@@ -0,0 +1,51 @@
+// Build flow relay shape hints.
+//
+// The literal JSON shape for each instruction is rendered from the step's
+// Zod report schema via `renderShapeSkeleton`; field-level placeholders come
+// from `.describe()` calls in `reports.ts`. Authors keep the task-specific
+// guidance and the shared mechanical tail as authored prose.
+import { renderShapeSkeleton } from '../registries/shape-hints/from-zod.js';
+import { mechanicalTail, shapeInstruction } from '../registries/shape-hints/instruction-helpers.js';
+import { BuildContext, BuildImplementation, BuildReview } from './reports.js';
+export const buildContextShapeHint = {
+    kind: 'schema',
+    schema: 'build.context@v1',
+    instruction: [
+        shapeInstruction(renderShapeSkeleton(BuildContext)),
+        "Read the relevant source and tests before planning. This step is read-only by intent: do not edit files, write files, or run commands that modify the checkout. Scale the breadth of your reading to the run's stated depth (provided to you): at low depth read just the directly implicated files; at high depth map the surrounding modules, callers, and local conventions. sources must contain at least one entry; observations must contain at least one entry. Use an empty open_questions array only when nothing remains unresolved. Every observation must be grounded in the cited sources - do not invent details the sources do not support.",
+        'In anticipated_file_extensions, predict the file extensions the implementer will likely touch based on what you read (for example .ts and .test.ts for a typed code change with tests). Use the implementation file types, not every file you read. Use an empty array only when the read gives no confident prediction. This list is advisory: it scopes and warns, it does not bind the implementer.',
+        'In slices, decompose the change into an ordered list of independently-verifiable units of implementation work - each a concrete step a worker implements and verification can confirm before the next begins - ordered so each builds on the last. Do NOT include global gates such as "verification passes" or "review completes"; those are not units of work. Give each slice a stable id (slice-1, slice-2, ...) and its own anticipated_file_extensions. Keep the list short: prefer the fewest slices that make the work safely incremental, and use a single slice (or an empty array) when the change is one indivisible unit. At high depth the engine implements and verifies these one at a time; at lower depths the change runs in a single pass regardless.',
+        'In guardrails, capture the negative space of the change. Put in non_goals the things the operator said the change must NOT do - boundaries drawn from the goal and brief, not invented. Put in invariants the properties the change must preserve, grounded in what you read (a contract, a data shape, an ordering, a safety property). Both default to empty arrays: declare a guardrail only when it is real and specific, never a generic "do not break anything". These carry forward to the plan and the reviewer checks the change against them.',
+        'In allowed_touch_area, name the paths this change is allowed to touch, proposed from what you read - either a directory subtree ending in "/" (for example "src/flows/build/", which covers everything beneath it) or an exact repo-relative file path. Include every place a correct change legitimately needs to reach: the source it edits, the tests that cover it, and any generated output it regenerates. State the allowed area positively; do not list off-limits files. After the build the engine compares the files actually changed - proven from git, not self-reported - against this area, and a change that reaches outside it cannot finish clean. Because the implementer is held to this without trimming the work to fit, leave the array empty whenever you cannot scope the change with confidence: an empty area turns the check off rather than guessing a box.',
+        'Include recommended_power ONLY when the relay context states the power dial is auto; omit the key entirely otherwise. When you do include it, judge from the codebase read how strong a model the downstream implementation and review need: "low" for a small localized change with good test coverage, "high" for a wide, subtle, or weakly-tested change, "medium" between. One short rationale sentence.',
+        mechanicalTail('build.context@v1', 'reports/build/context.json'),
+    ].join(' '),
+};
+export const buildImplementationShapeHint = {
+    kind: 'schema',
+    schema: 'build.implementation@v1',
+    instruction: [
+        shapeInstruction(renderShapeSkeleton(BuildImplementation)),
+        'Make the smallest behaviorally scoped change that satisfies the requested goal. Do not broaden semantics, normalize data, or add extra behavior just because tests still pass.',
+        'The plan may carry guardrails: non_goals (things this change must NOT do) and invariants (properties it must preserve). Stay inside the non_goals and preserve every invariant. These are advisory to you here, but the reviewer checks the finished change against them, so a violation will surface as a finding.',
+        "When the request names a current slice (its id and intent), implement ONLY that slice's unit of work - the smallest change that satisfies that slice's intent - and leave later slices for their own turn. When no current slice is named, implement the whole plan in one pass. Report changed_files cumulatively: every file changed so far across all slices, not only this slice's files.",
+        "The plan's anticipated_file_extensions (and the current slice's, when named) list the file types the grounding read expects to touch. Treat them as an advisory starting scope, not a hard limit: if the real change needs other file types, make the change and report the files you actually touched.",
+        'The plan may also carry allowed_touch_area: the paths the grounding read predicted this change should reach. It is advisory to you, not a cage - implement what the slice and goal actually require and report every file you really changed. After you finish, the engine compares your git-proven changes against that area; reaching outside it does not fail the build but surfaces for a human to confirm, so do not pad the change with edits it does not need, and do not trim a necessary change just to stay inside the predicted box.',
+        'Use an empty changed_files array only when no file changed. Evidence must contain at least one item.',
+        'When the thin envelope you were handed is missing a specific named slice of an upstream report you genuinely need to do the work, you may ask for it through context_request: name one parent step and one dotted field, and request only the slice you are truly missing - never reflexively, and never an everything ask. If the slice you need is not available to pull, say so honestly in your evidence and proceed on the context you have; do not invent what you could not read.',
+        mechanicalTail('build.implementation@v1', 'reports/build/implementation.json'),
+    ].join(' '),
+};
+export const buildReviewShapeHint = {
+    kind: 'schema',
+    schema: 'build.review@v1',
+    instruction: [
+        shapeInstruction(renderShapeSkeleton(BuildReview)),
+        'Review the change against the requested scope, not just against passing tests. Flag behavior that broadens semantics beyond the goal even when verification passes.',
+        'alignment is required. Set scope_adherence by judging the finished change against the brief: within_scope when it does only what the goal asked, exceeds_scope when it reaches beyond. Add one non_goals entry per non_goal the plan declared and one invariants entry per invariant, each restating the plan\'s text with a status and concrete evidence; use empty arrays only when the plan declared none. If you set scope_adherence to exceeds_scope, or mark any non_goal violated or any invariant violated, the verdict cannot be "accept" and you must include at least one finding that explains the breach.',
+        "You are also given a git-proven touch_area report: the files the change actually modified and whether they stayed inside the plan's allowed_touch_area. Treat it as ground truth about what was physically touched - more reliable than the implementer's self-reported file list - and let it inform your scope_adherence judgment and your evidence. The engine enforces that boundary separately at close, so your job here is the semantic call, not to re-run the boundary check.",
+        'Use an empty findings array only with verdict "accept". Verdicts "accept-with-fixes" and "reject" must include at least one finding. Use an empty file_refs array when a finding has no file-specific reference.',
+        mechanicalTail('build.review@v1', 'reports/build/review.json'),
+    ].join(' '),
+};
+//# sourceMappingURL=relay-hints.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.js","sourceRoot":"","sources":["../../../src/flows/build/relay-hints.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAChC,EAAE;AACF,0EAA0E;AAC1E,6EAA6E;AAC7E,2EAA2E;AAC3E,6DAA6D;AAE7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAEpG,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE9E,MAAM,CAAC,MAAM,qBAAqB,GAAoB;IACpD,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,kBAAkB;IAC1B,WAAW,EAAE;QACX,gBAAgB,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;QACnD,4nBAA4nB;QAC5nB,wYAAwY;QACxY,2uBAA2uB;QAC3uB,yhBAAyhB;QACzhB,01BAA01B;QAC11B,8YAA8Y;QAC9Y,cAAc,CAAC,kBAAkB,EAAE,4BAA4B,CAAC;KACjE,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,CAAC,MAAM,4BAA4B,GAAoB;IAC3D,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,yBAAyB;IACjC,WAAW,EAAE;QACX,gBAAgB,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,CAAC;QAC1D,gLAAgL;QAChL,qTAAqT;QACrT,+XAA+X;QAC/X,ySAAyS;QACzS,ihBAAihB;QACjhB,sGAAsG;QACtG,0dAA0d;QAC1d,cAAc,CAAC,yBAAyB,EAAE,mCAAmC,CAAC;KAC/E,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAoB;IACnD,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,iBAAiB;IACzB,WAAW,EAAE;QACX,gBAAgB,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC;QAClD,qKAAqK;QACrK,wlBAAwlB;QACxlB,wdAAwd;QACxd,kNAAkN;QAClN,cAAc,CAAC,iBAAiB,EAAE,2BAA2B,CAAC;KAC/D,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC"}