cclaw-cli 0.1.1 → 0.2.1

package/dist/install.js

@@ -1,26 +1,171 @@
+import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
 import { COMMAND_FILE_ORDER, REQUIRED_DIRS, RUNTIME_ROOT, UTILITY_COMMANDS } from "./constants.js";
 import { writeConfig, createDefaultConfig, readConfig, configPath } from "./config.js";
 import { commandContract } from "./content/contracts.js";
 import { autoplanSkillMarkdown, autoplanCommandContract } from "./content/autoplan.js";
+import { contextModeFiles, createInitialContextModeState } from "./content/contexts.js";
 import { learnSkillMarkdown, learnCommandContract } from "./content/learnings.js";
+import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
 import { subagentDrivenDevSkill, parallelAgentsSkill } from "./content/subagents.js";
 import { sessionHooksSkillMarkdown } from "./content/session-hooks.js";
 import { sessionStartScript, stopCheckpointScript, opencodePluginJs, claudeHooksJson, cursorHooksJson, codexHooksJson } from "./content/hooks.js";
-import { contextMonitorScript, observeScript, promptGuardScript, summarizeObservationsRuntimeModule, summarizeObservationsScript } from "./content/observe.js";
+import { contextMonitorScript, observeScript, promptGuardScript, workflowGuardScript, summarizeObservationsRuntimeModule, summarizeObservationsScript } from "./content/observe.js";
 import { META_SKILL_NAME, usingCclawSkillMarkdown } from "./content/meta-skill.js";
-import { ARTIFACT_TEMPLATES, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
+import { ARTIFACT_TEMPLATES, CURSOR_WORKFLOW_RULE_MDC, RULEBOOK_MARKDOWN, buildRulesJson } from "./content/templates.js";
 import { stageSkillFolder, stageSkillMarkdown } from "./content/skills.js";
 import { UTILITY_SKILL_FOLDERS, UTILITY_SKILL_MAP } from "./content/utility-skills.js";
 import { createInitialFlowState } from "./flow-state.js";
 import { ensureDir, exists, writeFileSafe } from "./fs-utils.js";
 import { ensureGitignore, removeGitignorePatterns } from "./gitignore.js";
 import { HARNESS_ADAPTERS, syncHarnessShims, removeCclawFromAgentsMd } from "./harness-adapters.js";
+import { validateHookDocument } from "./hook-schema.js";
 import { ensureRunSystem, readFlowState } from "./runs.js";
+const OPENCODE_PLUGIN_REL_PATH = ".opencode/plugins/cclaw-plugin.mjs";
+const CURSOR_RULE_REL_PATH = ".cursor/rules/cclaw-workflow.mdc";
+const GIT_HOOK_MANAGED_MARKER = "cclaw-managed-git-hook";
+const GIT_HOOK_RUNTIME_REL_DIR = `${RUNTIME_ROOT}/hooks/git`;
+const execFileAsync = promisify(execFile);
 function runtimePath(projectRoot, ...segments) {
     return path.join(projectRoot, RUNTIME_ROOT, ...segments);
 }
+function resolveGlobalLearningsPath(projectRoot, config) {
+    if (config.globalLearnings !== true) {
+        return null;
+    }
+    const raw = config.globalLearningsPath?.trim() ?? "";
+    if (raw.length === 0) {
+        return path.join(os.homedir(), ".cclaw-global-learnings.jsonl");
+    }
+    if (raw.startsWith("~/")) {
+        return path.join(os.homedir(), raw.slice(2));
+    }
+    if (path.isAbsolute(raw)) {
+        return raw;
+    }
+    return path.join(projectRoot, raw);
+}
+async function resolveGitHooksDir(projectRoot) {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", "hooks"], {
+            cwd: projectRoot
+        });
+        const rel = stdout.trim();
+        if (rel.length === 0) {
+            return null;
+        }
+        return path.resolve(projectRoot, rel);
+    }
+    catch {
+        return null;
+    }
+}
+function managedGitRuntimeScript(hookName) {
+    const rangeExpression = hookName === "pre-commit"
+        ? 'git diff --cached --name-only'
+        : 'git diff --name-only @{upstream}...HEAD || git diff --name-only HEAD~1...HEAD';
+    return `#!/usr/bin/env bash
+# ${GIT_HOOK_MANAGED_MARKER}: runtime ${hookName}
+set -euo pipefail
+
+ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+GUARD_SCRIPT="$ROOT/${RUNTIME_ROOT}/hooks/prompt-guard.sh"
+[ -x "$GUARD_SCRIPT" ] || exit 0
+
+FILES=$(${rangeExpression} 2>/dev/null || true)
+[ -n "$FILES" ] || exit 0
+
+printf '%s\n' "$FILES" | bash "$GUARD_SCRIPT"
+`;
+}
+function managedGitRelayHook(hookName) {
+    return `#!/usr/bin/env bash
+# ${GIT_HOOK_MANAGED_MARKER}: relay ${hookName}
+set -euo pipefail
+
+ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
+RUNTIME_HOOK="$ROOT/${GIT_HOOK_RUNTIME_REL_DIR}/${hookName}.sh"
+[ -x "$RUNTIME_HOOK" ] || exit 0
+exec bash "$RUNTIME_HOOK" "$@"
+`;
+}
+async function removeManagedGitHookRelays(projectRoot) {
+    const hooksDir = await resolveGitHooksDir(projectRoot);
+    if (!hooksDir) {
+        return;
+    }
+    for (const hookName of ["pre-commit", "pre-push"]) {
+        const hookPath = path.join(hooksDir, hookName);
+        if (!(await exists(hookPath)))
+            continue;
+        let content = "";
+        try {
+            content = await fs.readFile(hookPath, "utf8");
+        }
+        catch {
+            content = "";
+        }
+        if (!content.includes(GIT_HOOK_MANAGED_MARKER)) {
+            continue;
+        }
+        await fs.rm(hookPath, { force: true });
+    }
+}
+async function syncManagedGitHooks(projectRoot, config) {
+    const hooksDir = await resolveGitHooksDir(projectRoot);
+    if (!hooksDir) {
+        return;
+    }
+    if (config.gitHookGuards !== true) {
+        await removeManagedGitHookRelays(projectRoot);
+        try {
+            await fs.rm(path.join(projectRoot, GIT_HOOK_RUNTIME_REL_DIR), { recursive: true, force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+        return;
+    }
+    const runtimeGitHooksDir = path.join(projectRoot, GIT_HOOK_RUNTIME_REL_DIR);
+    await ensureDir(runtimeGitHooksDir);
+    for (const hookName of ["pre-commit", "pre-push"]) {
+        const runtimePathForHook = path.join(runtimeGitHooksDir, `${hookName}.sh`);
+        await writeFileSafe(runtimePathForHook, managedGitRuntimeScript(hookName));
+        try {
+            await fs.chmod(runtimePathForHook, 0o755);
+        }
+        catch {
+            // best effort on constrained filesystems
+        }
+    }
+    await ensureDir(hooksDir);
+    for (const hookName of ["pre-commit", "pre-push"]) {
+        const hookPath = path.join(hooksDir, hookName);
+        let canWriteRelay = true;
+        if (await exists(hookPath)) {
+            try {
+                const existing = await fs.readFile(hookPath, "utf8");
+                canWriteRelay = existing.includes(GIT_HOOK_MANAGED_MARKER);
+            }
+            catch {
+                canWriteRelay = false;
+            }
+        }
+        if (!canWriteRelay) {
+            continue;
+        }
+        await writeFileSafe(hookPath, managedGitRelayHook(hookName));
+        try {
+            await fs.chmod(hookPath, 0o755);
+        }
+        catch {
+            // best effort on constrained filesystems
+        }
+    }
+}
 async function ensureStructure(projectRoot) {
     for (const dir of REQUIRED_DIRS) {
         await ensureDir(path.join(projectRoot, dir));
@@ -48,6 +193,7 @@ async function writeSkills(projectRoot) {
     // Utility skills (not flow stages)
     await writeFileSafe(runtimePath(projectRoot, "skills", "learnings", "SKILL.md"), learnSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "autoplan", "SKILL.md"), autoplanSkillMarkdown());
+    await writeFileSafe(runtimePath(projectRoot, "skills", "flow-next-step", "SKILL.md"), nextCommandSkillMarkdown());
     await writeFileSafe(runtimePath(projectRoot, "skills", "subagent-dev", "SKILL.md"), subagentDrivenDevSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "parallel-dispatch", "SKILL.md"), parallelAgentsSkill());
     await writeFileSafe(runtimePath(projectRoot, "skills", "session", "SKILL.md"), sessionHooksSkillMarkdown());
@@ -60,6 +206,7 @@ async function writeSkills(projectRoot) {
 async function writeUtilityCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "learn.md"), learnCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "autoplan.md"), autoplanCommandContract());
+    await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -133,11 +280,120 @@ function tryParseHookDocument(raw) {
         return null;
     }
 }
+function opencodeConfigCandidates(projectRoot) {
+    return [
+        path.join(projectRoot, "opencode.json"),
+        path.join(projectRoot, "opencode.jsonc"),
+        path.join(projectRoot, ".opencode", "opencode.json"),
+        path.join(projectRoot, ".opencode", "opencode.jsonc")
+    ];
+}
+function normalizeOpenCodePluginEntry(entry) {
+    if (typeof entry === "string" && entry.trim().length > 0) {
+        return entry.trim();
+    }
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        return null;
+    }
+    const obj = entry;
+    for (const key of ["path", "src", "plugin"]) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function mergeOpenCodePluginConfig(existingDoc, pluginRelPath) {
+    const root = toObject(existingDoc) ?? {};
+    const pluginsRaw = Array.isArray(root.plugin) ? [...root.plugin] : [];
+    const normalized = new Set(pluginsRaw.map((entry) => normalizeOpenCodePluginEntry(entry)).filter(Boolean));
+    if (!normalized.has(pluginRelPath)) {
+        pluginsRaw.push(pluginRelPath);
+    }
+    const changed = !normalized.has(pluginRelPath) || !Array.isArray(root.plugin);
+    return {
+        merged: {
+            ...root,
+            plugin: pluginsRaw
+        },
+        changed
+    };
+}
+async function resolveOpenCodeConfigPath(projectRoot) {
+    for (const candidate of opencodeConfigCandidates(projectRoot)) {
+        if (await exists(candidate)) {
+            return candidate;
+        }
+    }
+    return path.join(projectRoot, "opencode.json");
+}
+async function writeMergedOpenCodePluginConfig(projectRoot, pluginRelPath) {
+    const configPath = await resolveOpenCodeConfigPath(projectRoot);
+    await ensureDir(path.dirname(configPath));
+    let existingDoc = {};
+    if (await exists(configPath)) {
+        try {
+            const raw = await fs.readFile(configPath, "utf8");
+            const parsed = tryParseHookDocument(raw);
+            existingDoc = parsed?.parsed ?? {};
+        }
+        catch {
+            existingDoc = {};
+        }
+    }
+    const { merged, changed } = mergeOpenCodePluginConfig(existingDoc, pluginRelPath);
+    if (changed || !(await exists(configPath))) {
+        await writeFileSafe(configPath, `${JSON.stringify(merged, null, 2)}\n`);
+    }
+}
+async function removeManagedOpenCodePluginConfig(projectRoot, pluginRelPath) {
+    for (const configPath of opencodeConfigCandidates(projectRoot)) {
+        if (!(await exists(configPath)))
+            continue;
+        let parsed = null;
+        try {
+            const raw = await fs.readFile(configPath, "utf8");
+            parsed = tryParseHookDocument(raw)?.parsed ?? null;
+        }
+        catch {
+            parsed = null;
+        }
+        const root = toObject(parsed);
+        if (!root || !Array.isArray(root.plugin))
+            continue;
+        const filtered = root.plugin.filter((entry) => normalizeOpenCodePluginEntry(entry) !== pluginRelPath);
+        if (filtered.length === root.plugin.length) {
+            continue;
+        }
+        root.plugin = filtered;
+        const remainingKeys = Object.keys(root).filter((k) => k !== "plugin" || filtered.length > 0);
+        if (remainingKeys.length === 0 || (remainingKeys.length === 1 && remainingKeys[0] === "plugin" && filtered.length === 0)) {
+            await fs.rm(configPath, { force: true });
+        }
+        else {
+            if (filtered.length === 0) {
+                delete root.plugin;
+            }
+            await writeFileSafe(configPath, `${JSON.stringify(root, null, 2)}\n`);
+        }
+    }
+}
 function backupFileNameForHook(projectRoot, hookFilePath) {
     const rel = path.relative(projectRoot, hookFilePath).replace(/[\\/]/gu, "__");
     const ts = new Date().toISOString().replace(/[:.]/gu, "-");
     return `${rel}.${ts}.bak`;
 }
+function harnessForHookFile(projectRoot, hookFilePath) {
+    const rel = path.relative(projectRoot, hookFilePath).replace(/\\/gu, "/");
+    if (rel === ".claude/hooks/hooks.json")
+        return "claude";
+    if (rel === ".cursor/hooks.json")
+        return "cursor";
+    if (rel === ".codex/hooks.json")
+        return "codex";
+    return null;
+}
 async function pruneOldHookBackups(backupsDir, maxBackups = 20) {
     let entries = [];
     try {
@@ -225,25 +481,50 @@ async function writeMergedHookJson(projectRoot, hookFilePath, generatedJson) {
         }
     }
     const generatedDoc = JSON.parse(generatedJson);
+    const harness = harnessForHookFile(projectRoot, hookFilePath);
+    if (harness) {
+        const generatedSchema = validateHookDocument(harness, generatedDoc);
+        if (!generatedSchema.ok) {
+            throw new Error(`Generated ${harness} hook document failed schema validation: ${generatedSchema.errors.join("; ")}`);
+        }
+    }
     const mergedDoc = mergeHookDocuments(existingDoc, generatedDoc);
+    if (harness) {
+        const mergedSchema = validateHookDocument(harness, mergedDoc);
+        if (!mergedSchema.ok) {
+            throw new Error(`Merged ${harness} hook document failed schema validation: ${mergedSchema.errors.join("; ")}`);
+        }
+    }
     await writeFileSafe(hookFilePath, `${JSON.stringify(mergedDoc, null, 2)}\n`);
 }
-async function writeHooks(projectRoot, harnesses) {
+async function writeHooks(projectRoot, config) {
+    const harnesses = config.harnesses;
     const hooksDir = runtimePath(projectRoot, "hooks");
     await ensureDir(hooksDir);
-    await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript());
+    await writeFileSafe(path.join(hooksDir, "session-start.sh"), sessionStartScript({
+        globalLearningsEnabled: config.globalLearnings === true,
+        globalLearningsPath: config.globalLearningsPath
+    }));
     await writeFileSafe(path.join(hooksDir, "stop-checkpoint.sh"), stopCheckpointScript());
-    await writeFileSafe(path.join(hooksDir, "prompt-guard.sh"), promptGuardScript());
+    await writeFileSafe(path.join(hooksDir, "prompt-guard.sh"), promptGuardScript({
+        strictMode: config.promptGuardMode === "strict"
+    }));
+    await writeFileSafe(path.join(hooksDir, "workflow-guard.sh"), workflowGuardScript());
     await writeFileSafe(path.join(hooksDir, "context-monitor.sh"), contextMonitorScript());
     await writeFileSafe(path.join(hooksDir, "observe.sh"), observeScript());
     await writeFileSafe(path.join(hooksDir, "summarize-observations.sh"), summarizeObservationsScript());
     await writeFileSafe(path.join(hooksDir, "summarize-observations.mjs"), summarizeObservationsRuntimeModule());
-    await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginJs());
+    const opencodePluginSource = opencodePluginJs({
+        globalLearningsEnabled: config.globalLearnings === true,
+        globalLearningsPath: config.globalLearningsPath
+    });
+    await writeFileSafe(path.join(hooksDir, "opencode-plugin.mjs"), opencodePluginSource);
     try {
         for (const script of [
             "session-start.sh",
             "stop-checkpoint.sh",
             "prompt-guard.sh",
+            "workflow-guard.sh",
             "context-monitor.sh",
             "observe.sh",
             "summarize-observations.sh",
@@ -256,6 +537,19 @@ async function writeHooks(projectRoot, harnesses) {
     catch {
         // chmod may fail on some filesystems
     }
+    if (harnesses.includes("opencode")) {
+        const opencodePluginsDir = path.join(projectRoot, ".opencode/plugins");
+        const opencodePluginPath = path.join(projectRoot, OPENCODE_PLUGIN_REL_PATH);
+        await ensureDir(opencodePluginsDir);
+        await writeFileSafe(opencodePluginPath, opencodePluginSource);
+        await writeMergedOpenCodePluginConfig(projectRoot, OPENCODE_PLUGIN_REL_PATH);
+        try {
+            await fs.chmod(opencodePluginPath, 0o755);
+        }
+        catch {
+            // chmod may fail on some filesystems
+        }
+    }
     for (const harness of harnesses) {
         if (harness === "claude") {
             const dir = path.join(projectRoot, ".claude/hooks");
@@ -272,7 +566,7 @@ async function writeHooks(projectRoot, harnesses) {
             await ensureDir(dir);
             await writeMergedHookJson(projectRoot, path.join(dir, "hooks.json"), codexHooksJson());
         }
-        // OpenCode: plugin.mjs is in .cclaw/hooks/ — user registers in opencode.json
+        // OpenCode registration is auto-managed via opencode.json/opencode.jsonc.
     }
 }
 async function ensureLearningsStore(projectRoot) {
@@ -281,6 +575,16 @@ async function ensureLearningsStore(projectRoot) {
         await writeFileSafe(storePath, "");
     }
 }
+async function ensureGlobalLearningsStore(projectRoot, config) {
+    const globalPath = resolveGlobalLearningsPath(projectRoot, config);
+    if (!globalPath) {
+        return;
+    }
+    await ensureDir(path.dirname(globalPath));
+    if (!(await exists(globalPath))) {
+        await writeFileSafe(globalPath, "");
+    }
+}
 async function ensureSessionStateFiles(projectRoot) {
     const stateDir = runtimePath(projectRoot, "state");
     await ensureDir(stateDir);
@@ -312,11 +616,56 @@ async function ensureSessionStateFiles(projectRoot) {
         };
         await writeFileSafe(suggestionMemoryPath, `${JSON.stringify(suggestionMemory, null, 2)}\n`);
     }
+    const contextModePath = path.join(stateDir, "context-mode.json");
+    if (!(await exists(contextModePath))) {
+        await writeFileSafe(contextModePath, `${JSON.stringify(createInitialContextModeState(), null, 2)}\n`);
+    }
 }
 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")) {
+        try {
+            await fs.rm(rulePath, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+        return;
+    }
+    await ensureDir(path.dirname(rulePath));
+    await writeFileSafe(rulePath, CURSOR_WORKFLOW_RULE_MDC);
+}
+async function syncDisabledHarnessArtifacts(projectRoot, harnesses) {
+    const enabled = new Set(harnesses);
+    const managedHookFiles = [
+        { harness: "claude", hookPath: path.join(projectRoot, ".claude/hooks/hooks.json") },
+        { harness: "cursor", hookPath: path.join(projectRoot, ".cursor/hooks.json") },
+        { harness: "codex", hookPath: path.join(projectRoot, ".codex/hooks.json") }
+    ];
+    for (const entry of managedHookFiles) {
+        if (enabled.has(entry.harness))
+            continue;
+        await removeManagedHookEntries(entry.hookPath);
+    }
+    if (!enabled.has("opencode")) {
+        try {
+            await fs.rm(path.join(projectRoot, OPENCODE_PLUGIN_REL_PATH), { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+        await removeManagedOpenCodePluginConfig(projectRoot, OPENCODE_PLUGIN_REL_PATH);
+    }
+}
 async function writeState(projectRoot, forceReset = false) {
     const statePath = runtimePath(projectRoot, "state", "flow-state.json");
     if (!forceReset && (await exists(statePath))) {
@@ -363,9 +712,23 @@ async function cleanLegacyArtifacts(projectRoot) {
     catch {
         // best-effort cleanup
     }
+    for (const legacyPlugin of [
+        path.join(projectRoot, ".opencode/plugins/viby-plugin.mjs"),
+        path.join(projectRoot, ".opencode/plugins/opencode-plugin.mjs"),
+        path.join(projectRoot, OPENCODE_PLUGIN_REL_PATH)
+    ]) {
+        try {
+            await fs.rm(legacyPlugin, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
 }
 async function cleanStaleFiles(projectRoot) {
     const expectedShimFiles = new Set([
+        ...COMMAND_FILE_ORDER.map((stage) => `viby-${stage}.md`),
+        ...UTILITY_COMMANDS.map((cmd) => `viby-${cmd}.md`),
         ...COMMAND_FILE_ORDER.map((stage) => `cc-${stage}.md`),
         ...UTILITY_COMMANDS.map((cmd) => `cc-${cmd}.md`)
     ]);
@@ -391,13 +754,15 @@ async function cleanStaleFiles(projectRoot) {
     // Keep user-owned custom assets under .cclaw/agents and .cclaw/skills.
     // Legacy managed removals happen in cleanLegacyArtifacts() with explicit paths.
 }
-async function materializeRuntime(projectRoot, harnesses, forceStateReset) {
+async function materializeRuntime(projectRoot, config, forceStateReset) {
+    const harnesses = config.harnesses;
     await ensureStructure(projectRoot);
     await cleanLegacyArtifacts(projectRoot);
     await cleanStaleFiles(projectRoot);
     await writeCommandContracts(projectRoot);
     await writeUtilityCommands(projectRoot);
     await writeSkills(projectRoot);
+    await writeContextModes(projectRoot);
     await writeArtifactTemplates(projectRoot);
     await writeRulebook(projectRoot);
     await writeState(projectRoot, forceStateReset);
@@ -405,27 +770,31 @@ async function materializeRuntime(projectRoot, harnesses, forceStateReset) {
     await ensureSessionStateFiles(projectRoot);
     await writeAdapterManifest(projectRoot, harnesses);
     await ensureLearningsStore(projectRoot);
-    await writeHooks(projectRoot, harnesses);
+    await ensureGlobalLearningsStore(projectRoot, config);
+    await writeHooks(projectRoot, config);
+    await syncDisabledHarnessArtifacts(projectRoot, harnesses);
+    await syncManagedGitHooks(projectRoot, config);
     await syncHarnessShims(projectRoot, harnesses);
+    await writeCursorWorkflowRule(projectRoot, harnesses);
     await ensureGitignore(projectRoot);
 }
 export async function initCclaw(options) {
     const config = createDefaultConfig(options.harnesses);
     await writeConfig(options.projectRoot, config);
-    await materializeRuntime(options.projectRoot, config.harnesses, true);
+    await materializeRuntime(options.projectRoot, config, true);
 }
 export async function syncCclaw(projectRoot) {
     const config = await readConfig(projectRoot);
     if (!(await exists(configPath(projectRoot)))) {
         await writeConfig(projectRoot, createDefaultConfig(config.harnesses));
     }
-    await materializeRuntime(projectRoot, config.harnesses, false);
+    await materializeRuntime(projectRoot, config, false);
 }
 export async function upgradeCclaw(projectRoot) {
     const config = await readConfig(projectRoot);
     const upgradedConfig = createDefaultConfig(config.harnesses);
     await writeConfig(projectRoot, upgradedConfig);
-    await materializeRuntime(projectRoot, upgradedConfig.harnesses, false);
+    await materializeRuntime(projectRoot, upgradedConfig, false);
 }
 function stripManagedHookCommands(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -485,7 +854,7 @@ function stripManagedHookCommands(value) {
 }
 function isManagedRuntimeHookCommand(command) {
     const normalized = command.trim().replace(/\s+/gu, " ");
-    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|prompt-guard|context-monitor|observe|summarize-observations)\.sh(?:\s|$)/u.test(normalized);
+    return /(^|\s)(?:bash\s+)?(?:\.\/)?\.cclaw\/hooks\/(?:session-start|stop-checkpoint|prompt-guard|workflow-guard|context-monitor|observe|summarize-observations)\.sh(?:\s|$)/u.test(normalized);
 }
 async function removeManagedHookEntries(hookFilePath) {
     if (!(await exists(hookFilePath)))
@@ -511,7 +880,7 @@ async function removeManagedHookEntries(hookFilePath) {
         !Array.isArray(hooks) &&
         Object.keys(hooks).length > 0;
     if (!hasHooks) {
-        const onlyHooksShell = Object.keys(root).every((key) => key === "hooks" || key === "version");
+        const onlyHooksShell = Object.keys(root).every((key) => key === "hooks" || key === "version" || key === "cclawHookSchemaVersion");
         if (onlyHooksShell) {
             await fs.rm(hookFilePath, { force: true });
             return;
@@ -520,6 +889,17 @@ async function removeManagedHookEntries(hookFilePath) {
     }
     await writeFileSafe(hookFilePath, `${JSON.stringify(root, null, 2)}\n`);
 }
+async function removeIfEmpty(dirPath) {
+    try {
+        const entries = await fs.readdir(dirPath);
+        if (entries.length === 0) {
+            await fs.rmdir(dirPath);
+        }
+    }
+    catch {
+        // directory not present or not removable
+    }
+}
 export async function uninstallCclaw(projectRoot) {
     const fullRuntimePath = path.join(projectRoot, RUNTIME_ROOT);
     try {
@@ -530,7 +910,7 @@ export async function uninstallCclaw(projectRoot) {
     }
     await removeCclawFromAgentsMd(projectRoot);
     await removeGitignorePatterns(projectRoot);
-    // Clean hook files
+    await removeManagedGitHookRelays(projectRoot);
     const hookFiles = [
         ".claude/hooks/hooks.json",
         ".cursor/hooks.json",
@@ -550,7 +930,7 @@ export async function uninstallCclaw(projectRoot) {
         try {
             const entries = await fs.readdir(fullDir);
             for (const entry of entries) {
-                if (/^cc-.*\.md$/u.test(entry)) {
+                if (/^(?:viby|cc)-.*\.md$/u.test(entry)) {
                     await fs.rm(path.join(fullDir, entry), { force: true });
                 }
             }
@@ -559,4 +939,39 @@ export async function uninstallCclaw(projectRoot) {
             // directory not present
         }
     }
+    for (const pluginPath of [
+        path.join(projectRoot, ".opencode/plugins/viby-plugin.mjs"),
+        path.join(projectRoot, ".opencode/plugins/opencode-plugin.mjs"),
+        path.join(projectRoot, OPENCODE_PLUGIN_REL_PATH)
+    ]) {
+        try {
+            await fs.rm(pluginPath, { force: true });
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    await removeManagedOpenCodePluginConfig(projectRoot, OPENCODE_PLUGIN_REL_PATH);
+    try {
+        await fs.rm(path.join(projectRoot, CURSOR_RULE_REL_PATH), { force: true });
+    }
+    catch {
+        // best-effort cleanup
+    }
+    const managedDirs = [
+        ".claude/hooks",
+        ".claude/commands",
+        ".claude",
+        ".cursor/rules",
+        ".cursor/commands",
+        ".cursor",
+        ".codex/commands",
+        ".codex",
+        ".opencode/plugins",
+        ".opencode/commands",
+        ".opencode"
+    ];
+    for (const relDir of managedDirs) {
+        await removeIfEmpty(path.join(projectRoot, relDir));
+    }
 }

package/dist/policy.d.ts

@@ -1,6 +1,10 @@
+import type { HarnessId } from "./types.js";
 export interface PolicyCheck {
     name: string;
     ok: boolean;
     details: string;
 }
-export declare function policyChecks(projectRoot: string): Promise<PolicyCheck[]>;
+export interface PolicyOptions {
+    harnesses?: HarnessId[];
+}
+export declare function policyChecks(projectRoot: string, options?: PolicyOptions): Promise<PolicyCheck[]>;