cclaw-cli 0.51.22 → 0.51.24

package/dist/install.js

@@ -6,6 +6,7 @@ import { CCLAW_VERSION, FLOW_VERSION, REQUIRED_DIRS, RUNTIME_ROOT } from "./cons
 import { writeConfig, createDefaultConfig, readConfig, configPath, detectLanguageRulePacks, detectAdvancedKeys } from "./config.js";
 import { learnSkillMarkdown } from "./content/learnings.js";
 import { nextCommandContract, nextCommandSkillMarkdown } from "./content/next-command.js";
+import { stageCommandShimMarkdown } from "./content/stage-command.js";
 import { ideateCommandContract, ideateCommandSkillMarkdown } from "./content/ideate-command.js";
 import { startCommandContract, startCommandSkillMarkdown } from "./content/start-command.js";
 import { viewCommandContract, viewCommandSkillMarkdown } from "./content/view-command.js";
@@ -190,15 +191,84 @@ function resolveRepoRoot() {
   return process.cwd();
 }
 
+function isZeroSha(value) {
+  return /^0{40,64}$/u.test(value);
+}
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function uniqueLines(chunks) {
+  return [...new Set(chunks
+    .join("\n")
+    .split(/\r?\n/gu)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0))].join("\n");
+}
+
+function diffNames(root, range) {
+  const result = runGit(["diff", "--name-only", range], root);
+  return result.status === 0 ? result.stdout : "";
+}
+
+function changedFilesFromUnpushedCommits(root, localSha = "HEAD") {
+  const revList = runGit(["rev-list", "--reverse", localSha, "--not", "--remotes"], root);
+  if (revList.status !== 0 || revList.stdout.trim().length === 0) {
+    return "";
+  }
+  const chunks = [];
+  for (const commit of revList.stdout.split(/\r?\n/gu).map((line) => line.trim()).filter(Boolean)) {
+    const diffTree = runGit(["diff-tree", "--no-commit-id", "--name-only", "-r", "--root", commit], root);
+    if (diffTree.status === 0) chunks.push(diffTree.stdout);
+  }
+  return uniqueLines(chunks);
+}
+
+function changedFilesFromPrePushStdin(root, stdin) {
+  const chunks = [];
+  for (const rawLine of stdin.split(/\r?\n/gu)) {
+    const parts = rawLine.trim().split(/\s+/u);
+    if (parts.length < 4) continue;
+    const [localRef, localSha, remoteRef, remoteSha] = parts;
+    void localRef;
+    void remoteRef;
+    if (!localSha || isZeroSha(localSha)) continue;
+    if (remoteSha && !isZeroSha(remoteSha)) {
+      chunks.push(diffNames(root, remoteSha + ".." + localSha));
+      continue;
+    }
+    const upstream = runGit(["rev-parse", "--verify", "--quiet", "@{upstream}"], root);
+    if (upstream.status === 0 && upstream.stdout.trim().length > 0) {
+      chunks.push(diffNames(root, upstream.stdout.trim() + ".." + localSha));
+      continue;
+    }
+    chunks.push(changedFilesFromUnpushedCommits(root, localSha));
+  }
+  return uniqueLines(chunks);
+}
+
 function resolveChangedFiles(root) {
   if (HOOK_NAME === "pre-commit") {
     const result = runGit(["diff", "--cached", "--name-only"], root);
     return result.status === 0 ? result.stdout : "";
   }
-  const upstreamResult = runGit(["diff", "--name-only", "@{upstream}...HEAD"], root);
+  const stdinChanged = changedFilesFromPrePushStdin(root, readStdin());
+  if (stdinChanged.length > 0) {
+    return stdinChanged;
+  }
+  const upstreamResult = runGit(["diff", "--name-only", "@{upstream}..HEAD"], root);
   if (upstreamResult.status === 0) {
     return upstreamResult.stdout;
   }
+  const unpushed = changedFilesFromUnpushedCommits(root);
+  if (unpushed.length > 0) {
+    return unpushed;
+  }
   const fallback = runGit(["diff", "--name-only", "HEAD~1...HEAD"], root);
   return fallback.status === 0 ? fallback.stdout : "";
 }
@@ -443,6 +513,9 @@ async function writeEntryCommands(projectRoot) {
     await writeFileSafe(runtimePath(projectRoot, "commands", "next.md"), nextCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "ideate.md"), ideateCommandContract());
     await writeFileSafe(runtimePath(projectRoot, "commands", "view.md"), viewCommandContract());
+    for (const stage of FLOW_STAGES) {
+        await writeFileSafe(runtimePath(projectRoot, "commands", `${stage}.md`), stageCommandShimMarkdown(stage));
+    }
 }
 function toObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -547,11 +620,20 @@ function mergeOpenCodePluginConfig(existingDoc, pluginRelPath) {
     if (!normalized.has(pluginRelPath)) {
         pluginsRaw.push(pluginRelPath);
     }
-    const changed = !normalized.has(pluginRelPath) || !Array.isArray(root.plugin);
+    const permission = toObject(root.permission) ?? {};
+    const permissionChanged = permission.question !== "allow";
+    const changed = !normalized.has(pluginRelPath) ||
+        !Array.isArray(root.plugin) ||
+        permissionChanged ||
+        !toObject(root.permission);
     return {
         merged: {
             ...root,
-            plugin: pluginsRaw
+            plugin: pluginsRaw,
+            permission: {
+                ...permission,
+                question: "allow"
+            }
         },
         changed
     };
@@ -933,7 +1015,6 @@ async function cleanLegacyArtifacts(projectRoot) {
         await removeBestEffort(legacyPlugin);
     }
     for (const legacyRuntimeFile of [
-        ...FLOW_STAGES.map((stage) => runtimePath(projectRoot, "commands", `${stage}.md`)),
         ...DEPRECATED_COMMAND_FILES.map((file) => runtimePath(projectRoot, "commands", file)),
         ...DEPRECATED_SKILL_FILES.map((segments) => runtimePath(projectRoot, "skills", ...segments)),
         ...DEPRECATED_STATE_FILES.map((file) => runtimePath(projectRoot, "state", file)),
@@ -1248,7 +1329,7 @@ export async function uninstallCclaw(projectRoot) {
     try {
         const entries = await fs.readdir(codexSkillsRoot);
         for (const entry of entries) {
-            if (/^(?:cclaw-)?cc(?:-(?:next|view|ops|ideate))?$/u.test(entry)) {
+            if (/^(?:cclaw-)?cc(?:-(?:next|view|ops|ideate|brainstorm|scope|design|spec|plan|tdd|review|ship))?$/u.test(entry)) {
                 await fs.rm(path.join(codexSkillsRoot, entry), { recursive: true, force: true });
             }
         }
@@ -1258,6 +1339,19 @@ export async function uninstallCclaw(projectRoot) {
     }
     await removeIfEmpty(codexSkillsRoot);
     await removeIfEmpty(path.join(projectRoot, ".agents"));
+    const managedAgentNames = [
+        "planner",
+        "product-manager",
+        "critic",
+        "reviewer",
+        "security-reviewer",
+        "test-author",
+        "doc-updater"
+    ];
+    for (const agentName of managedAgentNames) {
+        await removeBestEffort(path.join(projectRoot, ".opencode/agents", `${agentName}.md`));
+        await removeBestEffort(path.join(projectRoot, ".codex/agents", `${agentName}.toml`));
+    }
     for (const pluginPath of [
         path.join(projectRoot, ".opencode/plugins/viby-plugin.mjs"),
         path.join(projectRoot, ".opencode/plugins/opencode-plugin.mjs"),
@@ -1284,8 +1378,10 @@ export async function uninstallCclaw(projectRoot) {
         ".cursor/rules",
         ".cursor/commands",
         ".cursor",
+        ".codex/agents",
         ".codex/commands",
         ".codex",
+        ".opencode/agents",
         ".opencode/plugins",
         ".opencode/commands",
         ".opencode"

package/dist/knowledge-store.js

@@ -505,18 +505,40 @@ export async function appendKnowledge(projectRoot, seeds, defaults = {}) {
         appendedEntries
     };
 }
+const SHORT_TECHNICAL_TOKEN_SET = new Set(["ci", "db", "ui", "qa", "ux"]);
 function tokenizeText(value) {
     if (!value)
         return [];
-    return value
-        .toLowerCase()
-        .split(/[^a-z0-9]+/u)
-        .map((token) => token.trim())
-        .filter((token) => token.length >= 3);
+    const tokens = [];
+    const matches = value.matchAll(/[A-Za-z0-9]+/gu);
+    for (const match of matches) {
+        const raw = match[0] ?? "";
+        const normalized = raw.toLowerCase();
+        if (normalized.length >= 3) {
+            tokens.push(normalized);
+            continue;
+        }
+        if (/^[A-Z]{2}$/u.test(raw) || SHORT_TECHNICAL_TOKEN_SET.has(normalized)) {
+            tokens.push(normalized);
+        }
+    }
+    return tokens;
 }
 function uniqueTokens(values) {
     return [...new Set(values)];
 }
+function supersededTriggerSet(entries) {
+    const superseded = new Set();
+    for (const entry of entries) {
+        for (const trigger of entry.supersedes ?? []) {
+            superseded.add(normalizeText(trigger));
+        }
+    }
+    return superseded;
+}
+function isSupersededLearning(entry, supersededTriggers) {
+    return entry.superseded_by !== undefined || supersededTriggers.has(normalizeText(entry.trigger));
+}
 function pathTokens(paths) {
     if (!Array.isArray(paths) || paths.length === 0)
         return [];
@@ -538,7 +560,9 @@ export async function selectRelevantLearnings(projectRoot, options = {}) {
     const limit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0
         ? Math.floor(options.limit)
         : 8;
-    const ranked = entries.map((entry, index) => {
+    const staleTriggers = supersededTriggerSet(entries);
+    const activeEntries = entries.filter((entry) => !isSupersededLearning(entry, staleTriggers));
+    const ranked = activeEntries.map((entry, index) => {
         let score = 0;
         let stageScore = 0;
         if (stage) {

package/dist/run-archive.js

@@ -35,6 +35,13 @@ function stateDirPath(projectRoot) {
 function archiveLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".archive.lock");
 }
+function compoundCloseoutComplete(state) {
+    return (state.closeout.compoundCompletedAt !== undefined ||
+        state.closeout.compoundPromoted > 0 ||
+        (state.closeout.compoundSkipped === true &&
+            typeof state.closeout.compoundSkipReason === "string" &&
+            state.closeout.compoundSkipReason.trim().length > 0));
+}
 async function snapshotStateDirectory(projectRoot, destinationRoot) {
     const sourceDir = stateDirPath(projectRoot);
     if (!(await exists(sourceDir))) {
@@ -209,6 +216,10 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                 sourceState.closeout.retroSkipReason.trim().length > 0;
             const readyForArchive = sourceState.closeout.shipSubstate === "ready_to_archive";
             const inShipCloseout = sourceState.currentStage === "ship";
+            if (readyForArchive && !compoundCloseoutComplete(sourceState)) {
+                throw new Error("Archive blocked: compound closeout is incomplete. " +
+                    "Promote compound guidance or skip compound review with an explicit reason before archiving.");
+            }
             if (inShipCloseout && skipRetro) {
                 throw new Error("Archive blocked: --skip-retro is not allowed while current stage is ship. " +
                     "Complete closeout to ready_to_archive via /cc-next.");

package/dist/run-persistence.js

@@ -255,21 +255,27 @@ function sanitizeCloseoutState(value) {
         ? true
         : undefined;
     const compoundCompletedAt = typeof typed.compoundCompletedAt === "string" ? typed.compoundCompletedAt : undefined;
-    const compoundSkipped = typeof typed.compoundSkipped === "boolean" ? typed.compoundSkipped : undefined;
+    const compoundSkipReason = typeof typed.compoundSkipReason === "string"
+        ? typed.compoundSkipReason.trim() || undefined
+        : undefined;
+    const compoundSkipped = typed.compoundSkipped === true && compoundSkipReason !== undefined
+        ? true
+        : undefined;
     const promotedRaw = typed.compoundPromoted;
     const compoundPromoted = typeof promotedRaw === "number" && Number.isFinite(promotedRaw) && promotedRaw >= 0
         ? Math.floor(promotedRaw)
         : 0;
-    // Demote shipSubstate when its retro invariant is violated on disk. A
-    // hand-edited flow-state could claim `ready_to_archive` or `compound_review`
-    // without ever going through the retro step, which would let `archive`
-    // proceed and skip the gate. Compound completion is not independently
-    // tracked in all flows (some runs rely on knowledge.jsonl + the retro
-    // window), so we only demote when the retro leg is missing outright.
+    // Demote shipSubstate when its closeout invariants are violated on disk. A
+    // hand-edited flow-state could claim `ready_to_archive` without completing
+    // the compound leg, which would let `archive` skip durable closeout proof.
     const retroDone = retroAcceptedAt !== undefined || retroSkipped === true;
+    const compoundDone = compoundCompletedAt !== undefined || compoundPromoted > 0 || compoundSkipped === true;
     if (!retroDone && (shipSubstate === "ready_to_archive" || shipSubstate === "compound_review")) {
         shipSubstate = "retro_review";
     }
+    else if (shipSubstate === "ready_to_archive" && !compoundDone) {
+        shipSubstate = "compound_review";
+    }
     return {
         shipSubstate,
         retroDraftedAt,
@@ -278,6 +284,7 @@ function sanitizeCloseoutState(value) {
         retroSkipReason,
         compoundCompletedAt,
         compoundSkipped,
+        compoundSkipReason,
         compoundPromoted
     };
 }

package/package.json

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