@petepetrash/circuit 0.1.0

package/dist/schemas/custom-flow-descriptor.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const CustomFlowPackageDescriptor: z.ZodObject<{
+    schema_version: z.ZodLiteral<1>;
+    id: z.core.$ZodBranded<z.ZodString, "CompiledFlowId", "out">;
+    format: z.ZodLiteral<"compiled-flow-package">;
+    compiled_flow: z.ZodLiteral<"circuit.json">;
+    purpose: z.ZodString;
+}, z.core.$strict>;
+export type CustomFlowPackageDescriptor = z.infer<typeof CustomFlowPackageDescriptor>;
+//# sourceMappingURL=custom-flow-descriptor.d.ts.map

package/dist/schemas/custom-flow-descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-flow-descriptor.d.ts","sourceRoot":"","sources":["../../src/schemas/custom-flow-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,2BAA2B;;;;;;kBAQ7B,CAAC;AACZ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/schemas/custom-flow-descriptor.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { CompiledFlowId } from './ids.js';
+export const CustomFlowPackageDescriptor = z
+    .object({
+    schema_version: z.literal(1),
+    id: CompiledFlowId,
+    format: z.literal('compiled-flow-package'),
+    compiled_flow: z.literal('circuit.json'),
+    purpose: z.string().min(1),
+})
+    .strict();
+//# sourceMappingURL=custom-flow-descriptor.js.map

package/dist/schemas/custom-flow-descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-flow-descriptor.js","sourceRoot":"","sources":["../../src/schemas/custom-flow-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC;KACzC,MAAM,CAAC;IACN,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5B,EAAE,EAAE,cAAc;IAClB,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,uBAAuB,CAAC;IAC1C,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC;IACxC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC3B,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/schemas/depth.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const Depth: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+}>;
+export type Depth = z.infer<typeof Depth>;
+export declare const CompiledDepth: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    tournament: "tournament";
+    autonomous: "autonomous";
+}>;
+export type CompiledDepth = z.infer<typeof CompiledDepth>;
+//# sourceMappingURL=depth.d.ts.map

package/dist/schemas/depth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth.d.ts","sourceRoot":"","sources":["../../src/schemas/depth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,KAAK;;;;EAAoC,CAAC;AACvD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAI1C,eAAO,MAAM,aAAa;;;;;;EAAgE,CAAC;AAC3F,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/depth.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+// Operator-facing process dial. One of the two run dials (depth x power).
+export const Depth = z.enum(['low', 'medium', 'high']);
+// Compiled run thoroughness: the depth dial unioned with the mode flags,
+// used where a single scalar describes how hard a run goes.
+export const CompiledDepth = z.enum(['low', 'medium', 'high', 'tournament', 'autonomous']);
+//# sourceMappingURL=depth.js.map

package/dist/schemas/depth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depth.js","sourceRoot":"","sources":["../../src/schemas/depth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,0EAA0E;AAC1E,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;AAGvD,yEAAyE;AACzE,4DAA4D;AAC5D,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC"}

package/dist/schemas/engine-flags.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const EngineFlagsManifest: z.ZodObject<{
+    binds_execution_depth_to_relay_selection: z.ZodOptional<z.ZodBoolean>;
+    binds_terminal_outcome_to_primary_result: z.ZodOptional<z.ZodBoolean>;
+    iterates_slice_loop: z.ZodOptional<z.ZodObject<{
+        head_step: z.ZodString;
+        tail_step: z.ZodString;
+        advance_route: z.ZodString;
+        slices_from: z.ZodObject<{
+            report: z.ZodString;
+            items_path: z.ZodString;
+        }, z.core.$strict>;
+        max_slices: z.ZodNumber;
+        activate_when_depth_at_least: z.ZodLiteral<"high">;
+    }, z.core.$strict>>;
+    iterates_until_condition: z.ZodOptional<z.ZodObject<{
+        head_step: z.ZodString;
+        tail_step: z.ZodString;
+        body_steps: z.ZodArray<z.ZodString>;
+        reenter_route: z.ZodString;
+        max_iterations: z.ZodNumber;
+        stop_judge: z.ZodOptional<z.ZodObject<{
+            report: z.ZodString;
+            goal_met_path: z.ZodString;
+            lesson_path: z.ZodOptional<z.ZodString>;
+            progress_path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        needs_attention_route: z.ZodOptional<z.ZodString>;
+        carried_notes: z.ZodOptional<z.ZodObject<{
+            report: z.ZodString;
+            max_entries: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        cumulative_usd_cap: z.ZodOptional<z.ZodNumber>;
+        cumulative_token_cap: z.ZodOptional<z.ZodNumber>;
+        no_progress_ceiling: z.ZodOptional<z.ZodNumber>;
+        iteration_commit_containment: z.ZodOptional<z.ZodObject<{
+            branch_prefix: z.ZodString;
+        }, z.core.$strict>>;
+        frozen_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        activate_when_depth_at_least: z.ZodLiteral<"autonomous">;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type EngineFlagsManifest = z.infer<typeof EngineFlagsManifest>;
+//# sourceMappingURL=engine-flags.d.ts.map

package/dist/schemas/engine-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-flags.d.ts","sourceRoot":"","sources":["../../src/schemas/engine-flags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2FrB,CAAC;AACZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/schemas/engine-flags.js

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+// Stage 3 (first-class composition): the serialized, snake_case shape of a
+// flow's engine-visible behavior flags. One schema, two homes: the authored
+// FlowSchematic carries it so a flow (built-in or composed) can DECLARE
+// behavior, and the compiled manifest carries it so the engine can READ that
+// behavior without a by-id catalog package lookup. It mirrors the in-code
+// `CompiledFlowEngineFlags` (camelCase) in src/flows/types.ts; the
+// manifest->runtime boundary (`manifestEngineFlagsToInCode`) translates between
+// the two. Absent = the flow declares no engine flags.
+//
+// See docs/ideas/first-class-composition-sequence.md (Stage 3).
+export const EngineFlagsManifest = z
+    .object({
+    binds_execution_depth_to_relay_selection: z.boolean().optional(),
+    binds_terminal_outcome_to_primary_result: z.boolean().optional(),
+    iterates_slice_loop: z
+        .object({
+        head_step: z.string().min(1),
+        tail_step: z.string().min(1),
+        advance_route: z.string().min(1),
+        slices_from: z
+            .object({
+            report: z.string().min(1),
+            items_path: z.string().min(1),
+        })
+            .strict(),
+        max_slices: z.number().int().positive(),
+        activate_when_depth_at_least: z.literal('high'),
+    })
+        .strict()
+        .optional(),
+    // The until loop (a while loop for flows): re-enter [head..tail] once per
+    // iteration until max_iterations. Mutually exclusive with iterates_slice_loop
+    // (both drive one re-entry counter); the graph runner rejects a flow that
+    // sets both. body_steps is the full span head and tail included, because
+    // every body step must be iteration-scoped, not just the adjacent head/tail
+    // the slice loop scopes. See docs/ideas/until-loop.md.
+    iterates_until_condition: z
+        .object({
+        head_step: z.string().min(1),
+        tail_step: z.string().min(1),
+        body_steps: z.array(z.string().min(1)).min(1),
+        reenter_route: z.string().min(1),
+        max_iterations: z.number().int().positive(),
+        // Slice 2 (the stop-judge): the tail proposes a goal-met boolean the
+        // engine disposes against an evidence floor. report + goal_met_path say
+        // where to read the proposal; needs_attention_route is where an exhausted
+        // judge-gated loop exits (a non-@complete terminal). Both absent = the
+        // slice-1 count-driven form. lesson_path (slice 4) and progress_path
+        // (slice 6) are optional dotted paths to a carried lesson and an opaque
+        // progress marker the engine disposes; absent = those features off.
+        stop_judge: z
+            .object({
+            report: z.string().min(1),
+            goal_met_path: z.string().min(1),
+            lesson_path: z.string().min(1).optional(),
+            progress_path: z.string().min(1).optional(),
+        })
+            .strict()
+            .optional(),
+        needs_attention_route: z.string().min(1).optional(),
+        // Slice 4 (carried notes): the run-file the engine appends one note to per
+        // iteration; the head re-reads it next pass. max_entries caps retained
+        // notes (default 20). Absent = no notes carried.
+        carried_notes: z
+            .object({
+            report: z.string().min(1),
+            max_entries: z.number().int().positive().optional(),
+        })
+            .strict()
+            .optional(),
+        // Slice 5 (cumulative budget cap, fail-closed): hard spend ceilings summed
+        // across iterations from per-relay usage. At or above the cap the loop exits
+        // to needs_attention rather than spending more. Absent = no cap.
+        cumulative_usd_cap: z.number().positive().optional(),
+        cumulative_token_cap: z.number().int().positive().optional(),
+        // Slice 6 (no-progress ceiling): consecutive no-progress iterations
+        // tolerated before exiting to needs_attention. Requires
+        // stop_judge.progress_path. Absent = only the iteration cap bounds the loop.
+        no_progress_ceiling: z.number().int().positive().optional(),
+        // Slice 7 (per-iteration commit containment, opt-in, default off). When
+        // set AND the host injects a commit-containment runner, each iteration
+        // is committed to a throwaway branch named `${branch_prefix}-${run_id}`;
+        // the operator owns the merge. Absent => the engine makes zero git calls.
+        iteration_commit_containment: z
+            .object({
+            branch_prefix: z.string().min(1),
+        })
+            .strict()
+            .optional(),
+        // The loop's read-only eval surface (the test files, the verify command's
+        // own definition, a spec or expected file). The engine fingerprints these
+        // at loop entry and, at each tail seam, opens an honesty-ledger latch if a
+        // body iteration changed one — so the floor cannot honor that iteration's
+        // goal-met claim. Generic engine mechanism only; no shipped flow sets it
+        // (freezing real repo paths is a deliberate NEXT slice). Absent = off.
+        frozen_paths: z.array(z.string().min(1)).min(1).optional(),
+        activate_when_depth_at_least: z.literal('autonomous'),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+//# sourceMappingURL=engine-flags.js.map

package/dist/schemas/engine-flags.js.map

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

package/dist/schemas/equipment-discovery.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const EquipmentDiscovery: z.ZodObject<{
+    confirmed: z.ZodBoolean;
+    domain_tags: z.ZodArray<z.ZodString>;
+    evidence: z.ZodString;
+}, z.core.$strict>;
+export type EquipmentDiscovery = z.infer<typeof EquipmentDiscovery>;
+//# sourceMappingURL=equipment-discovery.d.ts.map

package/dist/schemas/equipment-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipment-discovery.d.ts","sourceRoot":"","sources":["../../src/schemas/equipment-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,kBAAkB;;;;kBAsBpB,CAAC;AACZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/schemas/equipment-discovery.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+// A runtime equipment discovery a researcher relay bubbles UP: what it learned
+// reading the code that the assembly-time equipment choice did not know — e.g.
+// "this turned out to be a React app, equip the remaining steps for it." It is
+// the trigger for the first live reshape (Step 2): the engine acts on it ONLY
+// when `confirmed` is true (unambiguous evidence, never a hunch), re-resolves
+// equipment on the remaining relay steps, and re-validates the whole flow
+// through the compiled-flow gate before continuing. An unconfirmed discovery is
+// recorded as a finding and changes nothing.
+//
+// Sibling of PowerRecommendation (schemas/power.ts): the same shape of in-run
+// signal a researcher emits in its report, read field-tolerantly at the
+// post-step seam (see runtime/run/equipment-reshape.ts). Kept import-free (zod
+// only) so any report schema can reference it without an import cycle.
+export const EquipmentDiscovery = z
+    .object({
+    confirmed: z
+        .boolean()
+        .describe('true ONLY on unambiguous runtime evidence; a hunch or a maybe must be false'),
+    // Bounded on both axes: the value is model-controlled and is copied verbatim
+    // into the durable run.equipment-reshape trace entry. Only a handful of tags
+    // map to a domain skill (the closed DOMAIN_SKILL table), so a long list is
+    // never useful — the caps just keep a pathological report from bloating the
+    // trace. Mirrors the evidence cap above.
+    domain_tags: z
+        .array(z.string().min(1).max(40))
+        .max(16)
+        .describe('technology signals confirmed at runtime, e.g. ["react"], that map to domain skills'),
+    evidence: z
+        .string()
+        .min(1)
+        .max(280)
+        .describe('one short sentence grounding the discovery in what was read'),
+})
+    .strict();
+//# sourceMappingURL=equipment-discovery.js.map

package/dist/schemas/equipment-discovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipment-discovery.js","sourceRoot":"","sources":["../../src/schemas/equipment-discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,+EAA+E;AAC/E,+EAA+E;AAC/E,+EAA+E;AAC/E,8EAA8E;AAC9E,8EAA8E;AAC9E,0EAA0E;AAC1E,gFAAgF;AAChF,6CAA6C;AAC7C,EAAE;AACF,8EAA8E;AAC9E,wEAAwE;AACxE,+EAA+E;AAC/E,uEAAuE;AACvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC;KAChC,MAAM,CAAC;IACN,SAAS,EAAE,CAAC;SACT,OAAO,EAAE;SACT,QAAQ,CAAC,6EAA6E,CAAC;IAC1F,6EAA6E;IAC7E,6EAA6E;IAC7E,2EAA2E;IAC3E,4EAA4E;IAC5E,yCAAyC;IACzC,WAAW,EAAE,CAAC;SACX,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;SAChC,GAAG,CAAC,EAAE,CAAC;SACP,QAAQ,CACP,oFAAoF,CACrF;IACH,QAAQ,EAAE,CAAC;SACR,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,GAAG,CAAC;SACR,QAAQ,CAAC,6DAA6D,CAAC;CAC3E,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/schemas/equipment-scope.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * EquipmentScope — the declared per-step "equipment" field for the tools axis.
+ *
+ * Equipment scope makes "how much capability a worker is given" a declared
+ * field on a step rather than an accident of which flow you picked. This field
+ * governs the TOOLS sub-axis (the skills sub-axis rides the existing
+ * `skill_slots` field). It is authored manifest-first on the schematic step and
+ * compiled onto the runtime step, exactly like `skill_slots` — the engine reads
+ * it off the step, never from a catalog keyed by flow id.
+ *
+ * See docs/ideas/e2-equipment-scope-spec.md (the design) and
+ * docs/ideas/equipment-scope-build-brief.md (the build brief).
+ */
+export declare const EquipmentToolName: z.ZodString;
+export type EquipmentToolName = z.infer<typeof EquipmentToolName>;
+export declare const EquipmentToolAllowList: z.ZodObject<{
+    allow: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type EquipmentToolAllowList = z.infer<typeof EquipmentToolAllowList>;
+export declare const EquipmentToolScope: z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+    allow: z.ZodArray<z.ZodString>;
+}, z.core.$strict>]>;
+export type EquipmentToolScope = z.infer<typeof EquipmentToolScope>;
+export declare const EquipmentEnforcement: z.ZodEnum<{
+    trusted: "trusted";
+    enforced: "enforced";
+}>;
+export type EquipmentEnforcement = z.infer<typeof EquipmentEnforcement>;
+export declare const EquipmentScope: z.ZodObject<{
+    tools: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"full">, z.ZodObject<{
+        allow: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>]>>;
+    enforcement: z.ZodDefault<z.ZodEnum<{
+        trusted: "trusted";
+        enforced: "enforced";
+    }>>;
+}, z.core.$strict>;
+export type EquipmentScope = z.infer<typeof EquipmentScope>;
+export declare const DEFAULT_EQUIPMENT_SCOPE: EquipmentScope;
+export declare function isDefaultEquipmentScope(scope: EquipmentScope): boolean;
+//# sourceMappingURL=equipment-scope.d.ts.map

package/dist/schemas/equipment-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipment-scope.d.ts","sourceRoot":"","sources":["../../src/schemas/equipment-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;GAYG;AAOH,eAAO,MAAM,iBAAiB,aAAoB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAKlE,eAAO,MAAM,sBAAsB;;kBAiB/B,CAAC;AACL,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAM5E,eAAO,MAAM,kBAAkB;;oBAAuD,CAAC;AACvF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAWpE,eAAO,MAAM,oBAAoB;;;EAAkC,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,eAAO,MAAM,cAAc;;;;;;;;kBAiBvB,CAAC;AACL,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAK5D,eAAO,MAAM,uBAAuB,EAAE,cAGpC,CAAC;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAEtE"}

package/dist/schemas/equipment-scope.js

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+/**
+ * EquipmentScope — the declared per-step "equipment" field for the tools axis.
+ *
+ * Equipment scope makes "how much capability a worker is given" a declared
+ * field on a step rather than an accident of which flow you picked. This field
+ * governs the TOOLS sub-axis (the skills sub-axis rides the existing
+ * `skill_slots` field). It is authored manifest-first on the schematic step and
+ * compiled onto the runtime step, exactly like `skill_slots` — the engine reads
+ * it off the step, never from a catalog keyed by flow id.
+ *
+ * See docs/ideas/e2-equipment-scope-spec.md (the design) and
+ * docs/ideas/equipment-scope-build-brief.md (the build brief).
+ */
+// A tool a worker may be granted (e.g. "Read", "Edit", "Bash"). Kept as a
+// permissive non-empty string: the connector layer owns the concrete tool
+// vocabulary per host, and equipment scope only needs to carry the author's
+// declared list. The runtime maps these names to a connector's native tool
+// surface when it enforces them.
+export const EquipmentToolName = z.string().min(1);
+// An explicit allow-list: the worker is scoped to exactly these tools. Rejects
+// an empty list (an empty scope is a contradiction — express "no restriction"
+// with the literal "full") and duplicate entries (an authoring slip).
+export const EquipmentToolAllowList = z
+    .object({
+    allow: z.array(EquipmentToolName).min(1),
+})
+    .strict()
+    .superRefine((scope, ctx) => {
+    const seen = new Set();
+    for (const [index, tool] of scope.allow.entries()) {
+        if (seen.has(tool)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['allow', index],
+                message: `duplicate tool '${tool}'`,
+            });
+        }
+        seen.add(tool);
+    }
+});
+// The capability set a step's worker is scoped to.
+//   "full"          — today's implicit default: the worker keeps the
+//                     connector's full tool surface (no restriction).
+//   { allow: [...] } — the worker is scoped to exactly this tool list.
+export const EquipmentToolScope = z.union([z.literal('full'), EquipmentToolAllowList]);
+// Whether the declared tool scope is merely offered to the worker (trusted) or
+// actually restricts what the worker can invoke at the write tier (enforced).
+//
+//   "trusted"  — the safe default. The scope is rendered to the worker as
+//                guidance; the substrate reports it honestly as not-enforced.
+//   "enforced" — the scope is a real boundary. Honorable only where the
+//                connector can restrict tools; on a connector that cannot, the
+//                runtime downgrades the binding to trusted and records a finding.
+//                Never displayed as enforced when it was downgraded.
+export const EquipmentEnforcement = z.enum(['trusted', 'enforced']);
+export const EquipmentScope = z
+    .object({
+    tools: EquipmentToolScope.default('full'),
+    enforcement: EquipmentEnforcement.default('trusted'),
+})
+    .strict()
+    .superRefine((scope, ctx) => {
+    // Enforcing "full" is a contradiction: there is nothing to restrict to.
+    // An enforced binding must name the tools it restricts the worker to.
+    if (scope.enforcement === 'enforced' && scope.tools === 'full') {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['enforcement'],
+            message: 'enforced equipment scope requires an explicit tools allow-list (there is nothing to restrict when tools is "full")',
+        });
+    }
+});
+// The value an absent field is equivalent to: the connector's full tool surface,
+// offered (not enforced). The compiler omits the field from compiled output when
+// it carries this no-op value, so flows that declare nothing stay byte-stable.
+export const DEFAULT_EQUIPMENT_SCOPE = Object.freeze({
+    tools: 'full',
+    enforcement: 'trusted',
+});
+export function isDefaultEquipmentScope(scope) {
+    return scope.tools === 'full' && scope.enforcement === 'trusted';
+}
+//# sourceMappingURL=equipment-scope.js.map

package/dist/schemas/equipment-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipment-scope.js","sourceRoot":"","sources":["../../src/schemas/equipment-scope.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;GAYG;AAEH,0EAA0E;AAC1E,0EAA0E;AAC1E,4EAA4E;AAC5E,2EAA2E;AAC3E,iCAAiC;AACjC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AAGnD,+EAA+E;AAC/E,8EAA8E;AAC9E,sEAAsE;AACtE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC;KACpC,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CACzC,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;IAC1B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QAClD,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC;gBACtB,OAAO,EAAE,mBAAmB,IAAI,GAAG;aACpC,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;AACH,CAAC,CAAC,CAAC;AAGL,mDAAmD;AACnD,qEAAqE;AACrE,sEAAsE;AACtE,uEAAuE;AACvE,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC;AAGvF,+EAA+E;AAC/E,8EAA8E;AAC9E,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,wEAAwE;AACxE,+EAA+E;AAC/E,kFAAkF;AAClF,qEAAqE;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC;AAGpE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC;KAC5B,MAAM,CAAC;IACN,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC;IACzC,WAAW,EAAE,oBAAoB,CAAC,OAAO,CAAC,SAAS,CAAC;CACrD,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE;IAC1B,wEAAwE;IACxE,sEAAsE;IACtE,IAAI,KAAK,CAAC,WAAW,KAAK,UAAU,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM,EAAE,CAAC;QAC/D,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,aAAa,CAAC;YACrB,OAAO,EACL,oHAAoH;SACvH,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC;AAGL,iFAAiF;AACjF,iFAAiF;AACjF,+EAA+E;AAC/E,MAAM,CAAC,MAAM,uBAAuB,GAAmB,MAAM,CAAC,MAAM,CAAC;IACnE,KAAK,EAAE,MAAM;IACb,WAAW,EAAE,SAAS;CACvB,CAAC,CAAC;AAEH,MAAM,UAAU,uBAAuB,CAAC,KAAqB;IAC3D,OAAO,KAAK,CAAC,KAAK,KAAK,MAAM,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC;AACnE,CAAC"}

package/dist/schemas/flow-block-definitions.d.ts

@@ -0,0 +1,59 @@
+import type { z } from 'zod';
+import { type FlowBlock as FlowBlockSchema } from './flow-blocks.js';
+import { type CanonicalStage } from './stage.js';
+export type FlowBlockSchematicExecutionKind = 'compose' | 'relay' | 'verification' | 'checkpoint' | 'sub-run' | 'fanout';
+export interface FlowBlockSchematicPolicy {
+    readonly executionKinds: readonly FlowBlockSchematicExecutionKind[];
+    readonly stages: readonly CanonicalStage[];
+}
+export type FlowBlockAuthoringDefaultEvidence = 'block-produces-evidence';
+export type FlowBlockAuthoringDefaultOutput = 'block-output-contract';
+export type FlowBlockAuthoringRequiredField = 'id' | 'title' | 'stage' | 'input' | 'routes' | 'protocol' | 'writes' | 'check' | 'relay_role' | 'checkpoint_policy' | 'fanout' | 'sub_run_ref' | 'sub_run_goal' | 'sub_run_depth';
+export interface FlowBlockAuthoringPolicy {
+    readonly defaults: {
+        readonly evidenceRequirements: FlowBlockAuthoringDefaultEvidence;
+        readonly output: FlowBlockAuthoringDefaultOutput;
+        readonly executionKind?: FlowBlockSchematicExecutionKind;
+    };
+    readonly required: {
+        readonly always: readonly FlowBlockAuthoringRequiredField[];
+        readonly whenExecutionKind: Partial<Record<FlowBlockSchematicExecutionKind, readonly FlowBlockAuthoringRequiredField[]>>;
+    };
+}
+type FlowBlockInput = z.input<typeof FlowBlockSchema>;
+type FlowBlockDefinitionInput = FlowBlockInput & {
+    readonly schematicPolicy: FlowBlockSchematicPolicy;
+};
+export type FlowBlockDefinition = FlowBlockDefinitionInput & {
+    readonly authoringPolicy: FlowBlockAuthoringPolicy;
+};
+export declare const FLOW_BLOCK_DEFINITIONS: FlowBlockDefinition[];
+export declare const FLOW_BLOCK_CATALOG: {
+    schema_version: "1";
+    blocks: {
+        id: "handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint";
+        title: string;
+        purpose: string;
+        input_contracts: string[];
+        alternative_input_contracts: string[][];
+        output_contract: string;
+        action_surface: "orchestrator" | "worker" | "host" | "mixed";
+        produces_evidence: string[];
+        check: {
+            kind: "command" | "schema" | "risk" | "review" | "queue" | "decision" | "coordination";
+            description: string;
+        };
+        allowed_routes: ("complete" | "handoff" | "split" | "continue" | "checkpoint" | "stop" | "escalate" | "review" | "retry" | "close" | "blocked" | "run-fix" | "run-review" | "run-explore" | "split-to-pursue" | "pursue" | "connector-failed" | "revise" | "ask" | "fix" | "build" | "explore" | "completion-gate" | "retry-selected-flow" | "recover" | "run-next-gate-pass" | "advance")[];
+        human_interaction: "never" | "optional" | "required" | "mode-dependent";
+        host_capabilities: {
+            claude: string[];
+            codex: string[];
+            non_interactive: string[];
+        };
+        notes?: string | undefined;
+    }[];
+};
+export declare const FLOW_BLOCK_SCHEMATIC_POLICY: Record<"handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint", FlowBlockSchematicPolicy>;
+export declare const FLOW_BLOCK_AUTHORING_POLICY: Record<"handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint", FlowBlockAuthoringPolicy>;
+export {};
+//# sourceMappingURL=flow-block-definitions.d.ts.map

package/dist/schemas/flow-block-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-block-definitions.d.ts","sourceRoot":"","sources":["../../src/schemas/flow-block-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EAGL,KAAK,SAAS,IAAI,eAAe,EAClC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,MAAM,+BAA+B,GACvC,SAAS,GACT,OAAO,GACP,cAAc,GACd,YAAY,GACZ,SAAS,GACT,QAAQ,CAAC;AAEb,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,cAAc,EAAE,SAAS,+BAA+B,EAAE,CAAC;IACpE,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;CAC5C;AAED,MAAM,MAAM,iCAAiC,GAAG,yBAAyB,CAAC;AAC1E,MAAM,MAAM,+BAA+B,GAAG,uBAAuB,CAAC;AAEtE,MAAM,MAAM,+BAA+B,GACvC,IAAI,GACJ,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,OAAO,GACP,YAAY,GACZ,mBAAmB,GACnB,QAAQ,GACR,aAAa,GACb,cAAc,GACd,eAAe,CAAC;AAEpB,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,oBAAoB,EAAE,iCAAiC,CAAC;QACjE,QAAQ,CAAC,MAAM,EAAE,+BAA+B,CAAC;QACjD,QAAQ,CAAC,aAAa,CAAC,EAAE,+BAA+B,CAAC;KAC1D,CAAC;IACF,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,MAAM,EAAE,SAAS,+BAA+B,EAAE,CAAC;QAC5D,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CACjC,MAAM,CAAC,+BAA+B,EAAE,SAAS,+BAA+B,EAAE,CAAC,CACpF,CAAC;KACH,CAAC;CACH;AAED,KAAK,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEtD,KAAK,wBAAwB,GAAG,cAAc,GAAG;IAC/C,QAAQ,CAAC,eAAe,EAAE,wBAAwB,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,GAAG;IAC3D,QAAQ,CAAC,eAAe,EAAE,wBAAwB,CAAC;CACpD,CAAC;AA+3BF,eAAO,MAAM,sBAAsB,uBAA8D,CAAC;AAWlG,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;CAG7B,CAAC;AAUH,eAAO,MAAM,2BAA2B,qfAA2B,CAAC;AACpE,eAAO,MAAM,2BAA2B,qfAA2B,CAAC"}