cclaw-cli 0.48.26 → 0.48.27

package/dist/content/stage-schema.d.ts

@@ -1,6 +1,6 @@
 import type { FlowStage, FlowTrack, TransitionRule } from "../types.js";
-import type { StageAutoSubagentDispatch, StageSchema } from "./stages/schema-types.js";
-export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageAutoSubagentDispatch, StageGate, StageSchema, StageSchemaInput } from "./stages/schema-types.js";
+import type { StageComplexityTier, StageAutoSubagentDispatch, StageSchema } from "./stages/schema-types.js";
+export type { ArtifactValidation, CrossStageTrace, ReviewSection, StageComplexityTier, StageExecutionModel, StagePhilosophy, StageArtifactRules, StageReviewLens, StageAutoSubagentDispatch, StageGate, StageSchema, StageSchemaInput } from "./stages/schema-types.js";
 export declare const SKILL_ENVELOPE_KINDS: readonly ["stage-output", "gate-result", "delegation-record"];
 export type SkillEnvelopeKind = (typeof SKILL_ENVELOPE_KINDS)[number];
 export interface SkillEnvelope {
@@ -18,7 +18,7 @@ export interface SkillEnvelopeValidation {
 export declare function validateSkillEnvelope(value: unknown): SkillEnvelopeValidation;
 export declare function parseSkillEnvelope(raw: string): SkillEnvelope | null;
 /** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
-export declare function mandatoryDelegationsForStage(stage: FlowStage): string[];
+export declare function mandatoryDelegationsForStage(stage: FlowStage, complexityTier?: StageComplexityTier): string[];
 export declare function stageSchema(stage: FlowStage, track?: FlowTrack): StageSchema;
 export declare function orderedStageSchemas(track?: FlowTrack): StageSchema[];
 export declare function stageGateIds(stage: FlowStage, track?: FlowTrack): string[];

package/dist/content/stage-schema.js

@@ -15,6 +15,11 @@ export const SKILL_ENVELOPE_KINDS = [
 ];
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
 const SKILL_ENVELOPE_KIND_SET = new Set(SKILL_ENVELOPE_KINDS);
+const COMPLEXITY_TIER_ORDER = {
+    lightweight: 0,
+    standard: 1,
+    deep: 2
+};
 function asRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -200,6 +205,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "planner",
             mode: "mandatory",
+            requiredAtTier: "standard",
             when: "Always during scope shaping.",
             purpose: "Challenge premise, map alternatives, and produce explicit in/out contract.",
             requiresUserGate: false
@@ -209,6 +215,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "planner",
             mode: "mandatory",
+            requiredAtTier: "standard",
             when: "Always during design lock.",
             purpose: "Stress architecture boundaries and dependency graph.",
             requiresUserGate: false
@@ -241,6 +248,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "planner",
             mode: "mandatory",
+            requiredAtTier: "standard",
             when: "Always when producing execution slices.",
             purpose: "Create dependency-aware task graph with verification steps.",
             requiresUserGate: false
@@ -250,6 +258,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "test-author",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always during TDD cycle (RED phase).",
             purpose: "Produce failing RED tests only; no production writes.",
             requiresUserGate: false,
@@ -258,6 +267,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "test-author",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always during TDD cycle (GREEN phase).",
             purpose: "Implement minimum production changes to satisfy RED and prove full-suite GREEN.",
             requiresUserGate: false,
@@ -266,6 +276,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "test-author",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always during TDD cycle (REFACTOR phase).",
             purpose: "Refactor only after GREEN proof, preserving behavior and test pass state.",
             requiresUserGate: false,
@@ -283,6 +294,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "reviewer",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always in review stage.",
             purpose: "Layer 1 spec compliance pass plus coordination of parallel Layer 2 fan-out (correctness, performance, architecture, external-safety) with source-tagged findings.",
             requiresUserGate: false,
@@ -291,6 +303,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "security-reviewer",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always in review stage. Even when no trust boundaries changed, produce an explicit 'no-change' security attestation.",
             purpose: "Guarantee a dedicated security pass on every diff: auth, input validation, secrets, injection, privilege, and blast-radius review are never opt-in. MUST load the `security-audit` skill and run a pattern-based sweep across the diff scope and touched modules in addition to the per-diff Layer 2 security checklist.",
             requiresUserGate: false,
@@ -299,6 +312,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "reviewer",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Mandatory when the diff exceeds 100 changed lines, touches more than 10 files, or modifies trust boundaries — dispatch a SECOND, independent reviewer with the adversarial-review skill loaded so the review army has at least two voices on a high-blast-radius change.",
             purpose: "Adversarial second-opinion review on large or trust-sensitive diffs. The second reviewer treats the implementation as hostile and tries to break it (hostile-user, future-maintainer, competitor lenses) instead of sympathetically explaining it.",
             requiresUserGate: false,
@@ -317,6 +331,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "doc-updater",
             mode: "mandatory",
+            requiredAtTier: "lightweight",
             when: "Always in ship stage.",
             purpose: "Ensure release notes and docs reflect actual shipped behavior.",
             requiresUserGate: false
@@ -331,9 +346,14 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
     ]
 };
 /** Transition guard: agents with `mode: "mandatory"` in auto-subagent dispatch for this stage. */
-export function mandatoryDelegationsForStage(stage) {
+export function mandatoryDelegationsForStage(stage, complexityTier = "standard") {
+    const currentTierRank = COMPLEXITY_TIER_ORDER[complexityTier];
     return [...new Set(STAGE_AUTO_SUBAGENT_DISPATCH[stage]
             .filter((d) => d.mode === "mandatory")
+            .filter((d) => {
+            const requiredAt = d.requiredAtTier ?? "standard";
+            return currentTierRank >= COMPLEXITY_TIER_ORDER[requiredAt];
+        })
             .map((d) => d.agent))];
 }
 export function stageSchema(stage, track = "standard") {
@@ -344,13 +364,54 @@ export function stageSchema(stage, track = "standard") {
         ...base.crossStageTrace,
         readsFrom: readsFromForTrack(base.crossStageTrace.readsFrom, track)
     };
+    const complexityTier = base.complexityTier ?? "standard";
+    const mandatoryDelegations = mandatoryDelegationsForStage(stage, complexityTier);
+    const philosophy = {
+        hardGate: base.hardGate,
+        ironLaw: base.ironLaw,
+        purpose: base.purpose,
+        whenToUse: base.whenToUse,
+        whenNotToUse: base.whenNotToUse,
+        commonRationalizations: base.commonRationalizations
+    };
+    const executionModel = {
+        interactionProtocol: base.interactionProtocol,
+        process: base.process,
+        checklist: base.checklist,
+        requiredGates: tieredGates,
+        requiredEvidence: base.requiredEvidence,
+        inputs: base.inputs,
+        requiredContext: base.requiredContext,
+        researchPlaybooks: base.researchPlaybooks,
+        blockers: base.blockers,
+        exitCriteria: base.exitCriteria
+    };
+    const artifactRules = {
+        artifactFile: base.artifactFile,
+        completionStatus: base.completionStatus,
+        crossStageTrace,
+        artifactValidation: tieredValidation,
+        trivialOverrideSections: base.trivialOverrideSections
+    };
+    const reviewLens = {
+        outputs: base.outputs,
+        reviewSections: base.reviewSections,
+        mandatoryDelegations,
+        policyNeedles: base.policyNeedles
+    };
     return {
         ...base,
+        schemaShape: "v2",
+        complexityTier,
+        philosophy,
+        executionModel,
+        artifactRules,
+        reviewLens,
         skillFolder: STAGE_TO_SKILL_FOLDER[stage],
         crossStageTrace,
         requiredGates: tieredGates,
         artifactValidation: tieredValidation,
-        mandatoryDelegations: mandatoryDelegationsForStage(stage)
+        mandatoryDelegations
     };
 }
 export function orderedStageSchemas(track = "standard") {

package/dist/content/stages/brainstorm.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 export const BRAINSTORM = {
     stage: "brainstorm",
+    complexityTier: "standard",
     skillFolder: "brainstorming",
     skillName: "brainstorming",
     skillDescription: "Design-first stage. Explore context, understand intent through collaborative dialogue, propose distinct approaches, and lock an approved direction before scope/design work.",

package/dist/content/stages/design.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 export const DESIGN = {
     stage: "design",
+    complexityTier: "deep",
     skillFolder: "engineering-design-lock",
     skillName: "engineering-design-lock",
     skillDescription: "Engineering lock-in stage. Build a concrete technical spine before spec and planning, with section-by-section interactive review.",

package/dist/content/stages/schema-types.d.ts

@@ -27,17 +27,62 @@ export interface StageAutoSubagentDispatch {
      * - `proactive` — should be dispatched automatically when context matches `when`.
      */
     mode: "mandatory" | "proactive";
+    /**
+     * Minimum complexity tier where this dispatch policy applies.
+     * Defaults to `standard` for mandatory dispatches when omitted.
+     */
+    requiredAtTier?: StageComplexityTier;
     when: string;
     purpose: string;
     requiresUserGate: boolean;
     /** Optional skill folder the dispatched agent should load as additional context. */
     skill?: string;
 }
+export type StageComplexityTier = "lightweight" | "standard" | "deep";
+export interface StagePhilosophy {
+    hardGate: string;
+    ironLaw: string;
+    purpose: string;
+    whenToUse: string[];
+    whenNotToUse: string[];
+    commonRationalizations: string[];
+}
+export interface StageExecutionModel {
+    interactionProtocol: string[];
+    process: string[];
+    checklist: string[];
+    requiredGates: StageGate[];
+    requiredEvidence: string[];
+    inputs: string[];
+    requiredContext: string[];
+    researchPlaybooks?: string[];
+    blockers: string[];
+    exitCriteria: string[];
+}
+export interface StageArtifactRules {
+    artifactFile: string;
+    completionStatus: string[];
+    crossStageTrace: CrossStageTrace;
+    artifactValidation: ArtifactValidation[];
+    trivialOverrideSections?: string[];
+}
+export interface StageReviewLens {
+    outputs: string[];
+    reviewSections: ReviewSection[];
+    mandatoryDelegations: string[];
+    policyNeedles: string[];
+}
 export interface StageSchema {
+    schemaShape: "v2";
     stage: FlowStage;
     skillFolder: string;
     skillName: string;
     skillDescription: string;
+    complexityTier: StageComplexityTier;
+    philosophy: StagePhilosophy;
+    executionModel: StageExecutionModel;
+    artifactRules: StageArtifactRules;
+    reviewLens: StageReviewLens;
     hardGate: string;
     /**
      * One-line "Iron Law" punchcard — the single rule that, if broken,
@@ -84,4 +129,6 @@ export interface StageSchema {
     /** Agent names that MUST be dispatched (or waived) before stage transition — derived from mandatory auto-subagent rows. */
     mandatoryDelegations: string[];
 }
-export type StageSchemaInput = Omit<StageSchema, "mandatoryDelegations">;
+export type StageSchemaInput = Omit<StageSchema, "schemaShape" | "philosophy" | "executionModel" | "artifactRules" | "reviewLens" | "mandatoryDelegations" | "complexityTier"> & {
+    complexityTier?: StageComplexityTier;
+};

package/dist/content/stages/scope.js

@@ -3,6 +3,7 @@
 // ---------------------------------------------------------------------------
 export const SCOPE = {
     stage: "scope",
+    complexityTier: "standard",
     skillFolder: "scope-shaping",
     skillName: "scope-shaping",
     skillDescription: "Strategic scope stage. Challenge premise and lock explicit in-scope/out-of-scope boundaries using CEO-level thinking.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "0.48.26",
+  "version": "0.48.27",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {