cclaw-cli 0.30.0 → 0.31.0

package/README.md

@@ -117,7 +117,8 @@ Plus harness-specific shims:
 
 `.cclaw/config.yaml` holds every tunable key (prompt guard strictness,
 TDD enforcement, git-hook guards, language rule packs, track heuristics).
-Edit it directly — `cclaw-cli upgrade` preserves your changes.
+Edit it directly — `cclaw-cli upgrade` preserves your changes. Full key
+reference: [`docs/config.md`](./docs/config.md).
 
 ---
 
@@ -355,7 +356,8 @@ npx cclaw-cli --version
 For CI or scripted installs, `cclaw-cli init --harnesses=<list>
 --no-interactive` is the non-interactive form. All other tunables
 (prompt-guard strictness, TDD enforcement, language rule packs, track
-heuristics) are set by editing `.cclaw/config.yaml` directly.
+heuristics) are set by editing `.cclaw/config.yaml` directly — see
+[`docs/config.md`](./docs/config.md) for the full key reference.
 
 ---
 

package/dist/cli.d.ts

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
-import type { FlowTrack, HarnessId, InitProfile } from "./types.js";
+import type { FlowTrack, HarnessId } from "./types.js";
 import type { EvalMode } from "./eval/types.js";
 type CommandName = "init" | "sync" | "doctor" | "upgrade" | "uninstall" | "archive" | "eval";
 interface ParsedArgs {
     command?: CommandName;
     harnesses?: HarnessId[];
     track?: FlowTrack;
-    profile?: InitProfile;
     dryRun?: boolean;
     interactive?: boolean;
     reconcileGates?: boolean;
@@ -40,6 +39,5 @@ interface ParsedArgs {
 export declare function usage(): string;
 declare function parseHarnesses(raw: string): HarnessId[];
 declare function parseTrack(raw: string): FlowTrack;
-declare function parseProfile(raw: string): InitProfile;
 declare function parseArgs(argv: string[]): ParsedArgs;
-export { parseArgs, parseHarnesses, parseTrack, parseProfile };
+export { parseArgs, parseHarnesses, parseTrack };

package/dist/cli.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-import { createReadStream, realpathSync } from "node:fs";
+import { createReadStream, existsSync, realpathSync } from "node:fs";
 import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import process from "node:process";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
-import { FLOW_TRACKS, HARNESS_IDS, INIT_PROFILES } from "./types.js";
+import { FLOW_TRACKS, HARNESS_IDS } from "./types.js";
 import { doctorChecks, doctorSucceeded } from "./doctor.js";
 import { initCclaw, syncCclaw, uninstallCclaw, upgradeCclaw } from "./install.js";
 import { error, info } from "./logger.js";
 import { archiveRun } from "./runs.js";
 import { CCLAW_VERSION, RUNTIME_ROOT } from "./constants.js";
-import { createDefaultConfig, createProfileConfig } from "./config.js";
+import { createDefaultConfig } from "./config.js";
 import { detectHarnesses } from "./init-detect.js";
 import { HARNESS_ADAPTERS } from "./harness-adapters.js";
 import { runEval } from "./eval/runner.js";
@@ -21,7 +21,6 @@ import { writeBaselinesFromReport } from "./eval/baseline.js";
 import { writeJsonReport, writeMarkdownReport } from "./eval/report.js";
 import { formatDiffMarkdown, runEvalDiff } from "./eval/diff.js";
 import { ensureRunDir, generateRunId, isRunAlive, listRuns, readRunStatus, resolveRunId, runLogPath, writeRunStatus } from "./eval/runs.js";
-import { EVAL_MODES } from "./eval/types.js";
 import { parseModeInput } from "./eval/mode.js";
 import { FLOW_STAGES } from "./types.js";
 const INSTALLER_COMMANDS = [
@@ -37,82 +36,33 @@ export function usage() {
     return `cclaw - installer-first flow toolkit
 
 Usage:
-  cclaw <command> [flags]
-  cclaw --help | -h
-  cclaw --version | -v
+  npx cclaw-cli                   # launch setup or print "already installed" hint
+  npx cclaw-cli <command> [flags]
+  npx cclaw-cli --help | -h
+  npx cclaw-cli --version | -v
 
 Commands:
   init       Bootstrap .cclaw runtime, state, and harness shims in this project.
-             Flags: --profile=<id>      Pre-fill defaults. One of: minimal | standard | full. Default: standard.
-                    --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex). Overrides the profile default.
-                    --track=<id>        Flow track for new runs (standard | medium | quick). Overrides the profile default.
-                    --interactive       Force interactive prompts (TTY only).
-                    --no-interactive    Skip interactive prompts even on TTY.
-                    --dry-run           Print resolved config + generated surfaces without writing files.
-  sync       Regenerate harness shim files from the current .cclaw config (non-destructive).
-  doctor     Run health checks against the local .cclaw runtime. Exit code 2 when any error-severity check fails.
-             Flags: --reconcile-gates   Recompute current-stage gate evidence before checks.
-                    --json              Emit machine-readable JSON output.
-                    --only=<filter>     Comma list of severities/check-name filters (error,warning,info,trace:,hook:...).
-                    --explain           Include fix + doc reference per check in text mode.
-                    --quiet             Print only failing checks (and totals).
-  archive    Move .cclaw/artifacts into .cclaw/runs/<date>-<slug> and reset flow state.
-             Flags: --name=<feature>    Feature slug (default: inferred from 00-idea.md).
-                    --skip-retro       Bypass mandatory retro gate (requires --retro-reason).
-                    --retro-reason=<t> Reason for bypassing retro gate.
-  eval       Run cclaw evals against .cclaw/evals/corpus (Phase 7: structural verifier + baselines).
-             Flags: --stage=<id>         Limit to one flow stage (${FLOW_STAGES.join("|")}) for fixture/agent modes.
-                    --mode=<${EVAL_MODES.join("|")}>
-                                         Evaluation mode:
-                                           fixture  = verify existing artifacts with structural/rule/judge verifiers.
-                                           agent    = LLM drafts one stage's artifact in a sandbox with tools.
-                                           workflow = LLM runs the full multi-stage flow (brainstorm→plan).
-                                         Legacy --tier=A|B|C still works (deprecated).
-                    --schema-only        Run only structural verifiers (default).
-                    --rules              Also run rule-based verifiers (keywords, regex, counts, uniqueness, traceability).
-                    --judge              Run the LLM judge (median-of-N) against each case's rubric. Requires CCLAW_EVAL_API_KEY; fixture mode judges an existing artifact, agent/workflow modes draft first and then judge.
-                    --dry-run            Validate config + corpus, print summary, do not execute.
-                    --json               Emit machine-readable JSON on stdout.
-                    --no-write           Skip writing the report to .cclaw/evals/reports/.
-                    --update-baseline    Overwrite baselines from the current run (requires --confirm).
-                    --confirm            Acknowledge --update-baseline (prevents accidental resets).
-                    --quiet              Silence the stderr progress logger (default: emit one
-                                         line per case / stage to stderr so long runs are visible).
-                    --max-cost-usd=<n>   Abort the run if committed USD spend crosses <n>
-                                         (independent from the daily cap). Also readable from
-                                         CCLAW_EVAL_MAX_COST_USD.
-                    --compare-model=<id> Run the same corpus twice — once with the configured model
-                                         and once with <id> — then diff the summaries. Exit code 1
-                                         when the override model regressed.
-                    --background         Spawn the run as a detached child process, write the
-                                         combined output to .cclaw/evals/runs/<id>/run.log, and
-                                         return immediately. Attach later with
-                                         \`cclaw eval runs tail <id|latest>\`.
-
-             Subcommands:
-                    diff <old> <new>     Compare two reports under .cclaw/evals/reports/.
-                                         Each argument is a cclawVersion (e.g. 0.26.0), a filename,
-                                         or the literal "latest". Exit code 1 when the diff shows a
-                                         regression. Accepts --json to emit machine-readable output.
-                    runs [action] [id]   Inspect background runs under .cclaw/evals/runs/.
-                                         Actions: list (default) | status <id|latest> | tail <id|latest>.
-  upgrade    Refresh generated files in .cclaw without modifying user artifacts.
+             Flags: --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex).
+                    --no-interactive    Skip interactive prompts even on TTY (for CI/scripts).
+  upgrade    Refresh generated files in .cclaw. Preserves your config.yaml.
   uninstall  Remove .cclaw runtime and the generated harness shim files.
+  eval       Run cclaw evals. Maintainer surface — see docs/evals.md.
+             Full flag reference: \`npx cclaw-cli eval --help\` or docs/evals.md.
 
 Global flags:
   -h, --help     Show this help message and exit 0.
   -v, --version  Print the cclaw CLI version and exit 0.
 
 Examples:
-  cclaw init --harnesses=claude,cursor
-  cclaw doctor --reconcile-gates
-  cclaw archive --name=payments-revamp
-  cclaw eval --dry-run
-  cclaw eval --stage=brainstorm --schema-only
-  cclaw eval --judge --mode=fixture --stage=brainstorm
-  cclaw eval --judge --mode=agent --stage=spec
-  cclaw eval --mode=workflow --judge
-  cclaw eval diff 0.26.0 latest
+  npx cclaw-cli
+  npx cclaw-cli init --harnesses=claude,cursor --no-interactive
+  npx cclaw-cli upgrade
+  npx cclaw-cli eval --dry-run
+
+Everything operational (retro, archive, worktrees, doctor, learnings)
+happens inside your harness via slash commands. The CLI is just a
+launcher. See README.md for the four user-facing slash commands.
 
 Docs:   https://github.com/zuevrs/cclaw
 Issues: https://github.com/zuevrs/cclaw/issues
@@ -136,13 +86,6 @@ function parseTrack(raw) {
     }
     return trimmed;
 }
-function parseProfile(raw) {
-    const trimmed = raw.trim();
-    if (!INIT_PROFILES.includes(trimmed)) {
-        throw new Error(`Unknown profile: ${trimmed}. Supported: ${INIT_PROFILES.join(", ")}`);
-    }
-    return trimmed;
-}
 function parseLegacyTier(raw) {
     return parseModeInput(raw.toUpperCase(), {
         source: "cli",
@@ -165,6 +108,26 @@ function parseEvalStage(raw) {
 function isInitPromptAllowed(ctx) {
     return Boolean(process.stdin.isTTY && ctx.stdout.isTTY);
 }
+/**
+ * Print a short, friendly hint when the user runs `cclaw-cli` with no
+ * arguments. Does not read or mutate flow state — only checks whether
+ * `.cclaw/config.yaml` exists to branch between "installed" and
+ * "not-installed" messaging. Keeps exit 0 in both cases: users discover
+ * the tool through this path, not through an error.
+ */
+function printNoArgsHint(ctx) {
+    const installed = existsSync(path.join(ctx.cwd, RUNTIME_ROOT, "config.yaml"));
+    if (installed) {
+        ctx.stdout.write("cclaw is installed in this project. Open your harness (Claude Code, " +
+            "Cursor, OpenCode, or Codex) and type `/cc` to start.\n");
+    }
+    else {
+        ctx.stdout.write("cclaw is not installed in this project yet.\n" +
+            "Run `npx cclaw-cli init` to bootstrap .cclaw and the harness shims.\n" +
+            "For help: `npx cclaw-cli --help`.\n");
+    }
+    return 0;
+}
 function buildInitSurfacePreview(harnesses) {
     const lines = [
         ".cclaw/config.yaml",
@@ -206,39 +169,11 @@ function buildInitSurfacePreview(harnesses) {
     }
     return lines;
 }
-function inferTrackDefault(profile, track) {
-    if (track)
-        return track;
-    if (!profile)
-        return "standard";
-    return createProfileConfig(profile).defaultTrack ?? "standard";
-}
 async function promptInitConfig(defaults, ctx) {
     const rl = createInterface({
         input: process.stdin,
         output: ctx.stdout
     });
-    const pickSingle = async (label, options, fallback) => {
-        while (true) {
-            ctx.stdout.write(`\n${label}\n`);
-            options.forEach((option, index) => {
-                const marker = option === fallback ? " (default)" : "";
-                ctx.stdout.write(`  ${index + 1}) ${option}${marker}\n`);
-            });
-            const answer = (await rl.question("> ")).trim();
-            if (answer.length === 0) {
-                return fallback;
-            }
-            const numeric = Number(answer);
-            if (Number.isInteger(numeric) && numeric >= 1 && numeric <= options.length) {
-                return options[numeric - 1];
-            }
-            if (options.includes(answer)) {
-                return answer;
-            }
-            ctx.stdout.write("Invalid selection. Use option number or value.\n");
-        }
-    };
     const pickHarnesses = async (fallback) => {
         const fallbackText = fallback.join(",");
         while (true) {
@@ -260,11 +195,8 @@ async function promptInitConfig(defaults, ctx) {
         }
     };
     try {
-        const profile = await pickSingle("Select init profile:", INIT_PROFILES, defaults.profile);
-        const trackDefault = inferTrackDefault(profile, defaults.track);
-        const track = await pickSingle("Select default flow track:", FLOW_TRACKS, trackDefault);
         const harnesses = await pickHarnesses(defaults.harnesses);
-        return { profile, track, harnesses };
+        return { harnesses };
     }
     finally {
         rl.close();
@@ -279,13 +211,11 @@ async function resolveInitInputs(parsed, ctx) {
     const promptForbidden = parsed.interactive === false;
     const implicitPrompt = !promptForbidden &&
         isInitPromptAllowed(ctx) &&
-        parsed.profile === undefined &&
         parsed.track === undefined &&
         parsed.harnesses === undefined;
     const shouldPrompt = promptRequested || implicitPrompt;
     if (!shouldPrompt) {
         return {
-            profile: parsed.profile,
             track: parsed.track,
             harnesses: autoHarnesses,
             detectedHarnesses
@@ -295,14 +225,11 @@ async function resolveInitInputs(parsed, ctx) {
         throw new Error("Interactive init requires a TTY. Remove --interactive or run in a terminal.");
     }
     const defaults = {
-        profile: parsed.profile ?? "standard",
-        track: inferTrackDefault(parsed.profile, parsed.track),
         harnesses: autoHarnesses ?? HARNESS_IDS.slice()
     };
     const prompted = await promptInitConfig(defaults, ctx);
     return {
-        profile: prompted.profile,
-        track: prompted.track,
+        track: parsed.track,
         harnesses: prompted.harnesses,
         detectedHarnesses
     };
@@ -447,7 +374,6 @@ function parseArgs(argv) {
             continue;
         }
         if (flag.startsWith("--profile=")) {
-            parsed.profile = parseProfile(flag.replace("--profile=", ""));
             continue;
         }
         if (flag === "--interactive") {
@@ -780,28 +706,20 @@ async function runCommand(parsed, ctx) {
     }
     const command = parsed.command;
     if (!command) {
-        ctx.stderr.write(usage());
-        return 1;
+        return printNoArgsHint(ctx);
     }
     if (command === "init") {
         const resolved = await resolveInitInputs(parsed, ctx);
-        const effectiveProfile = resolved.profile;
         const effectiveTrack = resolved.track;
         const effectiveHarnesses = resolved.harnesses;
         if (parsed.dryRun === true) {
-            const previewConfig = effectiveProfile
-                ? createProfileConfig(effectiveProfile, {
-                    harnesses: effectiveHarnesses,
-                    defaultTrack: effectiveTrack
-                })
-                : createDefaultConfig(effectiveHarnesses, effectiveTrack);
+            const previewConfig = createDefaultConfig(effectiveHarnesses, effectiveTrack);
             const previewSurfaces = buildInitSurfacePreview(previewConfig.harnesses);
             info(ctx, "Dry run: no files were written.");
             if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
                 info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
             }
             ctx.stdout.write(`${JSON.stringify({
-                profile: effectiveProfile ?? "standard(default)",
                 track: previewConfig.defaultTrack ?? "standard",
                 harnesses: previewConfig.harnesses,
                 promptGuardMode: previewConfig.promptGuardMode,
@@ -814,16 +732,13 @@ async function runCommand(parsed, ctx) {
         await initCclaw({
             projectRoot: ctx.cwd,
             harnesses: effectiveHarnesses,
-            track: effectiveTrack,
-            profile: effectiveProfile
+            track: effectiveTrack
         });
         if (resolved.detectedHarnesses.length > 0 && parsed.harnesses === undefined) {
             info(ctx, `Detected harnesses from repo: ${resolved.detectedHarnesses.join(", ")}`);
         }
-        const profileNote = effectiveProfile ? ` profile=${effectiveProfile}` : "";
-        const trackNote = effectiveTrack ? ` track=${effectiveTrack}` : "";
-        const suffix = profileNote || trackNote ? ` (${(profileNote + trackNote).trim()})` : "";
-        info(ctx, `Initialized .cclaw runtime and generated harness shims${suffix}`);
+        const trackNote = effectiveTrack ? ` (track=${effectiveTrack})` : "";
+        info(ctx, `Initialized .cclaw runtime and generated harness shims${trackNote}`);
         return 0;
     }
     if (command === "sync") {
@@ -1043,4 +958,4 @@ function isDirectExecution() {
 if (isDirectExecution()) {
     void main();
 }
-export { parseArgs, parseHarnesses, parseTrack, parseProfile };
+export { parseArgs, parseHarnesses, parseTrack };

package/dist/config.d.ts

@@ -1,15 +1,5 @@
-import type { FlowTrack, HarnessId, InitProfile, LanguageRulePack, VibyConfig } from "./types.js";
+import type { FlowTrack, HarnessId, VibyConfig } from "./types.js";
 export declare function configPath(projectRoot: string): string;
 export declare function createDefaultConfig(harnesses?: HarnessId[], defaultTrack?: FlowTrack): VibyConfig;
-/**
- * Build a VibyConfig for a named init profile. Profile defaults are applied
- * first, then any explicit overrides (CLI flags) win. This keeps the profile
- * contract deterministic and testable.
- */
-export declare function createProfileConfig(profile: InitProfile, overrides?: {
-    harnesses?: HarnessId[];
-    defaultTrack?: FlowTrack;
-    languageRulePacks?: LanguageRulePack[];
-}): VibyConfig;
 export declare function readConfig(projectRoot: string): Promise<VibyConfig>;
 export declare function writeConfig(projectRoot: string, config: VibyConfig): Promise<void>;

package/dist/config.js

@@ -67,46 +67,6 @@ export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, defaultTrack
         languageRulePacks: []
     };
 }
-/**
- * Build a VibyConfig for a named init profile. Profile defaults are applied
- * first, then any explicit overrides (CLI flags) win. This keeps the profile
- * contract deterministic and testable.
- */
-export function createProfileConfig(profile, overrides = {}) {
-    const base = createDefaultConfig();
-    switch (profile) {
-        case "minimal":
-            return {
-                ...base,
-                harnesses: overrides.harnesses ?? ["claude"],
-                promptGuardMode: "advisory",
-                tddEnforcement: "advisory",
-                gitHookGuards: false,
-                defaultTrack: overrides.defaultTrack ?? "medium",
-                languageRulePacks: overrides.languageRulePacks ?? []
-            };
-        case "standard":
-            return {
-                ...base,
-                harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
-                promptGuardMode: "advisory",
-                tddEnforcement: "advisory",
-                gitHookGuards: false,
-                defaultTrack: overrides.defaultTrack ?? "standard",
-                languageRulePacks: overrides.languageRulePacks ?? []
-            };
-        case "full":
-            return {
-                ...base,
-                harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
-                promptGuardMode: "strict",
-                tddEnforcement: "strict",
-                gitHookGuards: true,
-                defaultTrack: overrides.defaultTrack ?? "standard",
-                languageRulePacks: overrides.languageRulePacks ?? [...LANGUAGE_RULE_PACKS]
-            };
-    }
-}
 export async function readConfig(projectRoot) {
     const fullPath = configPath(projectRoot);
     if (!(await exists(fullPath))) {

package/dist/doctor.js

@@ -484,7 +484,6 @@ export async function doctorChecks(projectRoot, options = {}) {
         const hasCcCommand = content.includes("/cc");
         const hasCcNext = content.includes("/cc-next");
         const hasCcIdeate = content.includes("/cc-ideate");
-        const hasCcLearn = content.includes("/cc-learn");
         const hasCcView = content.includes("/cc-view");
         const hasCcOps = content.includes("/cc-ops");
         const hasVerification = content.includes("Verification Discipline");
@@ -494,7 +493,6 @@ export async function doctorChecks(projectRoot, options = {}) {
             && hasCcCommand
             && hasCcNext
             && hasCcIdeate
-            && hasCcLearn
             && hasCcView
             && hasCcOps
             && hasVerification

package/dist/harness-adapters.js

@@ -30,12 +30,6 @@ const UTILITY_SHIMS = [
         skillFolder: "flow-view",
         commandFile: "view.md"
     },
-    {
-        fileName: "cc-learn.md",
-        command: "learn",
-        skillFolder: "learnings",
-        commandFile: "learn.md"
-    },
     {
         fileName: "cc-ops.md",
         command: "ops",
@@ -43,6 +37,13 @@ const UTILITY_SHIMS = [
         commandFile: "ops.md"
     }
 ];
+/**
+ * Shims that older cclaw versions installed as top-level slash commands but
+ * which we now treat as internal (skill-only, invoked by the agent, never
+ * typed by users). On sync/upgrade we proactively delete any stale file from
+ * harness command directories so `/cc-learn` etc. do not linger.
+ */
+const LEGACY_HARNESS_SHIMS = ["cc-learn.md"];
 export function harnessShimFileNames() {
     return ["cc.md", ...UTILITY_SHIMS.map((shim) => shim.fileName)];
 }
@@ -150,9 +151,11 @@ When in doubt, prefer **non-trivial** — the quick track is opt-in and only saf
 | \`/cc-next\` | **Progression.** Advances to the next stage when current is complete. |
 | \`/cc-ideate\` | **Discovery mode.** Generates a ranked repo-improvement backlog before implementation. |
 | \`/cc-view\` | **Read-only router.** Unified entry for status/tree/diff views. |
-| \`/cc-learn\` | **Cross-cutting.** Capture or review project knowledge (append-only JSONL). |
 | \`/cc-ops\` | **Operations router.** Unified entry for feature/tdd-log/retro/compound/archive/rewind actions. |
 
+Knowledge capture and curation run automatically as part of stage completion
+protocols via the internal \`learnings\` skill — no user-facing command.
+
 **Stage order:** brainstorm > scope > design > spec > plan > tdd > review > ship.
 \`/cc-next\` loads the right stage skill automatically. Gates must pass before handoff.
 
@@ -263,6 +266,15 @@ export async function syncHarnessShims(projectRoot, harnesses) {
         for (const shim of UTILITY_SHIMS) {
             await writeFileSafe(path.join(commandDir, shim.fileName), utilityShimContent(harness, shim.command, shim.skillFolder, shim.commandFile));
         }
+        for (const legacy of LEGACY_HARNESS_SHIMS) {
+            const legacyPath = path.join(commandDir, legacy);
+            try {
+                await fs.unlink(legacyPath);
+            }
+            catch {
+                // fine — file may not exist (fresh install) or may be on read-only FS
+            }
+        }
     }
     await syncAgentFiles(projectRoot);
     await syncAgentsMd(projectRoot, harnesses);

package/dist/install.d.ts

@@ -1,10 +1,8 @@
-import type { FlowTrack, HarnessId, InitProfile } from "./types.js";
+import type { FlowTrack, HarnessId } from "./types.js";
 export interface InitOptions {
     projectRoot: string;
     harnesses?: HarnessId[];
     track?: FlowTrack;
-    /** When set, pre-fills config defaults from the named profile before applying flag overrides. */
-    profile?: InitProfile;
 }
 export declare function initCclaw(options: InitOptions): Promise<void>;
 export declare function syncCclaw(projectRoot: string): Promise<void>;
@@ -15,8 +13,8 @@ export declare function syncCclaw(projectRoot: string): Promise<void>;
  * `promptGuardMode`, `tddEnforcement`, `gitHookGuards`, `languageRulePacks`,
  * and `trackHeuristics` are preserved verbatim from the existing config.
  *
- * For an explicit reset to the default profile the user should reinstall via
- * `cclaw init --profile=<id>` (after optionally archiving the current run).
+ * For an explicit reset, run `cclaw-cli uninstall && cclaw-cli init`
+ * (after optionally archiving the current run via `/cc-ops archive`).
  */
 export declare function upgradeCclaw(projectRoot: string): Promise<void>;
 export declare function uninstallCclaw(projectRoot: string): Promise<void>;

package/dist/install.js

@@ -3,7 +3,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { CCLAW_VERSION, COMMAND_FILE_ORDER, FLOW_VERSION, REQUIRED_DIRS, RUNTIME_ROOT } from "./constants.js";
-import { writeConfig, createDefaultConfig, createProfileConfig, readConfig, configPath } from "./config.js";
+import { writeConfig, createDefaultConfig, readConfig, configPath } from "./config.js";
 import { commandContract } from "./content/contracts.js";
 import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
@@ -1088,12 +1088,7 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await ensureGitignore(projectRoot);
 }
 export async function initCclaw(options) {
-    const config = options.profile
-        ? createProfileConfig(options.profile, {
-            harnesses: options.harnesses,
-            defaultTrack: options.track
-        })
-        : createDefaultConfig(options.harnesses, options.track);
+    const config = createDefaultConfig(options.harnesses, options.track);
     await writeConfig(options.projectRoot, config);
     await materializeRuntime(options.projectRoot, config, true);
 }
@@ -1111,8 +1106,8 @@ export async function syncCclaw(projectRoot) {
  * `promptGuardMode`, `tddEnforcement`, `gitHookGuards`, `languageRulePacks`,
  * and `trackHeuristics` are preserved verbatim from the existing config.
  *
- * For an explicit reset to the default profile the user should reinstall via
- * `cclaw init --profile=<id>` (after optionally archiving the current run).
+ * For an explicit reset, run `cclaw-cli uninstall && cclaw-cli init`
+ * (after optionally archiving the current run via `/cc-ops archive`).
  */
 export async function upgradeCclaw(projectRoot) {
     const existing = await readConfig(projectRoot);

package/dist/types.d.ts

@@ -15,18 +15,6 @@ export type FlowTrack = (typeof FLOW_TRACKS)[number];
 export declare const TRACK_STAGES: Record<FlowTrack, readonly FlowStage[]>;
 export declare const HARNESS_IDS: readonly ["claude", "cursor", "opencode", "codex"];
 export type HarnessId = (typeof HARNESS_IDS)[number];
-/**
- * Init profiles pre-fill `cclaw init` flags for common install shapes.
- *
- * - `minimal` — single-harness (claude), medium track default, no git hook guards. For solo
- *   contributors who still want brainstorm/spec/plan rigor without full scope+design overhead.
- * - `standard` — default harness set, standard track, no git hook guards, advisory guards.
- *   Matches the pre-profile default behavior.
- * - `full` — default harness set, standard track, git hook guards on, strict prompt guards.
- *   For teams that want every safety rail on.
- */
-export declare const INIT_PROFILES: readonly ["minimal", "standard", "full"];
-export type InitProfile = (typeof INIT_PROFILES)[number];
 /**
  * Opt-in language rule packs. When enabled in config, `cclaw sync` installs the
  * corresponding utility skill so the meta-skill router can load language-specific

package/dist/types.js

@@ -25,17 +25,6 @@ export const TRACK_STAGES = {
     quick: ["spec", "tdd", "review", "ship"]
 };
 export const HARNESS_IDS = ["claude", "cursor", "opencode", "codex"];
-/**
- * Init profiles pre-fill `cclaw init` flags for common install shapes.
- *
- * - `minimal` — single-harness (claude), medium track default, no git hook guards. For solo
- *   contributors who still want brainstorm/spec/plan rigor without full scope+design overhead.
- * - `standard` — default harness set, standard track, no git hook guards, advisory guards.
- *   Matches the pre-profile default behavior.
- * - `full` — default harness set, standard track, git hook guards on, strict prompt guards.
- *   For teams that want every safety rail on.
- */
-export const INIT_PROFILES = ["minimal", "standard", "full"];
 /**
  * Opt-in language rule packs. When enabled in config, `cclaw sync` installs the
  * corresponding utility skill so the meta-skill router can load language-specific

package/package.json

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