cclaw-cli 0.48.26 → 0.48.28

package/dist/content/contracts.js

@@ -1,4 +1,4 @@
-import { stageSchema } from "./stage-schema.js";
+import { stagePolicyNeedles, stageSchema } from "./stage-schema.js";
 import { stageSkillFolder } from "./skills.js";
 export function stageCommandContract(stage, track = "standard") {
     const schema = stageSchema(stage, track);
@@ -17,6 +17,7 @@ export function stageCommandContract(stage, track = "standard") {
     const writeStepPaths = writes.length > 1
         ? writes.map((w) => `\`${w}\``).join(" and ")
         : `\`${primaryArtifact}\``;
+    const policyNeedles = stagePolicyNeedles(stage, track);
     return `# /cc-${stage}
 
 Load and follow **${skillPath}** — it contains the full checklist, examples, interaction protocol, and verification discipline.
@@ -45,6 +46,6 @@ ${gateIds}
 ${schema.exitCriteria.map((v) => `- ${v}`).join("\n")}
 
 ## Anchors
-${schema.policyNeedles.map((v) => `- ${v}`).join("\n")}
+${policyNeedles.map((v) => `- ${v}`).join("\n")}
 `;
 }

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, StageSchemaLegacyInput, StageSchema, StageSchemaInput, StageSchemaV2Input } 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

@@ -1,6 +1,7 @@
 import { FLOW_STAGES, FLOW_TRACKS, TRACK_STAGES } from "../types.js";
 import { STAGE_TO_SKILL_FOLDER } from "../constants.js";
 import { BRAINSTORM, SCOPE, DESIGN, SPEC, PLAN, TDD, REVIEW, SHIP } from "./stages/index.js";
+import { stagePolicyNeedlesFromMetadata } from "./stages/_lint-metadata/index.js";
 import { tddStageForTrack } from "./stages/tdd.js";
 // ---------------------------------------------------------------------------
 // NOTE: The former QUESTION_FORMAT_SPEC / ERROR_BUDGET_SPEC exports were
@@ -15,6 +16,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;
@@ -173,6 +179,46 @@ function readsFromForTrack(readsFrom, track) {
         return stageSet.has(stage);
     });
 }
+function isStageSchemaV2Input(value) {
+    return value.schemaShape === "v2";
+}
+function normalizeStageSchemaInput(value) {
+    if (!isStageSchemaV2Input(value)) {
+        return value;
+    }
+    return {
+        stage: value.stage,
+        skillFolder: value.skillFolder,
+        skillName: value.skillName,
+        skillDescription: value.skillDescription,
+        complexityTier: value.complexityTier,
+        hardGate: value.philosophy.hardGate,
+        ironLaw: value.philosophy.ironLaw,
+        purpose: value.philosophy.purpose,
+        whenToUse: value.philosophy.whenToUse,
+        whenNotToUse: value.philosophy.whenNotToUse,
+        interactionProtocol: value.executionModel.interactionProtocol,
+        process: value.executionModel.process,
+        requiredGates: value.executionModel.requiredGates,
+        requiredEvidence: value.executionModel.requiredEvidence,
+        inputs: value.executionModel.inputs,
+        requiredContext: value.executionModel.requiredContext,
+        researchPlaybooks: value.executionModel.researchPlaybooks,
+        outputs: value.reviewLens.outputs,
+        blockers: value.executionModel.blockers,
+        exitCriteria: value.executionModel.exitCriteria,
+        commonRationalizations: value.philosophy.commonRationalizations,
+        artifactFile: value.artifactRules.artifactFile,
+        next: value.next,
+        checklist: value.executionModel.checklist,
+        reviewSections: value.reviewLens.reviewSections,
+        completionStatus: value.artifactRules.completionStatus,
+        crossStageTrace: value.artifactRules.crossStageTrace,
+        artifactValidation: value.artifactRules.artifactValidation,
+        batchExecutionAllowed: value.batchExecutionAllowed,
+        trivialOverrideSections: value.artifactRules.trivialOverrideSections
+    };
+}
 // ---------------------------------------------------------------------------
 // Stage map and accessors
 // ---------------------------------------------------------------------------
@@ -200,6 +246,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 +256,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 +289,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 +299,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 +308,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 +317,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 +335,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 +344,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 +353,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 +372,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,26 +387,72 @@ 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") {
-    const base = stage === "tdd" ? tddStageForTrack(track) : STAGE_SCHEMA_MAP[stage];
+    const rawInput = stage === "tdd" ? tddStageForTrack(track) : STAGE_SCHEMA_MAP[stage];
+    const base = normalizeStageSchemaInput(rawInput);
     const tieredGates = tieredStageGates(stage, base.requiredGates, track);
     const tieredValidation = tieredArtifactValidation(stage, base.artifactValidation);
     const crossStageTrace = {
         ...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
+    };
     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") {
@@ -403,7 +505,7 @@ export function buildTransitionRules() {
     return rules;
 }
 export function stagePolicyNeedles(stage, track = "standard") {
-    return stageSchema(stage, track).policyNeedles;
+    return stagePolicyNeedlesFromMetadata(stage, track);
 }
 export function stageAutoSubagentDispatch(stage) {
     return STAGE_AUTO_SUBAGENT_DISPATCH[stage];

package/dist/content/stages/_lint-metadata/index.d.ts

@@ -0,0 +1,2 @@
+import type { FlowStage, FlowTrack } from "../../../types.js";
+export declare function stagePolicyNeedlesFromMetadata(stage: FlowStage, track?: FlowTrack): string[];

package/dist/content/stages/_lint-metadata/index.js

@@ -0,0 +1,79 @@
+import { SHIP_FINALIZATION_MODES } from "../../../constants.js";
+const STAGE_POLICY_NEEDLES = {
+    brainstorm: [
+        "Explore project context",
+        "One question at a time",
+        "2-3 architecturally distinct approaches",
+        "State what is being approved",
+        "Self-review before handoff",
+        "Do NOT implement, scaffold, or modify behavior"
+    ],
+    scope: [
+        "Scope mode",
+        "In Scope",
+        "Out of Scope",
+        "Discretion Areas",
+        "NOT in scope",
+        "Premise Challenge",
+        "Locked Decisions"
+    ],
+    design: [
+        "Parallel Research Fleet",
+        "Architecture",
+        "Data Flow",
+        "Failure Modes and Mitigation",
+        "Performance Budget",
+        "One issue at a time"
+    ],
+    spec: ["Acceptance Criteria", "Constraints", "Testability", "approved spec", "Edge Cases"],
+    plan: [
+        "WAIT_FOR_CONFIRM",
+        "Task Graph",
+        "Dependency Batches",
+        "Acceptance Mapping",
+        "verification steps",
+        "Locked Decision Coverage"
+    ],
+    tdd: [
+        "RED",
+        "GREEN",
+        "REFACTOR",
+        "failing test",
+        "full test suite",
+        "acceptance criteria",
+        "traceable to plan slice"
+    ],
+    review: [
+        "Layer 1",
+        "Layer 2",
+        "Critical",
+        "Review Army",
+        "Ready to Ship",
+        "ROUTE_BACK_TO_TDD",
+        "One issue at a time"
+    ],
+    ship: [
+        "Pre-Ship Checks",
+        "Release Notes",
+        "Rollback Plan",
+        ...SHIP_FINALIZATION_MODES
+    ]
+};
+function quickTrackText(value) {
+    return value
+        .replace(/\btask from the plan\b/giu, "acceptance criterion from the spec")
+        .replace(/\bplan task ID\b/giu, "acceptance criterion ID")
+        .replace(/\bplan task\b/giu, "acceptance criterion")
+        .replace(/\bplan row\b/giu, "acceptance row")
+        .replace(/\bplan slice\b/giu, "acceptance slice")
+        .replace(/\bplan artifact\b/giu, "spec artifact")
+        .replace(/\btraceable to plan slice\b/giu, "traceable to acceptance criterion")
+        .replace(/05-plan\.md/gu, "04-spec.md");
+}
+export function stagePolicyNeedlesFromMetadata(stage, track = "standard") {
+    const needles = STAGE_POLICY_NEEDLES[stage];
+    if (stage === "tdd" && track === "quick") {
+        return needles.map(quickTrackText);
+    }
+    return [...needles];
+}