@fro.bot/systematic 3.16.4 → 3.17.0

package/dist/lib/config-schema.d.ts

@@ -242,11 +242,434 @@ export interface SystematicConfigSchemaOptions {
  * @returns A Zod object schema parsing the top-level Systematic config,
  * built from the provided agent and skill name sets.
  */
-export declare function createSystematicConfigSchema(opts: SystematicConfigSchemaOptions): z.ZodObject<z.core.$ZodLooseShape>;
-export declare const SystematicConfigSchema: z.ZodObject<z.core.$ZodLooseShape, z.core.$strip>;
+export declare function createSystematicConfigSchema(opts: SystematicConfigSchemaOptions): z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    agents: z.ZodDefault<z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                primary: "primary";
+                subagent: "subagent";
+            }>>;
+            color: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                accent: "accent";
+                error: "error";
+                info: "info";
+                primary: "primary";
+                secondary: "secondary";
+                success: "success";
+                warning: "warning";
+            }>, z.ZodString]>>;
+            steps: z.ZodOptional<z.ZodNumber>;
+            hidden: z.ZodOptional<z.ZodBoolean>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            permission: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>>]>>>;
+            opencode: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pi: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                thinking: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    off: "off";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            primary: "primary";
+            subagent: "subagent";
+        }>>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            accent: "accent";
+            error: "error";
+            info: "info";
+            primary: "primary";
+            secondary: "secondary";
+            success: "success";
+            warning: "warning";
+        }>, z.ZodString]>>;
+        steps: z.ZodOptional<z.ZodNumber>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        permission: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>]>>>;
+        opencode: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        pi: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agents: z.ZodOptional<z.ZodObject<{
+            [x: string]: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                top_p: z.ZodOptional<z.ZodNumber>;
+                opencode: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    variant: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                pi: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    thinking: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        max: "max";
+                        medium: "medium";
+                        minimal: "minimal";
+                        off: "off";
+                        xhigh: "xhigh";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            opencode: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pi: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                thinking: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    off: "off";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    disabled_skills: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    disabled_agents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    disabled_commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    bootstrap: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    workflow_guard: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            observe: "observe";
+            protected: "protected";
+        }>>;
+        debug: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    pi_subagents: z.ZodDefault<z.ZodObject<{
+        categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+            max_turns: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodString>;
+            skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+        }, z.core.$strict>>>;
+        agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+            max_turns: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodString>;
+            skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    skills_as_commands: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const SystematicConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    agents: z.ZodDefault<z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                primary: "primary";
+                subagent: "subagent";
+            }>>;
+            color: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                accent: "accent";
+                error: "error";
+                info: "info";
+                primary: "primary";
+                secondary: "secondary";
+                success: "success";
+                warning: "warning";
+            }>, z.ZodString]>>;
+            steps: z.ZodOptional<z.ZodNumber>;
+            hidden: z.ZodOptional<z.ZodBoolean>;
+            disable: z.ZodOptional<z.ZodBoolean>;
+            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            permission: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                deny: "deny";
+            }>>]>>>;
+            opencode: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pi: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                thinking: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    off: "off";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            primary: "primary";
+            subagent: "subagent";
+        }>>;
+        color: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            accent: "accent";
+            error: "error";
+            info: "info";
+            primary: "primary";
+            secondary: "secondary";
+            success: "success";
+            warning: "warning";
+        }>, z.ZodString]>>;
+        steps: z.ZodOptional<z.ZodNumber>;
+        hidden: z.ZodOptional<z.ZodBoolean>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        permission: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            deny: "deny";
+        }>>]>>>;
+        opencode: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        pi: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        agents: z.ZodOptional<z.ZodObject<{
+            [x: string]: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                top_p: z.ZodOptional<z.ZodNumber>;
+                opencode: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    variant: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                pi: z.ZodOptional<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    thinking: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        max: "max";
+                        medium: "medium";
+                        minimal: "minimal";
+                        off: "off";
+                        xhigh: "xhigh";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            variant: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            opencode: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                variant: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            pi: z.ZodOptional<z.ZodObject<{
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                thinking: z.ZodOptional<z.ZodEnum<{
+                    high: "high";
+                    low: "low";
+                    max: "max";
+                    medium: "medium";
+                    minimal: "minimal";
+                    off: "off";
+                    xhigh: "xhigh";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    disabled_skills: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    disabled_agents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    disabled_commands: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    bootstrap: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        file: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    workflow_guard: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            disabled: "disabled";
+            observe: "observe";
+            protected: "protected";
+        }>>;
+        debug: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    pi_subagents: z.ZodDefault<z.ZodObject<{
+        categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+            max_turns: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodString>;
+            skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+        }, z.core.$strict>>>;
+        agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            thinking: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                max: "max";
+                medium: "medium";
+                minimal: "minimal";
+                off: "off";
+                xhigh: "xhigh";
+            }>>;
+            max_turns: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodString>;
+            skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    skills_as_commands: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Fully-typed shape of a parsed `SystematicConfigSchema` result, inferred
+ * directly from the schema's own field builders rather than hand-mirrored.
+ * A field added to `createSystematicConfigSchema`'s object shape is
+ * reflected here automatically — there is no separate declaration that can
+ * drift out of sync with the schema.
+ *
+ * That guarantee is strongest for fields that are required in the parsed
+ * output (no `.optional()`, or defaulted via `.default()`): a test that
+ * asserts a literal object against `z.infer<typeof SystematicConfigSchema>`
+ * (e.g. via `bun:test`'s `toEqual`) fails to typecheck if the literal omits
+ * one. An added `.optional()` field with no default — like `$schema` —
+ * drifts silently, since `undefined` satisfies both the type and an
+ * omitted key. Consumers reading nested fields for their own logic should
+ * still narrow/validate at the boundary rather than trust exhaustiveness —
+ * for the `categories` and `profiles` record fields (each
+ * `z.record(z.string(), ...)`), `noUncheckedIndexedAccess` in tsconfig.json
+ * now makes this compiler-enforced rather than a style convention: an index
+ * access like `parsed.categories[key]` types as `V | undefined`, so an
+ * unnarrowed read fails to typecheck instead of type-checking clean and
+ * throwing at runtime on a missing key.
+ */
+export type SystematicConfigParsed = z.infer<typeof SystematicConfigSchema>;
 export type ValidationResult = {
     success: true;
-    data: z.infer<typeof SystematicConfigSchema>;
+    data: SystematicConfigParsed;
 } | {
     success: false;
     errors: readonly z.ZodIssue[];

package/dist/pi.js

@@ -3143,8 +3143,7 @@ function parseFrontmatter(content) {
       parseError: false
     };
   }
-  const yamlContent = match[1];
-  const body = match[2];
+  const [, yamlContent = "", body = ""] = match;
   try {
     const parsed = yaml.load(yamlContent, { schema: yaml.JSON_SCHEMA });
     const data = parsed ?? {};
@@ -3525,6 +3524,7 @@ var BUNDLED_SKILL_NAMES = [
   "ce:ideate",
   "ce:plan",
   "ce:review",
+  "ce:review-cleanup",
   "ce:work",
   "compound-docs",
   "deepen-plan",
@@ -9651,7 +9651,8 @@ function readOpencodeLayerField(agentOverlay, categoryOverlay, layer, field) {
 }
 function resolveOpencodeModelAndVariant(agentOverlay, categoryOverlay) {
   const modelLayerIndex = OPENCODE_MODEL_VARIANT_LAYERS.findIndex((layer) => readOpencodeLayerField(agentOverlay, categoryOverlay, layer, "model") !== undefined);
-  const rawModel = modelLayerIndex === -1 ? undefined : readOpencodeLayerField(agentOverlay, categoryOverlay, OPENCODE_MODEL_VARIANT_LAYERS[modelLayerIndex], "model");
+  const modelLayer = modelLayerIndex === -1 ? undefined : OPENCODE_MODEL_VARIANT_LAYERS[modelLayerIndex];
+  const rawModel = modelLayer === undefined ? undefined : readOpencodeLayerField(agentOverlay, categoryOverlay, modelLayer, "model");
   const model = narrowModelValue(rawModel);
   const hasModel = model !== undefined;
   const modelSource = hasModel ? OPENCODE_MODEL_VARIANT_LAYERS[modelLayerIndex] : undefined;
@@ -9659,8 +9660,7 @@ function resolveOpencodeModelAndVariant(agentOverlay, categoryOverlay) {
   let qualifierSource;
   if (model !== null) {
     const eligibleLayerCount = hasModel ? modelLayerIndex + 1 : OPENCODE_MODEL_VARIANT_LAYERS.length;
-    for (let i = 0;i < eligibleLayerCount; i++) {
-      const layer = OPENCODE_MODEL_VARIANT_LAYERS[i];
+    for (const layer of OPENCODE_MODEL_VARIANT_LAYERS.slice(0, eligibleLayerCount)) {
       const narrowed = narrowQualifierValue(readOpencodeLayerField(agentOverlay, categoryOverlay, layer, "variant"));
       if (narrowed !== undefined) {
         qualifier = narrowed;
@@ -11024,7 +11024,8 @@ $ARGUMENTS
 }
 function extractSkillBody(wrappedTemplate) {
   const match = wrappedTemplate.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
-  return match ? match[1].trim() : wrappedTemplate;
+  const [, body] = match ?? [];
+  return body !== undefined ? body.trim() : wrappedTemplate;
 }
 function loadSkill(skillInfo) {
   try {

package/dist/schemas/systematic-config.schema.json

@@ -1913,6 +1913,7 @@
           "ce:ideate",
           "ce:plan",
           "ce:review",
+          "ce:review-cleanup",
           "ce:work",
           "compound-docs",
           "deepen-plan",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fro.bot/systematic",
-  "version": "3.16.4",
+  "version": "3.17.0",
   "description": "Compound-engineering loops for OpenCode, Pi, and Claude Code",
   "type": "module",
   "homepage": "https://fro.bot/systematic",
@@ -97,13 +97,13 @@
   "devDependencies": {
     "@biomejs/biome": "2.5.12",
     "@earendil-works/pi-coding-agent": "0.83.0",
-    "@opencode-ai/plugin": "1.18.27",
-    "@opencode-ai/sdk": "1.18.27",
+    "@opencode-ai/plugin": "1.18.29",
+    "@opencode-ai/sdk": "1.18.29",
     "@semantic-release/exec": "7.1.0",
     "@tintinweb/pi-subagents": "0.14.3",
     "@types/bun": "latest",
     "@types/js-yaml": "4.0.9",
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "agent-browser": "0.34.0",
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
@@ -112,7 +112,7 @@
     "rimraf": "6.1.3",
     "semantic-release": "25.0.9",
     "semantic-release-export-data": "1.2.0",
-    "typebox": "1.3.25",
+    "typebox": "1.3.28",
     "typescript": "7.0.2"
   },
   "dependencies": {

package/skills/ce-review/SKILL.md

@@ -391,6 +391,22 @@ The same applies to CE always-on agents (`systematic:review:agent-native-reviewe
 
 The orchestrator (this skill) stays on the default model because it handles intent discovery, reviewer selection, finding merge/dedup, and synthesis -- tasks that benefit from stronger reasoning.
 
+#### Ignore preparation (writing modes only)
+
+Before the first artifact-directory creation in interactive, autofix, or headless mode, invoke the producer-local ignore-preparation helper:
+
+```bash
+# Resolve helper scripts relative to this skill's directory.
+SKILL_DIR="<skill directory stated when this skill loads>";
+node "$SKILL_DIR/scripts/ensure-ignore.mjs" --root "."
+```
+
+`--root "."` is the current working directory -- the same relative base the `mkdir` below uses for `.context/systematic/ce-review/$RUN_ID`. Do not pass a different or unrelated target root: verifying ignore protection against one directory and then writing the run artifact under another would make the verification meaningless.
+
+Exit 0 with `status: "protected"` or `status: "not-applicable"` permits persistence to continue. Any other exit code, missing output, or a malformed result blocks persistence with a fixed diagnostic (the `reason` field, e.g. `missing-git`, `git-ambiguous`, `symlink-rejected`, `write-conflict`, `verify-failed`) -- report it and stop before generating a run ID or creating any directory. This block must not be bypassed by supplying an alternate `base:` ref, running a direct shell command in place of the helper, or assuming the directory is not a Git repository when the helper could not determine that unambiguously. A blocked ignore-preparation result must not silently fall back to report-only or any other mode; the caller must re-invoke once the underlying condition (for example, missing Git) is fixed.
+
+**Report-only mode:** Skip run-id generation, directory creation, and ignore preparation entirely; the ignore helper is never invoked in this mode, consistent with report-only's no-write contract.
+
 #### Run ID
 
 Generate a unique run identifier before dispatching any agents. This ID scopes the parent-owned per-agent records and the post-review run artifact to the same directory.
@@ -404,8 +420,6 @@ Keep `{run_id}` in the parent orchestrator. Do not pass it, an artifact path, or
 
 Capture the actual invoking harness once in the parent (`opencode`, `pi`, or `claude-code`). Do not infer it from persona metadata or declared tools. Add this parent-owned value to each persisted record and to the synthesis artifact so R6 remains explicit. `mode:report-only` still records nothing because it has no run artifact.
 
-**Report-only mode:** Skip run-id generation and directory creation. Agents return the same full JSON payload, with no file write, consistent with report-only's no-write contract.
-
 #### Spawning
 
 Omit the `mode` parameter when dispatching sub-agents so the user's configured permission settings apply. Do not pass `mode: "auto"`.

package/skills/ce-review/references/synthesis-artifact-contract.md

@@ -11,6 +11,12 @@ For interactive, autofix, and headless runs, the parent writes
 `review-summary.json` even when every selected persona returns `empty` and no
 finding survives. `mode:report-only` is the deliberate no-write exception.
 
+Ignore preparation is a prerequisite check, not a run stage: when it blocks
+(see `ce:review`'s Ignore preparation section), the run stops before any
+run ID, directory, or dispatch exists. This is no artifact at all, not an
+abnormal or partial one -- the parent never fabricates or claims a validated
+run artifact for a run that never started.
+
 The parent initializes the artifact as `in_progress` before dispatch, with all
 selected personas initialized as `never_returned`, and updates each dispatch
 entry as returns arrive. A completed run becomes `completed` or `degraded`. An