cclaw-cli 0.48.34 → 0.49.0

package/dist/cli.js

@@ -143,14 +143,10 @@ function buildInitSurfacePreview(harnesses) {
         ".cclaw/config.yaml",
         ".cclaw/commands/*.md",
         ".cclaw/skills/*/SKILL.md",
-        ".cclaw/contexts/*.md",
         ".cclaw/templates/*",
         ".cclaw/agents/*.md",
         ".cclaw/hooks/*",
         ".cclaw/rules/**",
-        ".cclaw/adapters/*.md",
-        ".cclaw/custom-skills/README.md",
-        ".cclaw/worktrees/**",
         ".cclaw/features/** (legacy snapshots, read-only migration)",
         ".cclaw/runs/**",
         ".cclaw/artifacts/**",

package/dist/constants.d.ts

@@ -19,7 +19,7 @@ export declare const DEFAULT_HARNESSES: HarnessId[];
 export declare const EVALS_ROOT = ".cclaw/evals";
 export declare const EVALS_CONFIG_PATH = ".cclaw/evals/config.yaml";
 export declare const EVALS_DIRS: readonly [".cclaw/evals", ".cclaw/evals/corpus", ".cclaw/evals/rubrics", ".cclaw/evals/baselines", ".cclaw/evals/reports"];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/worktrees", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills", ".cclaw/evals", ".cclaw/evals/corpus", ".cclaw/evals/rubrics", ".cclaw/evals/baselines", ".cclaw/evals/reports"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/agents", ".cclaw/hooks", ".cclaw/evals", ".cclaw/evals/corpus", ".cclaw/evals/rubrics", ".cclaw/evals/baselines", ".cclaw/evals/reports"];
 export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", "# cclaw evals: user-owned, track in git", "!.cclaw/evals/", "!.cclaw/evals/config.yaml", "!.cclaw/evals/corpus/", "!.cclaw/evals/corpus/**", "!.cclaw/evals/rubrics/", "!.cclaw/evals/rubrics/**", "!.cclaw/evals/baselines/", "!.cclaw/evals/baselines/**", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".agents/skills/cc/SKILL.md", ".agents/skills/cc-*/SKILL.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 /**
  * Canonical stage -> skill folder mapping.

package/dist/constants.js

@@ -74,14 +74,11 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/contexts`,
     `${RUNTIME_ROOT}/templates`,
     `${RUNTIME_ROOT}/artifacts`,
-    `${RUNTIME_ROOT}/worktrees`,
     `${RUNTIME_ROOT}/state`,
     `${RUNTIME_ROOT}/runs`,
     `${RUNTIME_ROOT}/rules`,
-    `${RUNTIME_ROOT}/adapters`,
     `${RUNTIME_ROOT}/agents`,
     `${RUNTIME_ROOT}/hooks`,
-    `${RUNTIME_ROOT}/custom-skills`,
     ...EVALS_DIRS
 ];
 export const REQUIRED_GITIGNORE_PATTERNS = [

package/dist/content/contexts.d.ts

@@ -1,6 +1,15 @@
 export declare const DEFAULT_CONTEXT_MODE = "default";
-export declare const CONTEXT_MODES: Record<string, string>;
-export declare function contextModeFiles(): Record<string, string>;
+/**
+ * Valid context mode identifiers used by the session hooks and the
+ * `context-engineering` skill. Mode bodies no longer live as separate
+ * `.cclaw/contexts/<mode>.md` files — the guidance was merged into the
+ * `context-engineering` skill. This list only exists so `doctor` can
+ * validate that `state/context-mode.json#activeMode` references a known
+ * mode name.
+ */
+export declare const AVAILABLE_CONTEXT_MODES: readonly ["default", "execution", "review", "incident"];
+/** Legacy alias: kept so existing imports keep typechecking. */
+export declare const CONTEXT_MODES: Record<string, true>;
 export interface ContextModeState {
     activeMode: string;
     updatedAt: string;

package/dist/content/contexts.js

@@ -1,65 +1,24 @@
 export const DEFAULT_CONTEXT_MODE = "default";
-export const CONTEXT_MODES = {
-    default: `# Context Mode: default
-
-Use for most day-to-day feature work.
-
-## Focus
-- Follow the active cclaw stage strictly.
-- Keep changes within the current task blast radius.
-- Prefer incremental progress with frequent verification.
-
-## Decision posture
-- Escalate only meaningful trade-offs.
-- Ask for user confirmation only at explicit stage gates.
-`,
-    execution: `# Context Mode: execution
-
-Use when plan/spec are approved and the goal is high-throughput delivery.
-
-## Focus
-- Prioritize deterministic implementation flow (RED -> GREEN -> REFACTOR).
-- Minimize conversational overhead; keep updates concise and evidence-first.
-- Batch machine-only checks through subagent dispatch where supported.
-
-## Decision posture
-- Avoid reopening settled design debates unless a blocker appears.
-- Stop immediately on failing quality gates or unresolved critical findings.
-`,
-    review: `# Context Mode: review
-
-Use for deep validation, risk discovery, and merge readiness.
-
-## Focus
-- Bias toward finding concrete defects, regressions, and evidence gaps.
-- Cross-check spec, plan, tests, and implementation alignment.
-- Treat unsupported claims as unverified until backed by command output.
-
-## Decision posture
-- Classify findings by severity and expected blast radius.
-- Block ship decisions when critical issues remain unresolved.
-`,
-    incident: `# Context Mode: incident
-
-Use for production failures, emergency regressions, or urgent stabilization.
-
-## Focus
-- Reproduce first, then isolate, then fix.
-- Favor smallest safe change with rollback clarity.
-- Preserve timeline and evidence for post-incident learning.
-
-## Decision posture
-- Prefer containment over optimization.
-- Require explicit evidence for declaring recovery complete.
-`
-};
-export function contextModeFiles() {
-    return { ...CONTEXT_MODES };
-}
+/**
+ * Valid context mode identifiers used by the session hooks and the
+ * `context-engineering` skill. Mode bodies no longer live as separate
+ * `.cclaw/contexts/<mode>.md` files — the guidance was merged into the
+ * `context-engineering` skill. This list only exists so `doctor` can
+ * validate that `state/context-mode.json#activeMode` references a known
+ * mode name.
+ */
+export const AVAILABLE_CONTEXT_MODES = [
+    "default",
+    "execution",
+    "review",
+    "incident"
+];
+/** Legacy alias: kept so existing imports keep typechecking. */
+export const CONTEXT_MODES = Object.fromEntries(AVAILABLE_CONTEXT_MODES.map((mode) => [mode, true]));
 export function createInitialContextModeState(nowIso = new Date().toISOString()) {
     return {
         activeMode: DEFAULT_CONTEXT_MODE,
         updatedAt: nowIso,
-        availableModes: Object.keys(CONTEXT_MODES)
+        availableModes: [...AVAILABLE_CONTEXT_MODES]
     };
 }

package/dist/content/meta-skill.js

@@ -106,9 +106,6 @@ Load utility skills only when triggered by the current task:
 - iron-laws as policy arbitration when instructions conflict
 - language rule packs from \`.cclaw/config.yaml\` when enabled
 
-Custom project skills under \`.cclaw/custom-skills/\` are opt-in supplements,
-never mandatory delegations.
-
 ## Protocol references
 
 Do not inline these protocols in stage skills; cite by path:

package/dist/content/opencode-plugin.js

@@ -12,6 +12,7 @@ export default function cclawPlugin(ctx) {
   const stateDir = join(runtimeDir, "state");
   const logsDir = join(runtimeDir, "logs");
   const pluginLogPath = join(logsDir, "opencode-plugin.log");
+  const configPath = join(runtimeDir, "config.yaml");
   const flowStatePath = join(stateDir, "flow-state.json");
   const checkpointPath = join(stateDir, "checkpoint.json");
   const activityPath = join(stateDir, "stage-activity.jsonl");
@@ -306,6 +307,41 @@ export default function cclawPlugin(ctx) {
     lastHookStderr.set(hookName, trimmed);
   }
 
+  /**
+   * A hook process can exit non-zero for two very different reasons:
+   *   (a) the guard legitimately decided to refuse an operation
+   *       (strict-mode refusal — this is the *only* case we ever want
+   *       to surface as a block to the user), or
+   *   (b) the hook infrastructure itself failed — the runtime crashed,
+   *       a child binary was missing, stderr is a chunk of yargs help
+   *       from some unrelated process, timeout, etc.
+   *
+   * Treating (b) as a block is what produces the "guard blocked
+   * tool.execute.before" error on a user who did nothing wrong. The
+   * heuristic below trims guaranteed-infra signals so only cleanly
+   * structured guard output is eligible for a real strict-mode block.
+   */
+  const INFRA_NOISE_PATTERNS = [
+    /^\\s*(Usage|Options|Commands|Examples|Positionals|Aliases):/im,
+    /^\\s*--[a-z][a-z0-9-]*\\b.*\\[(string|boolean|number|array)\\]/im,
+    /\\bcommand (not found|failed)\\b/i,
+    /\\bno such file or directory\\b/i,
+    /\\bCannot find module\\b/i,
+    /\\bThrowsCompletion\\b/,
+    /\\b(Reference|Syntax|Type|Range)Error\\b/,
+    /^\\s*at [^\\n]+\\([^)]*:\\d+:\\d+\\)/im,
+    /^\\s*node:internal\\b/im
+  ];
+  function looksLikeInfrastructureFailure(stderr) {
+    if (typeof stderr !== "string") return true;
+    const trimmed = stderr.trim();
+    if (trimmed.length === 0) return true;
+    for (const pattern of INFRA_NOISE_PATTERNS) {
+      if (pattern.test(trimmed)) return true;
+    }
+    return false;
+  }
+
   async function runHookScript(hookName, payload = {}) {
     const { spawn } = await import("node:child_process");
     const hookRuntimePath = join(root, "${RUNTIME_ROOT}/hooks/run-hook.mjs");
@@ -406,14 +442,42 @@ export default function cclawPlugin(ctx) {
    * still runs through guards.
    */
   const SAFE_READONLY_TOOLS = new Set([
+    // Filesystem / search reads — no state mutation possible.
     "read",
     "glob",
     "grep",
     "list",
     "ls",
     "view",
+    "find",
+    // Network reads — no local state mutation.
     "webfetch",
-    "websearch"
+    "websearch",
+    // User-facing question / ask tools: they only ask the human for
+    // input and cannot touch the filesystem or execute code. Blocking
+    // them strands the plugin mid-decision (see OpenCode's \`question\`).
+    "question",
+    "ask",
+    "askuser",
+    "askquestion",
+    "ask_question",
+    "ask_user",
+    "ask_user_question",
+    "askuserquestion",
+    "request_user_input",
+    "requestuserinput",
+    "prompt",
+    // Thinking / scratchpad tools — pure reasoning with no side effects.
+    "think",
+    "thinking",
+    // Todo bookkeeping tools — they write only inside the harness's own
+    // session state, not project files, and blocking them breaks agent
+    // planning without protecting anything.
+    "todo",
+    "todoread",
+    "todowrite",
+    "todo_read",
+    "todo_write"
   ]);
 
   function isSafeReadOnlyTool(payload) {
@@ -435,6 +499,42 @@ export default function cclawPlugin(ctx) {
     return false;
   }
 
+  /**
+   * Strictness derived from (in order of precedence): CCLAW_STRICTNESS
+   * env override, \`.cclaw/config.yaml\` key \`strictness\`, or the
+   * library default of "advisory". The plugin only ever *blocks* tool
+   * execution when strictness resolves to "strict"; in advisory mode
+   * guard failures are logged and the tool call proceeds. This mirrors
+   * the Ralph-loop / hook-runtime semantics of
+   * \`DEFAULT_STRICTNESS = advisory\`, so the plugin can no longer
+   * accidentally be the stricter half of a mismatched pair.
+   */
+  function readConfigStrictness() {
+    try {
+      if (!existsSync(configPath)) return "";
+      const { readFileSync } = require("node:fs");
+      const raw = readFileSync(configPath, "utf8");
+      if (typeof raw !== "string" || raw.length === 0) return "";
+      const match = raw.match(/^\\s*strictness\\s*:\\s*([A-Za-z0-9_-]+)/m);
+      return match && typeof match[1] === "string" ? match[1].trim().toLowerCase() : "";
+    } catch {
+      return "";
+    }
+  }
+
+  function resolveStrictness() {
+    const envRaw = typeof process.env.CCLAW_STRICTNESS === "string"
+      ? process.env.CCLAW_STRICTNESS.trim().toLowerCase()
+      : "";
+    if (envRaw === "strict") return "strict";
+    if (envRaw === "advisory" || envRaw === "off" || envRaw === "disabled" || envRaw === "none") {
+      return "advisory";
+    }
+    const fileRaw = readConfigStrictness();
+    if (fileRaw === "strict") return "strict";
+    return "advisory";
+  }
+
   /**
    * cclaw considers itself "active" in a project when both the state
    * file and the hook runtime script exist. If either is missing the
@@ -618,11 +718,35 @@ export default function cclawPlugin(ctx) {
         const failed = !promptOk ? "prompt-guard" : "workflow-guard";
         const rawDetail = lastHookStderr.get(failed) || "";
         const detail = rawDetail.length > 0 ? rawDetail.slice(-400) : "(no stderr captured)";
+        if (looksLikeInfrastructureFailure(rawDetail)) {
+          // Never let a broken hook runtime or misrouted child-process
+          // stderr (yargs help, Node crash, ENOENT, timeout) masquerade
+          // as a policy block. Log the infra hit and let the user keep
+          // working regardless of strictness.
+          logToFile(
+            "infra: " + failed + " non-zero exit with non-guard stderr — treated as infrastructure failure, tool allowed. " +
+            "stderr=" + detail.replace(/\\s+/g, " ").slice(0, 300)
+          );
+          return;
+        }
+        const strictness = resolveStrictness();
+        if (strictness !== "strict") {
+          // Advisory mode (the default) — every guard refusal is a hint,
+          // not a hard stop. Users report the "failure" as a log line
+          // and keep working. Only \`strictness: strict\` in config.yaml
+          // or CCLAW_STRICTNESS=strict upgrades this to a thrown block.
+          logToFile(
+            "advisory: " + failed + " flagged tool.execute.before (strictness=" +
+            strictness + "). detail=" + detail.replace(/\\s+/g, " ").slice(0, 300)
+          );
+          return;
+        }
         throw new Error(
           "cclaw " + failed + " blocked tool.execute.before.\\n" +
           "Reason: " + detail + "\\n" +
           "Diagnose: run \`cclaw doctor\` in project root.\\n" +
-          "Bypass (temporary): export CCLAW_DISABLE=1 before starting OpenCode."
+          "Bypass (temporary): export CCLAW_DISABLE=1 before starting OpenCode,\\n" +
+          "or set \`strictness: advisory\` in .cclaw/config.yaml."
         );
       }
     },

package/dist/content/utility-skills.js

@@ -565,11 +565,12 @@ Do not keep stale or oversized context loaded when task intent changes. Context
 
 ## Context Modes
 
-Modes are stored in \`.cclaw/contexts/\`:
-- \`default\` — balanced execution
-- \`execution\` — fast plan/tdd throughput
-- \`review\` — defect/risk discovery
-- \`incident\` — stabilization and recovery
+Four intentional postures tracked via \`.cclaw/state/context-mode.json\`:
+
+- \`default\` — balanced execution. Follow active stage, keep changes scoped, escalate real trade-offs only.
+- \`execution\` — high-throughput delivery after spec/plan lock. RED→GREEN→REFACTOR. Evidence-first, minimal chatter.
+- \`review\` — deep validation. Bias toward concrete defects, unsupported claims treated as unverified.
+- \`incident\` — stabilization. Reproduce, isolate, fix smallest safe change first. Preserve evidence.
 
 ## Mode Switching Protocol
 
@@ -578,7 +579,7 @@ Modes are stored in \`.cclaw/contexts/\`:
    - \`activeMode\`: target mode id
    - \`updatedAt\`: current ISO timestamp
 3. Announce mode change in-session with one-line reason.
-4. Continue using the corresponding \`.cclaw/contexts/<mode>.md\` guidance.
+4. Keep applying the posture above until the next explicit mode switch.
 
 ## Payload Hygiene Rules
 

package/dist/doctor.js

@@ -1241,62 +1241,6 @@ export async function doctorChecks(projectRoot, options = {}) {
         ok: await exists(path.join(projectRoot, RUNTIME_ROOT, "state", "harness-gaps.json")),
         details: `${RUNTIME_ROOT}/state/harness-gaps.json must exist for tiered harness capability tracking`
     });
-    const adapterManifestPath = path.join(projectRoot, RUNTIME_ROOT, "adapters", "manifest.json");
-    const adapterManifestExists = await exists(adapterManifestPath);
-    checks.push({
-        name: "state:adapter_manifest_exists",
-        ok: adapterManifestExists,
-        details: `${RUNTIME_ROOT}/adapters/manifest.json must exist for harness adapter provenance`
-    });
-    if (adapterManifestExists) {
-        let harnessesOk = false;
-        let harnessesDetails = "";
-        let sourcesOk = false;
-        let sourcesDetails = "";
-        try {
-            const parsed = JSON.parse(await fs.readFile(adapterManifestPath, "utf8"));
-            const manifestHarnesses = Array.isArray(parsed.harnesses)
-                ? parsed.harnesses.filter((entry) => typeof entry === "string")
-                : [];
-            const expectedHarnesses = configuredHarnesses.length > 0
-                ? [...new Set(configuredHarnesses)].sort()
-                : null;
-            const actualHarnesses = [...new Set(manifestHarnesses)].sort();
-            harnessesOk = expectedHarnesses
-                ? actualHarnesses.length === expectedHarnesses.length &&
-                    actualHarnesses.every((harness, index) => harness === expectedHarnesses[index])
-                : actualHarnesses.length > 0;
-            harnessesDetails = expectedHarnesses
-                ? harnessesOk
-                    ? `adapter manifest harnesses match config.yaml: ${actualHarnesses.join(", ")}`
-                    : `adapter manifest harnesses [${actualHarnesses.join(", ")}] do not match config.yaml [${expectedHarnesses.join(", ")}]`
-                : harnessesOk
-                    ? `adapter manifest declares harnesses: ${actualHarnesses.join(", ")}`
-                    : "adapter manifest must declare at least one harness";
-            const commandSource = typeof parsed.commandSource === "string" ? parsed.commandSource.trim() : "";
-            const skillSource = typeof parsed.skillSource === "string" ? parsed.skillSource.trim() : "";
-            sourcesOk = commandSource.length > 0 && skillSource.length > 0;
-            sourcesDetails = sourcesOk
-                ? `adapter manifest source globs are set (commandSource=${commandSource}; skillSource=${skillSource})`
-                : "adapter manifest must include non-empty commandSource and skillSource";
-        }
-        catch {
-            harnessesOk = false;
-            harnessesDetails = "adapter manifest must be valid JSON with a harnesses array";
-            sourcesOk = false;
-            sourcesDetails = "adapter manifest must be valid JSON with source globs";
-        }
-        checks.push({
-            name: "state:adapter_manifest_harnesses",
-            ok: harnessesOk,
-            details: harnessesDetails
-        });
-        checks.push({
-            name: "state:adapter_manifest_sources",
-            ok: sourcesOk,
-            details: sourcesDetails
-        });
-    }
     const contextModeStatePath = path.join(projectRoot, RUNTIME_ROOT, "state", "context-mode.json");
     checks.push({
         name: "state:context_mode_exists",
@@ -1319,14 +1263,6 @@ export async function doctorChecks(projectRoot, options = {}) {
             details: `${RUNTIME_ROOT}/state/context-mode.json must reference one of: ${Object.keys(CONTEXT_MODES).join(", ")} (default=${DEFAULT_CONTEXT_MODE})`
         });
     }
-    for (const mode of Object.keys(CONTEXT_MODES)) {
-        const modePath = path.join(projectRoot, RUNTIME_ROOT, "contexts", `${mode}.md`);
-        checks.push({
-            name: `contexts:mode:${mode}`,
-            ok: await exists(modePath),
-            details: modePath
-        });
-    }
     await ensureFeatureSystem(projectRoot, { repair: false });
     const activeFeature = await readActiveFeature(projectRoot, { repair: false });
     let flowState = createInitialFlowState();

package/dist/install.js

@@ -5,7 +5,7 @@ import { promisify } from "node:util";
 import { CCLAW_VERSION, FLOW_VERSION, REQUIRED_DIRS, RUNTIME_ROOT } from "./constants.js";
 import { writeConfig, createDefaultConfig, readConfig, configPath, detectLanguageRulePacks, detectAdvancedKeys } from "./config.js";
 import { stageCommandContract } from "./content/contracts.js";
-import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
+import { createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
 import { ideateCommandContract, ideateCommandSkillMarkdown } from "./content/ideate-command.js";
@@ -799,151 +799,6 @@ async function ensureKnowledgeStore(projectRoot) {
         await fs.rm(legacyMdPath, { force: true });
     }
 }
-async function ensureCustomSkillsScaffold(projectRoot) {
-    const customDir = runtimePath(projectRoot, "custom-skills");
-    await ensureDir(customDir);
-    const readmePath = path.join(customDir, "README.md");
-    if (!(await exists(readmePath))) {
-        await writeFileSafe(readmePath, CUSTOM_SKILLS_README);
-    }
-    const examplePath = path.join(customDir, "example", "SKILL.md");
-    if (!(await exists(examplePath))) {
-        await writeFileSafe(examplePath, CUSTOM_SKILLS_EXAMPLE);
-    }
-}
-const CUSTOM_SKILLS_README = `# Custom Skills (sync-safe)
-
-This directory is **never overwritten** by \`cclaw sync\` or \`cclaw upgrade\`. Use it
-to add project-specific skills that complement the managed skills under
-\`.cclaw/skills/\`.
-
-## When to add a custom skill
-
-- A repeatable lens specific to **this project** (e.g. "billing-domain", "kafka-message-contracts").
-- A team convention you want every agent session to load.
-- A domain checklist that does not generalize to other projects.
-
-If the skill is general (security, performance, accessibility, etc.) prefer
-contributing it upstream instead — the managed skills receive maintenance.
-
-## File format — public API (stable contract)
-
-Each skill lives at \`.cclaw/custom-skills/<folder>/SKILL.md\`. The format is a
-**stable public API**: \`cclaw sync\` and \`cclaw upgrade\` will not rewrite
-custom skills, and the fields below are guaranteed to be respected by the
-meta-skill router and the stage hooks.
-
-### Frontmatter (YAML, required)
-
-\`\`\`yaml
----
-# Required fields
-name: <kebab-case-skill-name>
-description: >
-  One sentence (≤180 chars) that triggers semantic routing. Include the
-  concrete situation and the expected action
-  (e.g. "Audit Kafka topic contracts when a producer or consumer signature changes").
-
-# Optional fields (omit when not applicable)
-stages: [design, spec, tdd, review]    # flow stages this skill applies to
-triggers:
-  - "kafka topic"
-  - "producer.schema"
-  - "consumer.schema"
-hardGate: false                        # true => skill body MUST include a ## HARD-GATE section
-owners: ["@team-messaging"]            # informational routing hint, not enforced
-version: 0.1.0                         # semver; bump when hardGate or algorithm changes
----
-\`\`\`
-
-### Field contract
-
-| Field | Type | Required | Meaning |
-|---|---|---|---|
-| \`name\` | string (kebab-case) | yes | Unique id used by the router and by \`/cc-view status\` diagnostics. |
-| \`description\` | string ≤180 chars (single line OR YAML \`>\` folded) | yes | Drives semantic routing. Include trigger + action. |
-| \`stages\` | array of flow stages | no | When present, the meta-skill only surfaces this skill during those stages. Omit for "any stage". |
-| \`triggers\` | array of strings | no | Extra literal substrings that route to this skill when found in the user prompt or the active artifact. |
-| \`hardGate\` | boolean | no | When \`true\`, the body MUST include a \`## HARD-GATE\` section; the agent treats the rule as non-skippable. |
-| \`owners\` | array of strings | no | Informational only — surfaced to the user, never enforced. |
-| \`version\` | semver string | no | Bump when you change the HARD-GATE or algorithm so reviewers can spot changes. |
-
-### Body sections (markdown, recommended order)
-
-\`\`\`markdown
-# <Skill title>
-
-## Overview
-One-paragraph summary; context for when this skill is loaded.
-
-## When to use
-- Bullet list of situations where this skill adds value.
-
-## When NOT to use
-- Situations where loading this skill is context bloat or wrong.
-
-## HARD-GATE   (REQUIRED when frontmatter hardGate: true)
-Phrase it as a refusal:
-> Do not <X> while <Y>.
-
-## Algorithm / checklist
-1. Concrete, observable steps with evidence (file:line, artifact, or knowledge entry).
-
-## Output protocol
-Where the artifact / chat output lives and what shape it takes.
-
-## Anti-patterns
-- Common failure modes to reject.
-\`\`\`
-
-### Stage association semantics
-
-- \`stages: []\` or missing → skill is available at any stage. The meta-skill still only surfaces it when \`description\` or \`triggers\` match the prompt.
-- \`stages: [review]\` → skill is offered only during the review stage.
-- Custom skills **never** become mandatory delegations. They are opt-in lenses. If you need a mandatory dispatch, add a proper managed specialist under \`.cclaw/skills/\` instead.
-
-## Routing
-
-Custom skills are surfaced via the \`using-cclaw\` meta-skill at session start.
-Mention the skill name in your prompt or let the agent semantic-route to it
-based on the description + triggers + stages frontmatter.
-
-## Versioning & removal
-
-Custom skills are user-owned. Bump \`version\` when you change the HARD-GATE or
-algorithm; delete or edit them at any time — \`cclaw sync\` will not touch them.
-`;
-const CUSTOM_SKILLS_EXAMPLE = `---
-name: example-custom-skill
-description: "Replace this with a one-sentence description that triggers when the skill should be used. Delete or rename this folder when you add a real skill."
----
-
-# Example Custom Skill
-
-This is a placeholder. Use it as a starting template, then delete or rename
-the \`example/\` folder.
-
-## When to use
-
-- A real, repeatable situation in **this** project that needs a consistent lens.
-
-## HARD-GATE (optional)
-
-Drop this section if no hard rule applies. Keep it crisp:
-
-> Do not <X> while <Y>.
-
-## Algorithm
-
-1. Step one — observable, file:line evidence required.
-2. Step two — produce a named artifact, not a vibe.
-3. Step three — escalate / hand off / record knowledge entry.
-
-## Anti-patterns
-
-- Treating this skill as advisory when the situation matches the trigger.
-- Loading this skill when the situation clearly does not match (context bloat).
-`;
 async function ensureSessionStateFiles(projectRoot) {
     const stateDir = runtimePath(projectRoot, "state");
     await ensureDir(stateDir);
@@ -1020,11 +875,6 @@ async function writeRulebook(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "rules", "RULES.md"), RULEBOOK_MARKDOWN);
     await writeFileSafe(runtimePath(projectRoot, "rules", "rules.json"), `${JSON.stringify(buildRulesJson(), null, 2)}\n`);
 }
-async function writeContextModes(projectRoot) {
-    for (const [mode, content] of Object.entries(contextModeFiles())) {
-        await writeFileSafe(runtimePath(projectRoot, "contexts", `${mode}.md`), content);
-    }
-}
 async function writeCursorWorkflowRule(projectRoot, harnesses) {
     const rulePath = path.join(projectRoot, CURSOR_RULE_REL_PATH);
     if (!harnesses.includes("cursor")) {
@@ -1073,15 +923,6 @@ async function writeState(projectRoot, config, forceReset = false) {
     const state = createInitialFlowState({ track: config.defaultTrack ?? "standard" });
     await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
 }
-async function writeAdapterManifest(projectRoot, harnesses) {
-    const manifest = {
-        generatedAt: new Date().toISOString(),
-        harnesses,
-        commandSource: `${RUNTIME_ROOT}/commands/*.md`,
-        skillSource: `${RUNTIME_ROOT}/skills/*/SKILL.md`
-    };
-    await writeFileSafe(runtimePath(projectRoot, "adapters", "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`);
-}
 async function writeHarnessGapsState(projectRoot, harnesses) {
     const report = harnesses.map((harness) => {
         const capabilities = HARNESS_ADAPTERS[harness].capabilities;
@@ -1304,7 +1145,6 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
         writeCommandContracts(projectRoot, config.defaultTrack ?? "standard"),
         writeUtilityCommands(projectRoot, config),
         writeSkills(projectRoot, config),
-        writeContextModes(projectRoot),
         writeArtifactTemplates(projectRoot),
         writeEvalScaffold(projectRoot),
         writeRulebook(projectRoot)
@@ -1312,10 +1152,8 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await writeState(projectRoot, config, forceStateReset);
     await ensureRunSystem(projectRoot, { createIfMissing: false });
     await ensureSessionStateFiles(projectRoot);
-    await writeAdapterManifest(projectRoot, harnesses);
     await writeHarnessGapsState(projectRoot, harnesses);
     await ensureKnowledgeStore(projectRoot);
-    await ensureCustomSkillsScaffold(projectRoot);
     await writeHooks(projectRoot, config);
     await syncDisabledHarnessArtifacts(projectRoot, harnesses);
     await syncManagedGitHooks(projectRoot, config);

package/dist/policy.js

@@ -181,10 +181,6 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:frontend_accessibility:hard_gate" },
         { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## Checklist", name: "utility_skill:frontend_accessibility:checklist" },
         { file: runtimeFile("skills/frontend-accessibility/SKILL.md"), needle: "## Anti-Patterns", name: "utility_skill:frontend_accessibility:anti_patterns" },
-        { file: runtimeFile("contexts/default.md"), needle: "Context Mode: default", name: "context_mode:default" },
-        { file: runtimeFile("contexts/execution.md"), needle: "Context Mode: execution", name: "context_mode:execution" },
-        { file: runtimeFile("contexts/review.md"), needle: "Context Mode: review", name: "context_mode:review" },
-        { file: runtimeFile("contexts/incident.md"), needle: "Context Mode: incident", name: "context_mode:incident" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "activeRunId", name: "hooks:session_start:active_run" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "checkpoint.json", name: "hooks:session_start:checkpoint_ref" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "stage-activity.jsonl", name: "hooks:session_start:activity_ref" },

package/package.json

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