cclaw-cli 1.0.0 → 3.0.0

package/dist/artifact-linter/brainstorm.js

@@ -1,8 +1,22 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { checkCriticPredictionsContract, sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
+import { checkCriticPredictionsContract, sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, getMarkdownTableRows, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
 export async function lintBrainstormStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const qaLogBody = sectionBodyByName(sections, "Q&A Log");
+    const qaLogRows = qaLogBody ? getMarkdownTableRows(qaLogBody) : [];
+    const qaLogOk = qaLogBody !== null && qaLogRows.length > 0;
+    findings.push({
+        section: "qa_log_missing",
+        required: false,
+        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        found: qaLogOk,
+        details: qaLogOk
+            ? `Q&A Log contains ${qaLogRows.length} data row(s).`
+            : qaLogBody === null
+                ? "Missing `## Q&A Log` section."
+                : "Q&A Log is present but has zero data rows."
+    });
     // Brainstorm Iron Law: "NO ARTIFACT IS COMPLETE WITHOUT AN EXPLICITLY
     // APPROVED DIRECTION — SILENCE IS NOT APPROVAL." Previously this was
     // prose-only — nothing failed when the Selected Direction section

package/dist/artifact-linter/design.js

@@ -204,6 +204,20 @@ async function runStaleDiagramAudit(projectRoot, artifactPath, artifactRaw, code
 }
 export async function lintDesignStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const qaLogBody = sectionBodyByName(sections, "Q&A Log");
+    const qaLogRows = qaLogBody ? getMarkdownTableRows(qaLogBody) : [];
+    const qaLogOk = qaLogBody !== null && qaLogRows.length > 0;
+    findings.push({
+        section: "qa_log_missing",
+        required: false,
+        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        found: qaLogOk,
+        details: qaLogOk
+            ? `Q&A Log contains ${qaLogRows.length} data row(s).`
+            : qaLogBody === null
+                ? "Missing `## Q&A Log` section."
+                : "Q&A Log is present but has zero data rows."
+    });
     const criticPredictions = checkCriticPredictionsContract(sections);
     if (criticPredictions !== null) {
         findings.push({

package/dist/artifact-linter/scope.js

@@ -12,6 +12,20 @@ export async function lintScopeStage(ctx) {
         sectionBodyByName(sections, "Scope Summary") ?? "",
         lockedDecisionsBody
     ].join("\n");
+    const qaLogBody = sectionBodyByName(sections, "Q&A Log");
+    const qaLogRows = qaLogBody ? getMarkdownTableRows(qaLogBody) : [];
+    const qaLogOk = qaLogBody !== null && qaLogRows.length > 0;
+    findings.push({
+        section: "qa_log_missing",
+        required: false,
+        rule: "[P3] qa_log_missing — Q&A Log empty — confirm you actually had a dialogue with the user, not a draft from memory.",
+        found: qaLogOk,
+        details: qaLogOk
+            ? `Q&A Log contains ${qaLogRows.length} data row(s).`
+            : qaLogBody === null
+                ? "Missing `## Q&A Log` section."
+                : "Q&A Log is present but has zero data rows."
+    });
     const strategistRequired = selectedScopeMode === "SCOPE EXPANSION" || selectedScopeMode === "SELECTIVE EXPANSION";
     if (strategistRequired) {
         const delegationLedger = await readDelegationLedger(projectRoot);

package/dist/artifact-linter/shared.d.ts

@@ -26,6 +26,7 @@ export type H2SectionMap = Map<string, string>;
  *   into multiple passes.
  */
 export declare function extractH2Sections(markdown: string): H2SectionMap;
+export declare function duplicateH2Headings(markdown: string): string[];
 export declare function headingPresent(sections: H2SectionMap, section: string): boolean;
 export declare function sectionBodyByName(sections: H2SectionMap, section: string): string | null;
 export declare function sectionBodyByAnyName(sections: H2SectionMap, sectionNames: string[]): string | null;

package/dist/artifact-linter/shared.js

@@ -57,6 +57,38 @@ export function extractH2Sections(markdown) {
     flush();
     return sections;
 }
+export function duplicateH2Headings(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    let fenced = null;
+    const counts = new Map();
+    const displayHeading = new Map();
+    for (const line of lines) {
+        const fenceMatch = /^(```|~~~)/u.exec(line);
+        if (fenceMatch) {
+            if (fenced === null) {
+                fenced = fenceMatch[1] ?? null;
+            }
+            else if (line.startsWith(fenced)) {
+                fenced = null;
+            }
+            continue;
+        }
+        if (fenced !== null)
+            continue;
+        const match = /^##\s+(.+)$/u.exec(line);
+        if (!match)
+            continue;
+        const heading = normalizeHeadingTitle(match[1] ?? "");
+        const key = heading.toLowerCase();
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+        if (!displayHeading.has(key)) {
+            displayHeading.set(key, heading);
+        }
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([key]) => displayHeading.get(key) ?? key);
+}
 export function headingPresent(sections, section) {
     const want = normalizeHeadingTitle(section).toLowerCase();
     for (const h of sections.keys()) {

package/dist/artifact-linter.js

@@ -1,9 +1,8 @@
 import fs from "node:fs/promises";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
-import { readConfig } from "./config.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
-import { extractH2Sections, extractLockedDecisionAnchors, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody } from "./artifact-linter/shared.js";
+import { duplicateH2Headings, extractH2Sections, extractLockedDecisionAnchors, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody } from "./artifact-linter/shared.js";
 import { lintBrainstormStage } from "./artifact-linter/brainstorm.js";
 import { lintDesignStage } from "./artifact-linter/design.js";
 import { lintPlanStage } from "./artifact-linter/plan.js";
@@ -48,7 +47,16 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
     }
     const raw = await fs.readFile(absFile, "utf8");
     const sections = extractH2Sections(raw);
-    const projectConfig = await readConfig(projectRoot);
+    const duplicateHeadings = duplicateH2Headings(raw);
+    if (duplicateHeadings.length > 0) {
+        findings.push({
+            section: "duplicate_h2_heading",
+            required: false,
+            rule: "[P3] keep each `##` heading unique within an artifact; append updates to the existing section instead of cloning headings.",
+            found: false,
+            details: `Duplicate H2 heading(s): ${duplicateHeadings.join(", ")}. Merge edits into the existing heading to avoid split contracts.`
+        });
+    }
     const parsedFrontmatter = parseFrontmatter(raw);
     const frontmatterMissingKeys = FRONTMATTER_REQUIRED_KEYS.filter((key) => {
         const value = parsedFrontmatter.values[key];
@@ -87,8 +95,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard") {
     });
     const brainstormShortCircuitBody = stage === "brainstorm" ? sectionBodyByName(sections, "Short-Circuit Decision") : null;
     const brainstormShortCircuitActivated = stage === "brainstorm" && isShortCircuitActivated(brainstormShortCircuitBody);
-    const scopePreAuditEnabled = projectConfig.optInAudits?.scopePreAudit === true;
-    const staleDiagramAuditEnabled = projectConfig.optInAudits?.staleDiagramAudit === true;
+    const scopePreAuditEnabled = true;
+    const staleDiagramAuditEnabled = true;
     const isTrivialOverride = Boolean(schema.trivialOverrideSections &&
         schema.trivialOverrideSections.length > 0 &&
         (/trivial.change|mini.design|escape.hatch/iu.test(raw) ||

package/dist/cli.js

@@ -425,11 +425,8 @@ async function runCommand(parsed, ctx) {
                 info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
             }
             ctx.stdout.write(`${JSON.stringify({
-                track: previewConfig.defaultTrack ?? "standard",
+                track: effectiveTrack ?? "standard",
                 harnesses: previewConfig.harnesses,
-                strictness: previewConfig.strictness ?? "advisory",
-                gitHookGuards: previewConfig.gitHookGuards,
-                languageRulePacks: previewConfig.languageRulePacks,
                 generatedSurfaces: previewSurfaces
             }, null, 2)}\n`);
             return 0;
@@ -444,11 +441,7 @@ async function runCommand(parsed, ctx) {
         }
         const trackNote = effectiveTrack ? ` (track=${effectiveTrack})` : "";
         info(ctx, `Initialized .cclaw runtime and generated harness shims${trackNote}`);
-        // Point new users at the one config surface they might actually flip —
-        // `strictness` and `gitHookGuards` — without overselling the other knobs
-        // (those live behind docs/config.md until someone needs them).
-        info(ctx, "Config: .cclaw/config.yaml (strictness=advisory, gitHookGuards=false).");
-        info(ctx, "Need stricter guards or language rule packs? See docs/config.md.");
+        info(ctx, "Config: .cclaw/config.yaml (harnesses + auto-managed version stamps).");
         await maybeEnableCodexHooksFlag(effectiveHarnesses, parsed, ctx);
         return 0;
     }

package/dist/config.d.ts

@@ -1,4 +1,9 @@
 import type { CclawConfig, FlowTrack, HarnessId, LanguageRulePack } from "./types.js";
+export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
+export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
+export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
+export declare const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
+export declare const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
 export interface ConfigWarningState {
     emitted: Set<string>;
 }
@@ -10,73 +15,12 @@ export declare class InvalidConfigError extends Error {
     constructor(message: string);
 }
 export declare function configPath(projectRoot: string): string;
-/**
- * Default test-path patterns used by the workflow-guard hook to classify TDD writes.
- *
- * Scope is intentionally narrow and language-agnostic; users can extend this
- * list in config when their repository uses different conventions.
- */
-export declare const DEFAULT_TDD_TEST_PATH_PATTERNS: readonly string[];
-/**
- * Legacy alias kept for backwards compatibility with `tddTestGlobs`.
- * Prefer `tdd.testPathPatterns` in new configurations.
- */
-export declare const DEFAULT_TDD_TEST_GLOBS: readonly string[];
-export declare const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS: readonly string[];
-export declare const DEFAULT_COMPOUND_RECURRENCE_THRESHOLD = 3;
-export declare const DEFAULT_EARLY_LOOP_MAX_ITERATIONS = 3;
-/**
- * Populated runtime view of config values that downstream callers (install,
- * observe, sync/runtime checks) consume. Always has the derived guard modes populated,
- * regardless of whether the user wrote `strictness`, the legacy keys, both,
- * or neither.
- */
-export declare function createDefaultConfig(harnesses?: HarnessId[], defaultTrack?: FlowTrack): CclawConfig;
-/**
- * Probe common project-root manifests to infer which language rule packs the
- * user would reasonably want. Pure-functional best-effort: any filesystem
- * error is swallowed, producing an empty list — the user can always override
- * by hand.
- *
- * Called from `cclaw init` only (not `readConfig`), so subsequent upgrades
- * never surprise a user who intentionally cleared the list.
- */
-export declare function detectLanguageRulePacks(projectRoot: string): Promise<LanguageRulePack[]>;
-export declare function readConfig(projectRoot: string, options?: ReadConfigOptions): Promise<CclawConfig>;
-/**
- * Fields that live on the populated runtime `CclawConfig` but are considered
- * "advanced" — we keep them in the in-memory object so downstream callers
- * don't have to branch, but we do **not** write them to `config.yaml` unless
- * the user set them explicitly. Keeps the default template small and honest:
- * only knobs a new user would meaningfully flip show up.
- */
-type AdvancedConfigKey = "vcs" | "tddTestGlobs" | "tdd" | "compound" | "earlyLoop" | "defaultTrack" | "languageRulePacks" | "trackHeuristics" | "sliceReview" | "ironLaws" | "optInAudits" | "reviewLoop";
-/**
- * Options controlling the serialisation shape of `config.yaml`.
- *
- * - `"full"` (default): write every field on the `CclawConfig` object that
- *   isn't `undefined`. Preserves existing shapes and keeps legacy callers
- *   working without migration.
- * - `"minimal"`: write only the user-facing knobs (`MINIMAL_CONFIG_KEYS`)
- *   plus any non-empty `languageRulePacks` (so auto-detected values survive
- *   a fresh `cclaw init`). Use this when generating the default template;
- *   power users can still add advanced keys by hand.
- *
- * `advancedKeysPresent` upgrades an otherwise-minimal serialisation by
- * including the listed advanced keys. `cclaw upgrade` uses it to preserve
- * the exact shape a user hand-authored, while still re-minimising configs
- * where the user stayed at defaults.
- */
+export declare function createDefaultConfig(harnesses?: HarnessId[], _defaultTrack?: FlowTrack): CclawConfig;
+export declare function detectLanguageRulePacks(_projectRoot: string): Promise<LanguageRulePack[]>;
+export declare function readConfig(projectRoot: string, _options?: ReadConfigOptions): Promise<CclawConfig>;
 export interface WriteConfigOptions {
     mode?: "full" | "minimal";
-    advancedKeysPresent?: ReadonlySet<AdvancedConfigKey>;
+    advancedKeysPresent?: ReadonlySet<never>;
 }
-export declare function writeConfig(projectRoot: string, config: CclawConfig, options?: WriteConfigOptions): Promise<void>;
-/**
- * Enumerate which advanced keys are currently set in the on-disk config.
- * Used by `cclaw upgrade` to preserve the user's existing shape — if they
- * wrote `tddTestGlobs` by hand, the upgrade keeps it; if they didn't, the
- * upgrade stays minimal.
- */
-export declare function detectAdvancedKeys(projectRoot: string): Promise<ReadonlySet<AdvancedConfigKey>>;
-export {};
+export declare function writeConfig(projectRoot: string, config: CclawConfig, _options?: WriteConfigOptions): Promise<void>;
+export declare function detectAdvancedKeys(_projectRoot: string): Promise<ReadonlySet<never>>;