cclaw-cli 0.29.0 → 0.31.0

package/README.md

@@ -1,7 +1,8 @@
 # cclaw
 
-**Install once, ship every time.** cclaw is an installer-first workflow runtime
-that gives your AI coding agent one inspectable path from idea to shipped PR:
+**Install once, ship every time.** cclaw is an installer-first workflow
+runtime that gives your AI coding agent one inspectable path from idea to
+shipped PR:
 
 > **brainstorm → scope → design → spec → plan → tdd → review → ship**
 
@@ -9,9 +10,9 @@ Every stage has real gates the agent cannot skip, every decision leaves a
 file-backed audit trail, and the same six slash commands work across
 Claude Code, Cursor, OpenCode, and OpenAI Codex.
 
-No hidden control plane. No background daemon. No plugin marketplace to
-configure. Just a repo-local `.cclaw/` runtime your whole team can read,
-diff, and reason about.
+You install cclaw **once** from the terminal, then everything happens
+inside your harness — no hidden control plane, no background daemon, no
+operational knobs to memorise.
 
 ---
 
@@ -25,74 +26,66 @@ diff, and reason about.
 - Maintainers of AI agents/skills who want **measurable prompt engineering**
   via the built-in eval harness.
 
-If you are looking for a virtual engineering org with 20+ role-play
-commands, or for a plugin marketplace ecosystem, see the
-[Compared to references](#compared-to-references) section — other tools do
-that well. cclaw trades breadth for a single, inspectable pipeline.
-
 ---
 
 ## How it works
 
-```mermaid
-flowchart LR
-    A[Idea] --> B[Brainstorm]
-    B --> C[Scope]
-    C --> D[Design]
-    D --> E[Spec]
-    E --> F[Plan]
-    F --> G[TDD]
-    G --> H[Review]
-    H --> I[Ship]
 ```
-
-```mermaid
-sequenceDiagram
-    participant U as User
-    participant H as Harness
-    participant V as cclaw hooks + skills
-    participant S as State + knowledge
-    U->>H: /cc <idea>
-    H->>V: Load stage contract + HARD-GATE
-    V->>S: Read context (state/knowledge)
-    V-->>H: Structured execution guidance
-    H->>S: Write artifacts + checkpoint
-    S-->>U: Next stage is explicit
+  ┌─────────┐   ┌──────┐   ┌────────┐   ┌──────┐   ┌──────┐
+  │  Idea   │ → │ /cc  │ → │Classify│ → │Track │ → │Stages│
+  └─────────┘   └──────┘   └────────┘   └──────┘   └──┬───┘
+                                                      │
+      ┌───────────────────────────────────────────────┘
+      ▼
+  brainstorm → scope → design → spec → plan → tdd → review → ship
+      │          │        │       │      │      │      │       │
+      ▼          ▼        ▼       ▼      ▼      ▼      ▼       ▼
+   01.md      02.md    03.md   04.md  05.md  06.md  07.md   08.md
+      │
+      └──── gates + subagents + knowledge capture happen at every step
 ```
 
 Every stage reads and writes real files under `.cclaw/`. `flow-state.json`
 holds the single source of truth for "where are we"; `knowledge.jsonl`
-accumulates reusable lessons; stage artifacts live under
-`.cclaw/artifacts/` until the feature is archived.
+accumulates reusable lessons **throughout** the flow, not only at the end;
+stage artifacts live under `.cclaw/artifacts/` until the feature is
+archived.
+
+```
+You ──► /cc <idea>
+        │
+        ▼
+   harness loads stage contract + HARD-GATE
+        │
+        ▼
+   cclaw reads state + knowledge, guides execution
+        │
+        ▼
+   artifacts written, checkpoint saved
+        │
+        ▼
+   next stage is explicit in flow-state.json
+```
 
 ---
 
 ## 30-second install
 
 ```bash
-npx cclaw-cli init
+npx cclaw-cli
 ```
 
-You will get an interactive prompt for profile, default track, and which
-harnesses to install into. For CI or scripted installs:
+Interactive setup will pick which harnesses to install into. For CI or
+scripted installs:
 
 ```bash
-npx cclaw-cli init --profile=standard --harnesses=claude,cursor --no-interactive
+npx cclaw-cli init --harnesses=claude,cursor --no-interactive
 ```
 
-### Init profiles
-
-| Profile | promptGuardMode | tddEnforcement | gitHookGuards | languageRulePacks | Use when |
-|---|---|---|---|---|---|
-| `minimal` | advisory | advisory | off | none | Personal projects, quick exploration |
-| `standard` _(default)_ | advisory | advisory | off | none | Most teams; enables the full flow without hard blocks |
-| `full` | **strict** | **strict** | **on** | all | Enterprise / regulated / multi-contributor repos |
-
-Profile values are persisted to `.cclaw/config.yaml` and preserved by
-`cclaw upgrade`. Switch profile later with `cclaw init --profile=<id>` or
-edit individual keys directly.
+That's the entire CLI interaction. Everything after install happens
+inside your harness (Claude Code, Cursor, OpenCode, or Codex).
 
-### What you get
+### What gets generated
 
 ```text
 .cclaw/
@@ -104,7 +97,7 @@ edit individual keys directly.
 ├── adapters/           # per-harness translation notes
 ├── agents/             # subagent definitions (planner, reviewer, …)
 ├── hooks/              # harness-agnostic hook scripts
-├── worktrees/          # git worktrees created by /cc-ops feature
+├── worktrees/          # isolated feature worktrees (power-user, via /cc-ops)
 ├── artifacts/          # active feature artifacts (00-idea.md → 09-retro.md)
 ├── runs/               # archived feature snapshots: YYYY-MM-DD-slug/
 ├── references/         # (optional) pinned copies of reference frameworks
@@ -122,22 +115,31 @@ Plus harness-specific shims:
 - `.codex/commands/cc*.md` + `.codex/hooks.json`
 - `AGENTS.md` with a managed routing block
 
+`.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. Full key
+reference: [`docs/config.md`](./docs/config.md).
+
 ---
 
-## The six commands
+## The four commands you actually use
 
-All six appear as slash commands in every supported harness. This is the
-entire top-level surface — everything else happens through subcommands or
-stage routing.
+All four appear as slash commands in every supported harness. This is the
+top-level user surface — everything else is either automatic or happens
+inside `/cc-ops` subcommands.
 
 | Command | What it does |
 |---|---|
-| **`/cc <idea>`** | Classify the task (software / trivial / bugfix / pure-question / non-software), discover origin docs (`docs/prd/**`, ADRs, root `PRD.md`, …), sniff the stack, recommend a track, then start the first stage of that track. `/cc` without arguments resumes the current flow. |
+| **`/cc <idea>`** | Classify the task, discover origin docs (`docs/prd/**`, ADRs, root `PRD.md`, …), sniff the stack, recommend a track, then start the first stage of that track. `/cc` without arguments resumes the current flow. |
 | **`/cc-next`** | The one progression primitive. Reads `flow-state.json`, checks gates + mandatory subagent delegations, and either resumes the current stage or advances to the next. `/cc-next` in a new session is how you **resume**. |
 | **`/cc-ideate`** | Repository improvement discovery. Scans for TODOs, flaky tests, oversized modules, docs drift, and recurring knowledge-store lessons; returns a ranked backlog before you commit to a specific feature. |
 | **`/cc-view`** | Read-only flow visibility. `/cc-view status` (default), `/cc-view tree`, `/cc-view diff` (baseline delta map). Never mutates state. |
-| **`/cc-learn`** | Append strict-schema entries to `.cclaw/knowledge.jsonl`: `rule`, `pattern`, `lesson`, or `compound`. Also curates (dedupe, promote, soft-archive) when the store grows. |
-| **`/cc-ops`** | Operational router: `feature` (git-worktree manager), `tdd-log`, `retro`, `compound` (lift repeated lessons into first-class skills/rules), `archive`, `rewind` (clear a stale stage marker). |
+
+> Power-user surface: `/cc-ops` is an operational router for manual
+> overrides (rewind a stale stage, manage parallel features, re-run a
+> compound pass). `/cc-learn` is the strict-schema knowledge writer —
+> agents call it automatically from completion protocols; you rarely
+> invoke it by hand.
 
 ### Example first-run
 
@@ -199,7 +201,7 @@ cclaw has eight stages, but a single prompt rarely needs all of them.
 
 Each stage produces a dated artifact under `.cclaw/artifacts/`:
 `00-idea.md` (seed) and `01-brainstorm.md` through `08-ship.md`
-(plus `09-retro.md` at closeout).
+(plus `09-retro.md` at automatic closeout — see below).
 
 ### Track heuristics are configurable
 
@@ -231,80 +233,31 @@ Reclassification is append-only: the old decision stays in history.
 
 ---
 
-## Quality loop: `cclaw doctor`
-
-Run anytime. Non-zero exit code means something observably wrong with the
-`.cclaw/` runtime.
-
-```bash
-cclaw doctor                   # full sweep, PASS/FAIL summary
-cclaw doctor --reconcile-gates # also recompute current stage gate evidence
-cclaw doctor --explain         # include fix + doc reference per check
-cclaw doctor --only=error      # or --only=trace:,hook: for narrow sweeps
-cclaw doctor --quiet           # only failing checks (CI-friendly)
-cclaw doctor --json            # machine-readable, exit 2 on error failures
-```
-
-Each failing check points at:
-
-- a **severity** (error / warning / info)
-- a one-line **summary**
-- concrete **details** from your repo
-- a **fix** string and a **doc reference** when `--explain` is on
-
-Example:
-
-```text
-[ERROR]
-FAIL trace:matrix_populated :: spec artifact exists but trace matrix is empty
-  details: .cclaw/artifacts/04-spec.md has 3 acceptance criteria; 0 mapped
-  fix: rebuild trace matrix via /cc-next (spec completion protocol) or edit 04-spec.md to add testable criteria
-  docs: .cclaw/skills/specification-authoring/SKILL.md#trace-matrix
-
-Doctor status: BLOCKED (1 failing error check)
-```
-
-Add `cclaw doctor` to a pre-commit hook or CI job (`exit 2` on error
-severity) and you inherit a shared definition of "the runtime is healthy".
-
----
-
-## Closeout and compounding
-
-Shipping a feature is a **separate stage** (`08-ship.md`), followed by two
-more disciplined steps:
-
-```text
-/cc-ops retro       # writes 09-retro.md; gates knowledge capture (≥1 compound line)
-/cc-ops compound    # (optional) lifts repeated learnings into first-class rules/skills
-/cc-ops archive     # moves artifacts/ to runs/YYYY-MM-DD-slug/, resets flow-state
-```
-
-Archive is gated on retro completion unless you explicitly pass
-`--skip-retro --retro-reason="..."`. You cannot accidentally lose the
-learning pass.
-
-Knowledge entries are strict JSONL with frequency, maturity, and provenance
-fields — not freeform markdown — so they stay machine-queryable across
-sessions and contributors.
-
----
-
-## Parallel features with git worktrees
-
-Use `/cc-ops feature` to run more than one cclaw flow side by side without
-copying `.cclaw/` state:
+## Guardrails that ship in the box
 
-```text
-/cc-ops feature new payments-revamp   # creates a git worktree + isolated registry
-/cc-ops feature list                  # shows all active features + their branches
-/cc-ops feature switch checkout-refactor
-/cc-ops feature status                # which feature this workspace is attached to
-```
+These are the things that make cclaw "enterprise-strong" without turning
+it into ceremony:
 
-Each feature is a real `git worktree` with its own branch, its own
-`flow-state.json`, and its own artifacts. Archive flushes the **current**
-feature back into `.cclaw/runs/`.
+- **Locked decisions (D-XX IDs).** Scope decisions are numbered and must
+  reappear in plan + TDD artifacts. The artifact linter catches any
+  silent drift.
+- **No placeholders.** `TBD`, `TODO`, `similar to task`, and "static for
+  now"-style scope reduction are flagged before a stage completes.
+- **Stale-stage detection.** If an upstream artifact changes after a
+  downstream stage is already complete, cclaw marks the downstream stage
+  stale and refuses to advance until you re-run it (or explicitly
+  acknowledge via a manual override).
+- **Mandatory subagent delegation** at TDD, with per-harness waivers.
+- **Turn Announce Discipline.** Every stage entry/exit emits a visible
+  line so users can see what the agent is doing, not just what it says.
+- **Extracted protocols.** Decision, Completion, and Ethos protocols live
+  in a single place (`.cclaw/contexts/`), so every skill speaks the same
+  dialect.
+- **Knowledge capture throughout the flow.** Every stage completion
+  protocol can emit entries to `knowledge.jsonl` — not only retro. Strict
+  JSONL schema keeps it machine-queryable.
+- **Automatic integrity checks.** Runtime health is verified on every
+  stage transition — no command you need to remember to run.
 
 ---
 
@@ -323,9 +276,26 @@ subagent as `completed` or explicitly `waived` (for harnesses without
 native subagent dispatch, such as Codex — see
 [Harness support](#harness-support)).
 
-In **full** profile, `tddEnforcement: strict` blocks progression until a
-real test file is present and matches one of your configured
-`tddTestGlobs`.
+---
+
+## Ship and closeout
+
+Shipping writes `08-ship.md` and then closes out the feature through a
+guided three-step sequence:
+
+1. **Retro** drafts `09-retro.md` from flow artifacts and the delegation
+   log; you review and accept.
+2. **Compound pass** promotes repeated knowledge entries (frequency ≥ 2,
+   maturity = stable) into first-class rules or skills.
+3. **Archive** moves artifacts to `.cclaw/runs/YYYY-MM-DD-<slug>/` and
+   resets `flow-state.json`.
+
+Retro is not optional — archive is gated on retro completion so you can't
+silently lose the learning pass.
+
+> **Coming next:** cclaw will chain these three steps automatically from
+> `ship` (one structured `edit`/`accept`/`skip` ask, resumable if the
+> session ends). Tracked as the v0.32 closeout-automation wave.
 
 ---
 
@@ -335,62 +305,26 @@ cclaw is honest about which harnesses give you full automation and which
 need small manual bridges. See
 [`docs/harnesses.md`](./docs/harnesses.md) for the full matrix.
 
-| Harness | Tier | Native subagent dispatch | Hook surface | Structured ask |
+| Harness | Subagent dispatch | Hook surface | Structured ask | Status |
 |---|---|---|---|---|
-| Claude Code | tier1 | full | full | `AskUserQuestion` |
-| Cursor | tier2 | partial | full | `AskQuestion` |
-| OpenCode | tier2 | partial | plugin | plain-text |
-| OpenAI Codex | tier2 | none | full | plain-text |
-
-Capability gaps are captured in `.cclaw/state/harness-gaps.json` and
-surfaced by `cclaw doctor`. Where native dispatch is missing, cclaw emits
-a structured **waiver** rather than pretending the delegation happened.
-
----
-
-## Guardrails that ship in the box
+| Claude Code | native | full | `AskUserQuestion` | full parity |
+| Cursor | partial | full | `AskQuestion` | parity gap: subagent dispatch |
+| OpenCode | partial | plugin | plain-text | parity gap: plugin hooks |
+| OpenAI Codex | none (waiver) | full | plain-text | parity gap: no subagent |
 
-These are the things that make cclaw "enterprise-strong" without turning
-it into ceremony:
-
-- **Locked decisions (D-XX IDs).** Scope decisions are numbered and must
-  reappear in plan + TDD artifacts. The artifact linter catches any
-  silent drift.
-- **No placeholders.** `TBD`, `TODO`, `similar to task`, and "static for
-  now"-style scope reduction are flagged before a stage completes.
-- **Stale-stage detection.** If an upstream artifact changes after a
-  downstream stage is already complete, cclaw marks the downstream stage
-  stale and refuses to advance until you re-run it (or explicitly
-  acknowledge via `/cc-ops rewind --ack <stage>`).
-- **Mandatory subagent delegation** at TDD, with per-harness waivers.
-- **Turn Announce Discipline.** Every stage entry/exit emits a visible
-  line so users can see what the agent is doing, not just what it says.
-- **Extracted protocols.** Decision, Completion, and Ethos protocols live
-  in a single place (`.cclaw/contexts/`), so every skill speaks the same
-  dialect.
-- **Strict JSONL knowledge schema.** Queryable from scripts, not just
-  grep-able.
+Capability gaps are captured in `.cclaw/state/harness-gaps.json`. Where
+native dispatch is missing, cclaw emits a **structured waiver** rather
+than pretending the delegation happened. Closing these gaps is an
+ongoing kinetic effort — see the harness tracking doc above.
 
 ---
 
 ## Eval-driven prompt engineering
 
-cclaw ships with `cclaw eval` — a three-tier regression harness for the
-skills and contracts the runtime generates. Use it when you change a
+cclaw ships with `cclaw-cli eval` — a three-tier regression harness for
+the skills and contracts the runtime generates. Use it when you change a
 stage skill, tweak a prompt, or swap a model.
 
-```bash
-cclaw eval --dry-run                              # validate corpus + config
-cclaw eval --schema-only                          # L1 structural (PR-blocking, no LLM)
-cclaw eval --rules                                # L1 + L2 rule-based
-cclaw eval --judge --mode=fixture --stage=spec    # L3 LLM judge against a fixture
-cclaw eval --judge --mode=agent --stage=plan      # draft in a sandbox, then judge
-cclaw eval --mode=workflow --judge                # full multi-stage run (Tier C)
-cclaw eval --compare-model=gpt-4o-mini            # diff two models against same corpus
-cclaw eval diff 0.26.0 latest                     # compare two saved reports
-cclaw eval --background                           # long runs go to .cclaw/evals/runs/
-```
-
 Works with any OpenAI-compatible endpoint — Zhipu AI GLM, OpenAI, Together,
 self-hosted vLLM — via three environment variables:
 
@@ -398,89 +332,32 @@ self-hosted vLLM — via three environment variables:
 CCLAW_EVAL_API_KEY=...
 CCLAW_EVAL_BASE_URL=https://api.z.ai/api/coding/paas/v4   # default
 CCLAW_EVAL_MODEL=glm-5.1                                  # default
-CCLAW_EVAL_DAILY_USD_CAP=5                                # optional cost guard
 ```
 
-Full details and the eval contract live in
+Full details, corpus format, and the eval contract live in
 [`docs/evals.md`](./docs/evals.md).
 
 ---
 
 ## CLI reference
 
-```bash
-cclaw init [--profile=<id>] [--harnesses=<list>] [--track=<id>] \
-           [--interactive | --no-interactive] [--dry-run]
-cclaw sync                                                      # regenerate shims
-cclaw doctor [--reconcile-gates] [--explain] [--quiet] \
-             [--only=<filter>] [--json]
-cclaw upgrade                                                    # refresh generated files; preserve config
-cclaw archive [--name=<slug>] [--skip-retro --retro-reason=<t>]
-cclaw eval   <see evals section above>
-cclaw uninstall                                                  # remove .cclaw + generated shims
-cclaw --version                                                  # shows the installed package version
-```
-
-`sync` regenerates shims and runtime files without touching user artifacts,
-state, or config keys. `upgrade` does the same **and** bumps the version
-stamp in `.cclaw/config.yaml`, preserving every custom profile/heuristic
-key. To reset to a named profile, re-run `cclaw init --profile=<id>`.
-
----
-
-## Compared to references
-
-cclaw stands on the shoulders of several open frameworks. Each one is
-genuinely good at something. Here is the honest tradeoff.
-
-**Superpowers** (obra) ships a mature methodology where skills compose and
-activate ambiently. cclaw trades that breadth for a **single auditable
-pipeline**: `flow-state.json`, stage gates, and `cclaw doctor` make it easy
-to see *why* the agent is allowed to advance. Choose Superpowers for
-ecosystem richness; choose cclaw when deterministic stage discipline
-matters more than plugin variety.
-
-**G-Stack** is a full virtual engineering org — dozens of slash commands
-for planning, design, QA, and release. cclaw deliberately keeps **one
-stage machine** and the same six harness entrypoints, prioritizing
-repeatability across harnesses over role-surface area. Use G-Stack when
-you want explicit multi-role theater; use cclaw when you want one pipeline
-across Claude, Cursor, OpenCode, and Codex.
-
-**Everything Claude Code** is an optimization and inventory system —
-memory, instincts, security, and multi-ecosystem configs. cclaw is a
-**minimal flow runtime**: eight stages, JSONL knowledge, and evals for
-contract drift. Pair ECC-style breadth with cclaw if you need both
-coverage and a single ship path.
-
----
-
-## PR-first ship flow
-
-cclaw does not run hidden git automation. Release discipline lives inside
-the harness; repository operations stay explicit:
+The CLI is deliberately small. Everything operational happens inside
+your harness.
 
 ```bash
-git checkout main
-git pull origin main
-git checkout -b feat/<topic>
-# run the flow in the harness
-git add . && git commit -m "..."
-git push -u origin HEAD
-gh pr create
+npx cclaw-cli                   # launches interactive setup (or prints
+                                # a one-line status hint if already installed)
+npx cclaw-cli upgrade           # refresh generated files; preserves .cclaw/config.yaml
+npx cclaw-cli uninstall         # remove .cclaw + generated harness shims
+npx cclaw-cli eval …            # maintainer surface (see docs/evals.md)
+npx cclaw-cli --version
 ```
 
-After merge to `main`, CI handles release lifecycle:
-
-- **Release Drafter** updates draft notes from merged PRs.
-- **Release Publish** validates the build, publishes to npm when the
-  version is new, publishes an existing release draft or creates a new
-  GitHub Release, and uploads `.tgz` + plugin manifest artifacts.
-- **Release Package** remains available for manual / event-driven flows.
-
-Bump `package.json` in the PR to trigger a new publish.
-
-Required repository secret: `NPM_TOKEN` with publish access.
+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 — 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.29.0",
+  "version": "0.31.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {