cclaw-cli 0.48.1 → 0.48.3

package/dist/content/opencode-plugin.js

@@ -2,7 +2,8 @@ import { RUNTIME_ROOT } from "../constants.js";
 import { META_SKILL_NAME } from "./meta-skill.js";
 export function opencodePluginJs(_options = {}) {
     return `// cclaw OpenCode plugin — generated by cclaw sync
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 
 export default function cclawPlugin(ctx) {
@@ -33,9 +34,9 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function readFlowState() {
+  async function readFlowState() {
     try {
-      const raw = readFileSync(flowStatePath, "utf8");
+      const raw = await readFile(flowStatePath, "utf8");
       const state = JSON.parse(raw);
       return {
         stage: typeof state.currentStage === "string" ? state.currentStage : "none",
@@ -47,23 +48,23 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function readFileText(filePath) {
+  async function readFileText(filePath) {
     try {
-      return readFileSync(filePath, "utf8");
+      return await readFile(filePath, "utf8");
     } catch {
       return "";
     }
   }
 
-  function readTailLines(filePath, maxLines) {
-    const text = readFileText(filePath).trim();
+  async function readTailLines(filePath, maxLines) {
+    const text = (await readFileText(filePath)).trim();
     if (!text) return [];
     return text.split(/\\r?\\n/).slice(-maxLines);
   }
 
-  function readCheckpointSummary() {
+  async function readCheckpointSummary() {
     try {
-      const raw = readFileText(checkpointPath);
+      const raw = await readFileText(checkpointPath);
       if (!raw) return "";
       const cp = JSON.parse(raw);
       return \`Checkpoint: stage=\${cp.stage || "none"}, status=\${cp.status || "unknown"}, run=\${cp.runId || "none"}, at=\${cp.timestamp || "unknown"}\`;
@@ -72,10 +73,10 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function readContextMode() {
+  async function readContextMode() {
     let mode = "default";
     try {
-      const parsed = JSON.parse(readFileText(contextModePath));
+      const parsed = JSON.parse(await readFileText(contextModePath));
       if (parsed && typeof parsed.activeMode === "string" && parsed.activeMode.trim().length > 0) {
         mode = parsed.activeMode.trim();
       }
@@ -87,9 +88,9 @@ export default function cclawPlugin(ctx) {
     return { mode, guide };
   }
 
-  function readRecentActivity() {
+  async function readRecentActivity() {
     try {
-      const lines = readTailLines(activityPath, 5);
+      const lines = await readTailLines(activityPath, 5);
       if (lines.length === 0) return [];
       return lines
         .map((line) => {
@@ -106,9 +107,9 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function readLatestContextWarning() {
+  async function readLatestContextWarning() {
     try {
-      const line = readTailLines(contextWarningsPath, 1)[0];
+      const line = (await readTailLines(contextWarningsPath, 1))[0];
       if (!line) return "";
       try {
         const parsed = JSON.parse(line);
@@ -122,8 +123,8 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function readKnowledgeDigest() {
-    const digest = readFileText(knowledgeDigestPath).trim();
+  async function readKnowledgeDigest() {
+    const digest = (await readFileText(knowledgeDigestPath)).trim();
     if (!digest) {
       return readTailLines(knowledgePath, 12);
     }
@@ -134,68 +135,219 @@ export default function cclawPlugin(ctx) {
       .filter((line) => !line.startsWith("#"));
   }
 
-  function buildBootstrap() {
-    const flow = readFlowState();
+  const BOOTSTRAP_MARKER = "<!-- cclaw-bootstrap-v1 -->";
+
+  async function buildBootstrap() {
+    const flow = await readFlowState();
     const parts = [
+      BOOTSTRAP_MARKER,
       \`cclaw loaded. Flow: stage=\${flow.stage} (\${flow.completed}/8 completed, run=\${flow.activeRunId}). Active artifacts: ${RUNTIME_ROOT}/artifacts/\`
     ];
-    const contextMode = readContextMode();
+    const contextMode = await readContextMode();
     parts.push(
       contextMode.guide
         ? \`Context mode: \${contextMode.mode} (guide: \${contextMode.guide})\`
         : \`Context mode: \${contextMode.mode}\`
     );
 
-    const checkpoint = readCheckpointSummary();
+    const checkpoint = await readCheckpointSummary();
     if (checkpoint) parts.push(checkpoint);
 
-    const digest = readFileText(sessionDigestPath).trim();
+    const digest = (await readFileText(sessionDigestPath)).trim();
     if (digest) parts.push("Last session:", digest);
 
-    const activity = readRecentActivity();
+    const activity = await readRecentActivity();
     if (activity.length > 0) parts.push("Recent stage activity:", ...activity);
 
-    const warning = readLatestContextWarning();
+    const warning = await readLatestContextWarning();
     if (warning) parts.push("Latest context warning:", warning);
 
-    const knowledge = readKnowledgeDigest();
+    const knowledge = await readKnowledgeDigest();
     if (knowledge.length > 0) parts.push("Knowledge digest (top relevant entries):", ...knowledge);
 
     parts.push(
       "If you discover a non-obvious rule or pattern, append one strict-schema JSON line to .cclaw/knowledge.jsonl using type: rule, pattern, lesson, or compound."
     );
 
-    const meta = readFileText(metaSkillPath).trim();
+    const meta = (await readFileText(metaSkillPath)).trim();
     if (meta) parts.push("", meta);
     return parts.join("\\n");
   }
 
   let bootstrapCache = "";
+  let bootstrapMtimes = new Map();
+  let bootstrapRefreshPromise = null;
+  const BOOTSTRAP_SOURCE_PATHS = [
+    flowStatePath,
+    checkpointPath,
+    activityPath,
+    contextWarningsPath,
+    contextModePath,
+    sessionDigestPath,
+    knowledgePath,
+    knowledgeDigestPath,
+    metaSkillPath
+  ];
+
+  async function readMtimeMs(filePath) {
+    try {
+      const st = await stat(filePath);
+      return Number.isFinite(st.mtimeMs) ? st.mtimeMs : 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  async function snapshotBootstrapMtimes() {
+    const next = new Map();
+    for (const filePath of BOOTSTRAP_SOURCE_PATHS) {
+      next.set(filePath, await readMtimeMs(filePath));
+    }
+    return next;
+  }
+
+  async function bootstrapNeedsRefresh() {
+    if (!bootstrapCache) return true;
+    for (const filePath of BOOTSTRAP_SOURCE_PATHS) {
+      const prev = bootstrapMtimes.get(filePath) ?? 0;
+      const now = await readMtimeMs(filePath);
+      if (prev !== now) return true;
+    }
+    return false;
+  }
 
-  function refreshBootstrapCache() {
-    bootstrapCache = buildBootstrap();
+  async function refreshBootstrapCache(force = false) {
+    if (!force && !(await bootstrapNeedsRefresh())) {
+      return bootstrapCache;
+    }
+    if (bootstrapRefreshPromise) {
+      return bootstrapRefreshPromise;
+    }
+    bootstrapRefreshPromise = (async () => {
+      const nextBootstrap = await buildBootstrap();
+      const nextMtimes = await snapshotBootstrapMtimes();
+      bootstrapCache = nextBootstrap;
+      bootstrapMtimes = nextMtimes;
+      return bootstrapCache;
+    })();
+    try {
+      return await bootstrapRefreshPromise;
+    } finally {
+      bootstrapRefreshPromise = null;
+    }
   }
 
   function getBootstrap() {
-    if (!bootstrapCache) refreshBootstrapCache();
     return bootstrapCache;
   }
 
+  const MAX_CONCURRENT_HOOKS = 2;
+  let runningHookTasks = 0;
+  const pendingHookTasks = [];
+
+  function runNextHookTask() {
+    if (runningHookTasks >= MAX_CONCURRENT_HOOKS) return;
+    const queued = pendingHookTasks.shift();
+    if (!queued) return;
+    runningHookTasks += 1;
+    queued()
+      .catch(() => false)
+      .finally(() => {
+        runningHookTasks -= 1;
+        runNextHookTask();
+      });
+  }
+
+  function scheduleHookTask(task) {
+    return new Promise((resolve) => {
+      const wrapped = async () => {
+        try {
+          resolve(await task());
+        } catch {
+          resolve(false);
+        }
+      };
+      pendingHookTasks.push(wrapped);
+      runNextHookTask();
+    });
+  }
+
   async function runHookScript(scriptFileName, payload = {}) {
-    const { spawnSync } = await import("node:child_process");
+    const { spawn } = await import("node:child_process");
     const scriptPath = join(root, "${RUNTIME_ROOT}/hooks/" + scriptFileName);
     const input = typeof payload === "string" ? payload : JSON.stringify(payload ?? {});
-    try {
-      const result = spawnSync("bash", [scriptPath], {
-        cwd: root,
-        timeout: 20000,
-        stdio: ["pipe", "ignore", "ignore"],
-        input
+    return scheduleHookTask(() => new Promise((resolve) => {
+      let stderr = "";
+      let settled = false;
+      const finish = (ok) => {
+        if (settled) return;
+        settled = true;
+        resolve(ok);
+      };
+
+      let child;
+      try {
+        child = spawn("bash", [scriptPath], {
+          cwd: root,
+          stdio: ["pipe", "ignore", "pipe"]
+        });
+      } catch {
+        finish(false);
+        return;
+      }
+
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        if (stderr.length > 0) {
+          console.error("[cclaw] opencode hook timeout: " + scriptFileName + " stderr=" + stderr.slice(-1200));
+        }
+        finish(false);
+      }, 20_000);
+
+      child.stderr?.on("data", (chunk) => {
+        stderr += String(chunk ?? "");
+        if (stderr.length > 4000) {
+          stderr = stderr.slice(-4000);
+        }
       });
-      return typeof result.status === "number" ? result.status === 0 : false;
-    } catch {
-      return false;
-    }
+      child.on("error", () => {
+        clearTimeout(timer);
+        finish(false);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const ok = code === 0;
+        if (!ok && stderr.length > 0) {
+          console.error("[cclaw] opencode hook failed: " + scriptFileName + " stderr=" + stderr.slice(-1200));
+        }
+        finish(ok);
+      });
+      if (child.stdin) {
+        child.stdin.on("error", (error) => {
+          const code =
+            error && typeof error === "object" && "code" in error
+              ? String(error.code)
+              : "";
+          if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+            return;
+          }
+          clearTimeout(timer);
+          finish(false);
+        });
+        try {
+          child.stdin.end(input);
+        } catch (error) {
+          const code =
+            error && typeof error === "object" && "code" in error
+              ? String(error.code)
+              : "";
+          if (code !== "EPIPE" && code !== "ERR_STREAM_DESTROYED") {
+            clearTimeout(timer);
+            finish(false);
+          }
+        }
+      }
+    }));
   }
 
   function normalizeToolPayload(input, output) {
@@ -207,9 +359,15 @@ export default function cclawPlugin(ctx) {
     if (typeof payload === "string") return payload;
     if (payload && typeof payload === "object") {
       if (typeof payload.type === "string") return payload.type;
+      if (typeof payload.eventType === "string") return payload.eventType;
+      if (typeof payload.kind === "string") return payload.kind;
+      if (typeof payload.topic === "string") return payload.topic;
       if (typeof payload.name === "string") return payload.name;
       if (payload.event && typeof payload.event === "object") {
         if (typeof payload.event.type === "string") return payload.event.type;
+        if (typeof payload.event.eventType === "string") return payload.event.eventType;
+        if (typeof payload.event.kind === "string") return payload.event.kind;
+        if (typeof payload.event.topic === "string") return payload.event.topic;
         if (typeof payload.event.name === "string") return payload.event.name;
       }
     }
@@ -217,18 +375,40 @@ export default function cclawPlugin(ctx) {
   }
 
   function resolveEventData(payload) {
-    if (payload && typeof payload === "object" && payload.event && typeof payload.event === "object") {
-      return payload.event;
+    if (payload && typeof payload === "object") {
+      if (payload.event && typeof payload.event === "object") {
+        if (payload.event.data && typeof payload.event.data === "object") {
+          return payload.event.data;
+        }
+        if (payload.event.payload && typeof payload.event.payload === "object") {
+          return payload.event.payload;
+        }
+        return payload.event;
+      }
+      if (payload.data && typeof payload.data === "object") {
+        return payload.data;
+      }
+      if (payload.payload && typeof payload.payload === "object") {
+        return payload.payload;
+      }
     }
     return payload;
   }
 
   ensureRuntimeDirs();
+  void refreshBootstrapCache(true);
 
   return {
     event: async (payload) => {
       const eventType = resolveEventType(payload);
       const eventData = resolveEventData(payload);
+      if (!eventType) {
+        const keys =
+          payload && typeof payload === "object"
+            ? Object.keys(payload).slice(0, 10).join(", ")
+            : typeof payload;
+        console.error("[cclaw] opencode unknown event payload keys: " + keys);
+      }
       if (
         eventType === "session.created" ||
         eventType === "session.resumed" ||
@@ -242,7 +422,7 @@ export default function cclawPlugin(ctx) {
         // session.updated covers config reloads and artifact/rules edits
         // that happen mid-session; without it the cache would stay stale
         // until the next compaction or restart.
-        refreshBootstrapCache();
+        await refreshBootstrapCache(true);
       }
       if (eventType === "session.compacted") {
         await runHookScript("pre-compact.sh", eventData ?? {});
@@ -264,14 +444,16 @@ export default function cclawPlugin(ctx) {
     "tool.execute.after": async (input, output) => {
       const payload = normalizeToolPayload(input, output);
       await runHookScript("context-monitor.sh", payload);
+      void refreshBootstrapCache(false);
     },
     "experimental.chat.system.transform": (payload) => {
       const bootstrap = getBootstrap();
+      if (!bootstrap) return payload;
       if (typeof payload === "string") {
-        return payload.includes("cclaw loaded.") ? payload : \`\${payload}\\n\\n\${bootstrap}\`;
+        return payload.includes(BOOTSTRAP_MARKER) ? payload : \`\${payload}\\n\\n\${bootstrap}\`;
       }
       if (payload && typeof payload === "object" && typeof payload.system === "string") {
-        if (payload.system.includes("cclaw loaded.")) return payload;
+        if (payload.system.includes(BOOTSTRAP_MARKER)) return payload;
         return { ...payload, system: \`\${payload.system}\\n\\n\${bootstrap}\` };
       }
       return payload;

package/dist/content/stage-schema.js

@@ -198,7 +198,7 @@ const STAGE_AUTO_SUBAGENT_DISPATCH = {
         {
             agent: "doc-updater",
             mode: "proactive",
-            when: "When public behavior, APIs, or config surfaces change.",
+            when: "Proactive in tdd when public behavior, APIs, or config surfaces change.",
             purpose: "Prevent code/docs drift before review and ship.",
             requiresUserGate: false
         }

package/dist/content/stages/ship.js

@@ -1,3 +1,4 @@
+import { SHIP_FINALIZATION_MODES } from "../../constants.js";
 // ---------------------------------------------------------------------------
 // SHIP — reference: superpowers finishing-a-development-branch + gstack /ship
 // ---------------------------------------------------------------------------
@@ -93,11 +94,7 @@ export const SHIP = {
         "Pre-Ship Checks",
         "Release Notes",
         "Rollback Plan",
-        "FINALIZE_MERGE_LOCAL",
-        "FINALIZE_OPEN_PR",
-        "FINALIZE_KEEP_BRANCH",
-        "FINALIZE_DISCARD_BRANCH",
-        "FINALIZE_NO_VCS"
+        ...SHIP_FINALIZATION_MODES
     ],
     artifactFile: "08-ship.md",
     // `done` exits the stage pipeline. Archive semantics are handled by the

package/dist/content/templates.js

@@ -1,6 +1,7 @@
-import { CCLAW_VERSION } from "../constants.js";
+import { CCLAW_VERSION, SHIP_FINALIZATION_MODES } from "../constants.js";
 import { orderedStageSchemas } from "./stage-schema.js";
 import { FLOW_STAGES } from "../types.js";
+const SHIP_FINALIZATION_ENUM_LINES = SHIP_FINALIZATION_MODES.map((mode) => `  - ${mode}`).join("\n");
 export const ARTIFACT_TEMPLATES = {
     "01-brainstorm.md": `---
 stage: brainstorm
@@ -645,11 +646,7 @@ inputs_hash: sha256:pending
 
 ## Finalization
 - Selected enum (exactly one):
-  - FINALIZE_MERGE_LOCAL
-  - FINALIZE_OPEN_PR
-  - FINALIZE_KEEP_BRANCH
-  - FINALIZE_DISCARD_BRANCH
-  - FINALIZE_NO_VCS
+${SHIP_FINALIZATION_ENUM_LINES}
 - Selected label (A/B/C/D/E):
 - Execution result:
 - PR URL / merge commit / kept branch / discard confirmation:

package/dist/delegation.d.ts

@@ -53,6 +53,8 @@ export type DelegationEntry = {
     retryCount?: number;
     /** Optional references to evidence anchors in artifacts. */
     evidenceRefs?: string[];
+    /** Optional skill marker used for role-specific mandatory checks. */
+    skill?: string;
     /**
      * Fulfillment mode this entry was executed under. Omitted on legacy rows
      * (treated as `"isolated"` for Claude, otherwise inferred from the active
@@ -85,7 +87,9 @@ export declare function appendDelegation(projectRoot: string, entry: DelegationE
  * strongest guarantee.
  */
 export declare function expectedFulfillmentMode(fallbacks: SubagentFallback[]): DelegationFulfillmentMode;
-export declare function checkMandatoryDelegations(projectRoot: string, stage: FlowStage): Promise<{
+export declare function checkMandatoryDelegations(projectRoot: string, stage: FlowStage, options?: {
+    repairFeatureSystem?: boolean;
+}): Promise<{
     satisfied: boolean;
     missing: string[];
     waived: string[];

package/dist/delegation.js

@@ -154,6 +154,7 @@ function isDelegationEntry(value) {
         (o.tokens === undefined || isDelegationTokenUsage(o.tokens)) &&
         retryOk &&
         (o.evidenceRefs === undefined || (Array.isArray(o.evidenceRefs) && o.evidenceRefs.every((item) => typeof item === "string"))) &&
+        (o.skill === undefined || typeof o.skill === "string") &&
         (o.schemaVersion === undefined || o.schemaVersion === 1));
 }
 function parseLedger(raw, runId) {
@@ -237,7 +238,7 @@ export async function appendDelegation(projectRoot, entry) {
             runId: activeRunId,
             entries: [...prior.entries, stamped]
         };
-        await writeFileSafe(filePath, `${JSON.stringify(ledger, null, 2)}\n`);
+        await writeFileSafe(filePath, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 });
     });
 }
 /**
@@ -257,9 +258,11 @@ export function expectedFulfillmentMode(fallbacks) {
         return "role-switch";
     return "harness-waiver";
 }
-export async function checkMandatoryDelegations(projectRoot, stage) {
+export async function checkMandatoryDelegations(projectRoot, stage, options = {}) {
     const mandatory = stageSchema(stage).mandatoryDelegations;
-    const { activeRunId } = await readFlowState(projectRoot);
+    const { activeRunId } = await readFlowState(projectRoot, {
+        repairFeatureSystem: options.repairFeatureSystem
+    });
     const ledger = await readDelegationLedger(projectRoot);
     const forStage = ledger.entries.filter((e) => e.stage === stage);
     const forRun = forStage.filter((e) => e.runId === activeRunId);
@@ -279,14 +282,15 @@ export async function checkMandatoryDelegations(projectRoot, stage) {
         const rows = forRun.filter((e) => e.agent === agent);
         const completedRows = rows.filter((e) => e.status === "completed");
         const waivedRows = rows.filter((e) => e.status === "waived");
-        const requiredCompletedCount = stage === "review" &&
+        const adversarialReviewerRequired = stage === "review" &&
             agent === "reviewer" &&
-            reviewTriggers?.requireAdversarialReviewer
-            ? 2
-            : 1;
+            reviewTriggers?.requireAdversarialReviewer === true;
+        const requiredCompletedCount = adversarialReviewerRequired ? 2 : 1;
         const hasCompleted = completedRows.length >= requiredCompletedCount;
         const hasWaived = waivedRows.length > 0;
-        const ok = hasCompleted || hasWaived;
+        const hasAdversarialSkill = !adversarialReviewerRequired ||
+            completedRows.some((row) => row.skill === "adversarial-review");
+        const ok = hasWaived || (hasCompleted && hasAdversarialSkill);
         if (!ok) {
             missing.push(agent);
             continue;