cclaw-cli 0.49.0 → 0.51.1

package/dist/content/node-hooks.js

@@ -290,12 +290,6 @@ async function appendJsonLine(filePath, value) {
   });
 }
 
-async function writeTextFileAtomic(filePath, content) {
-  await withDirectoryLockInline(lockPathFor(filePath), async () => {
-    await writeFileAtomic(filePath, content);
-  });
-}
-
 async function readStdin() {
   return await new Promise((resolve) => {
     let data = "";
@@ -400,7 +394,7 @@ function hookEventNameForOutput(hookName) {
   if (hookName === "prompt-guard") return "PreToolUse";
   if (hookName === "workflow-guard") return "PreToolUse";
   if (hookName === "context-monitor") return "PostToolUse";
-  if (hookName === "stop-checkpoint") return "Stop";
+  if (hookName === "stop-handoff") return "Stop";
   if (hookName === "pre-compact") return "PreCompact";
   if (hookName === "verify-current-state") return "UserPromptSubmit";
   return "SessionStart";
@@ -811,33 +805,9 @@ async function readFlowState(root) {
   };
 }
 
-function formatCheckpointSummary(checkpointObj) {
-  const stage = typeof checkpointObj.stage === "string" ? checkpointObj.stage : "none";
-  const status = typeof checkpointObj.status === "string" ? checkpointObj.status : "unknown";
-  const runId = typeof checkpointObj.runId === "string" ? checkpointObj.runId : "none";
-  const timestamp = typeof checkpointObj.timestamp === "string" ? checkpointObj.timestamp : "unknown";
-  return "Checkpoint: stage=" + stage + ", status=" + status + ", run=" + runId + ", at=" + timestamp;
-}
-
-function stageSuggestion(stage) {
-  const map = {
-    brainstorm:
-      "Suggestion: list 2-3 alternatives and ask a single focused clarifying question before direction lock.",
-    scope: "Suggestion: lock explicit in-scope/out-of-scope boundaries and choose one scope mode.",
-    design:
-      "Suggestion: map failure modes per new codepath and confirm architecture boundaries before moving forward.",
-    spec: "Suggestion: ensure every acceptance criterion is measurable and mapped to a concrete test.",
-    plan: "Suggestion: group tasks into dependency batches and keep WAIT_FOR_CONFIRM pending until approval.",
-    tdd: "Suggestion: execute RED -> GREEN -> REFACTOR for each selected slice and capture evidence per cycle.",
-    review: "Suggestion: run Layer 1 before Layer 2 and reconcile findings into 07-review-army.json.",
-    ship: "Suggestion: verify preflight + rollback plan before selecting exactly one finalization mode."
-  };
-  return map[stage] || "";
-}
 
 async function buildKnowledgeDigest(root, currentStage, prereadRaw) {
   const knowledgeFile = path.join(root, RUNTIME_ROOT, "knowledge.jsonl");
-  const digestFile = path.join(root, RUNTIME_ROOT, "state", "knowledge-digest.md");
   // Caller may supply pre-read raw bytes to avoid re-reading knowledge.jsonl.
   // Falls back to a local read if nothing is passed in.
   const raw = typeof prereadRaw === "string"
@@ -873,105 +843,19 @@ async function buildKnowledgeDigest(root, currentStage, prereadRaw) {
     });
   const body =
     relevant.length > 0 ? relevant.join("\\n") : "(no matching entries for current stage)";
-  await writeTextFileAtomic(
-    digestFile,
-    "# Knowledge digest (auto-generated)\\n\\n" + body + "\\n"
-  );
   return {
     digestLines: relevant,
     learningsCount
   };
 }
 
-async function readRecentActivityLines(activityFile) {
-  const raw = await readTextFile(activityFile, "");
-  const lines = raw.split(/\\r?\\n/gu).map((line) => line.trim()).filter((line) => line.length > 0);
-  const tail = lines.slice(-5);
-  const out = [];
-  for (const line of tail) {
-    try {
-      const parsed = JSON.parse(line);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-      out.push(
-        "- " +
-          (typeof parsed.ts === "string" ? parsed.ts : "unknown") +
-          " [" +
-          (typeof parsed.phase === "string" ? parsed.phase : "unknown") +
-          "] " +
-          (typeof parsed.tool === "string" ? parsed.tool : "unknown") +
-          " (stage=" +
-          (typeof parsed.stage === "string" ? parsed.stage : "unknown") +
-          ", run=" +
-          (typeof parsed.runId === "string" ? parsed.runId : "none") +
-          ")"
-      );
-    } catch {
-      // ignore malformed activity lines
-    }
-  }
-  return out;
-}
-
-async function readLatestContextWarningLine(filePath) {
-  const raw = await readTextFile(filePath, "");
-  const lines = raw.split(/\\r?\\n/gu).map((line) => line.trim()).filter((line) => line.length > 0);
-  const line = lines[lines.length - 1] || "";
-  if (line.length === 0) return "";
-  try {
-    const parsed = JSON.parse(line);
-    if (parsed && typeof parsed === "object" && typeof parsed.note === "string") {
-      return parsed.note;
-    }
-  } catch {
-    // fallback
-  }
-  return line;
-}
-
 async function handleSessionStart(runtime) {
   const state = await readFlowState(runtime.root);
   const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
-  const contextsDir = path.join(runtime.root, RUNTIME_ROOT, "contexts");
-  const activeFeatureFile = path.join(stateDir, "active-feature.json");
-  const checkpointFile = path.join(stateDir, "checkpoint.json");
-  const activityFile = path.join(stateDir, "stage-activity.jsonl");
-  const contextWarningsFile = path.join(stateDir, "context-warnings.jsonl");
-  const contextModeFile = path.join(stateDir, "context-mode.json");
-  const suggestionMemoryFile = path.join(stateDir, "suggestion-memory.json");
   const ironLawsFile = path.join(stateDir, "iron-laws.json");
-  const sessionDigestFile = path.join(stateDir, "session-digest.md");
   const metaSkillFile = path.join(runtime.root, RUNTIME_ROOT, "skills", "using-cclaw", "SKILL.md");
 
-  const activeFeatureObj = toObject(await readJsonFile(activeFeatureFile, {})) || {};
-  const activeFeature =
-    typeof activeFeatureObj.activeFeature === "string" && activeFeatureObj.activeFeature.length > 0
-      ? activeFeatureObj.activeFeature
-      : "default";
-
-  const contextModeObj = toObject(await readJsonFile(contextModeFile, {})) || {};
-  const activeContextMode =
-    typeof contextModeObj.activeMode === "string" && contextModeObj.activeMode.length > 0
-      ? contextModeObj.activeMode
-      : "default";
-  const contextGuidePath = path.join(contextsDir, activeContextMode + ".md");
-  const contextModeNote = (await fileExists(contextGuidePath))
-    ? "Context mode: " +
-      activeContextMode +
-      " (guide: " +
-      RUNTIME_ROOT +
-      "/contexts/" +
-      activeContextMode +
-      ".md)"
-    : "Context mode: " + activeContextMode;
-
-  const checkpointObj = toObject(await readJsonFile(checkpointFile, {})) || {};
-  const checkpointSummary = Object.keys(checkpointObj).length > 0
-    ? formatCheckpointSummary(checkpointObj)
-    : "";
-
-  const sessionDigest = (await readTextFile(sessionDigestFile, "")).trim();
-  const activitySummary = await readRecentActivityLines(activityFile);
-  const contextWarning = await readLatestContextWarningLine(contextWarningsFile);
+
   // Read knowledge.jsonl exactly once per session-start while holding the
   // SAME lock CLI writers acquire in \`appendKnowledge\`. Guarantees we never
   // see a partial (mid-write) snapshot. Both the digest and
@@ -1041,32 +925,8 @@ async function handleSessionStart(runtime) {
       });
       await writeJsonFile(path.join(stateDir, "compound-readiness.json"), readiness);
     }
-    const readinessObj = toObject(readiness) || {};
-    const ready = Array.isArray(readinessObj.ready) ? readinessObj.ready : [];
-    const readyCount =
-      typeof readinessObj.readyCount === "number" && Number.isFinite(readinessObj.readyCount)
-        ? Math.trunc(readinessObj.readyCount)
-        : ready.length;
-    const clusterCount =
-      typeof readinessObj.clusterCount === "number" && Number.isFinite(readinessObj.clusterCount)
-        ? Math.trunc(readinessObj.clusterCount)
-        : 0;
-    const threshold =
-      typeof readinessObj.threshold === "number" && Number.isFinite(readinessObj.threshold)
-        ? Math.trunc(readinessObj.threshold)
-        : COMPOUND_RECURRENCE_THRESHOLD;
     if (state.currentStage === "review" || state.currentStage === "ship") {
-      if (readyCount === 0) {
-        compoundReadinessLine = "Compound readiness: no candidates (clusters=" +
-          String(clusterCount) + ", threshold=" + String(threshold) + ")";
-      } else {
-        const critical = ready.filter(
-          (entry) => entry && typeof entry === "object" && entry.severity === "critical"
-        ).length;
-        const criticalSuffix = critical > 0 ? " (critical=" + String(critical) + ")" : "";
-        compoundReadinessLine = "Compound readiness: clusters=" + String(clusterCount) +
-          ", ready=" + String(readyCount) + criticalSuffix;
-      }
+      compoundReadinessLine = formatCompoundReadinessLineInline(toObject(readiness) || {});
     }
   } catch (err) {
     // Best-effort — a malformed knowledge.jsonl must never break
@@ -1080,26 +940,6 @@ async function handleSessionStart(runtime) {
     );
   }
 
-  const suggestionMemory = toObject(await readJsonFile(suggestionMemoryFile, {})) || {};
-  const suggestionsEnabled = suggestionMemory.enabled !== false;
-  const mutedStages = Array.isArray(suggestionMemory.mutedStages)
-    ? suggestionMemory.mutedStages.filter((value) => typeof value === "string")
-    : [];
-  const stageMuted = mutedStages.includes(state.currentStage);
-  let stageHint = "";
-  if (suggestionsEnabled && !stageMuted) {
-    stageHint = stageSuggestion(state.currentStage);
-    if (stageHint.length > 0) {
-      const nextSuggestionMemory = {
-        enabled: suggestionsEnabled,
-        mutedStages,
-        lastSuggestedStage: state.currentStage,
-        lastSuggestedAt: new Date().toISOString()
-      };
-      await writeJsonFile(suggestionMemoryFile, nextSuggestionMemory);
-    }
-  }
-
   const ironLawsObj = toObject(await readJsonFile(ironLawsFile, {})) || {};
   const laws = Array.isArray(ironLawsObj.laws) ? ironLawsObj.laws : [];
   const ironLawLines = laws
@@ -1122,50 +962,23 @@ async function handleSessionStart(runtime) {
       String(state.completedCount) +
       "/8 completed, run=" +
       state.activeRunId +
-      ", feature=" +
-      activeFeature +
       "). Active artifacts: " +
       RUNTIME_ROOT +
-      "/artifacts/. Feature registry: " +
-      RUNTIME_ROOT +
-      "/state/worktrees.json (managed roots: " +
-      RUNTIME_ROOT +
-      "/worktrees/). Learnings: " +
+      "/artifacts/. Learnings: " +
       String(knowledge.learningsCount) +
       " entries."
   ];
-  parts.push(contextModeNote);
-  if (checkpointSummary.length > 0) {
-    parts.push(checkpointSummary);
-  }
-  if (sessionDigest.length > 0) {
-    parts.push("Last session:\\n" + sessionDigest);
-  }
-  if (activitySummary.length > 0) {
-    parts.push("Recent stage activity:\\n" + activitySummary.join("\\n"));
-  }
   if (ralphLoopLine.length > 0) {
     parts.push(ralphLoopLine);
   }
   if (compoundReadinessLine.length > 0) {
     parts.push(compoundReadinessLine);
   }
-  if (contextWarning.length > 0) {
-    parts.push("Latest context warning:\\n" + contextWarning);
-  }
-  if (stageHint.length > 0) {
-    parts.push(
-      stageHint +
-        "\\nTo disable suggestions persistently set " +
-        RUNTIME_ROOT +
-        "/state/suggestion-memory.json -> enabled=false."
-    );
-  }
   if (staleStageNames.length > 0) {
     parts.push(
       "Stale stages pending acknowledgement: " +
         staleStageNames.join(", ") +
-        " (use /cc-ops rewind --ack <stage> after redo)."
+        " (use cclaw internal rewind --ack <stage> after redo)."
     );
   }
   if (knowledge.digestLines.length > 0) {
@@ -1222,15 +1035,14 @@ function stopLawIsStrict(ironLawsObj) {
     (row) =>
       row &&
       typeof row === "object" &&
-      row.id === "stop-clean-or-checkpointed" &&
+      (row.id === "stop-clean-or-handoff" || row.id === "stop-clean-or-checkpointed") &&
       row.strict === true
   );
 }
 
-async function handleStopCheckpoint(runtime) {
+async function handleStopHandoff(runtime) {
   const state = await readFlowState(runtime.root);
   const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
-  const checkpointFile = path.join(stateDir, "checkpoint.json");
   const ironLawsFile = path.join(stateDir, "iron-laws.json");
   const input = toObject(runtime.inputData) || {};
   const loopCount =
@@ -1238,31 +1050,11 @@ async function handleStopCheckpoint(runtime) {
       ? Math.trunc(input.loop_count)
       : 0;
 
-  const existing = toObject(await readJsonFile(checkpointFile, {})) || {};
-  const timestamp = new Date().toISOString();
   const dirtyState = await isGitDirty(runtime.root);
-  const nextCheckpoint = {
-    ...existing,
-    stage: state.currentStage,
-    runId: state.activeRunId,
-    status:
-      typeof existing.status === "string" && existing.status.trim().length > 0
-        ? existing.status
-        : "in_progress",
-    dirtyState,
-    lastCompletedStep:
-      typeof existing.lastCompletedStep === "string" ? existing.lastCompletedStep : "",
-    remainingSteps: Array.isArray(existing.remainingSteps) ? existing.remainingSteps : [],
-    blockers: Array.isArray(existing.blockers) ? existing.blockers : [],
-    harness: runtime.harness,
-    timestamp
-  };
-  await writeJsonFile(checkpointFile, nextCheckpoint);
-
   const strictStop = stopLawIsStrict(toObject(await readJsonFile(ironLawsFile, {})) || {});
   if (dirtyState === "dirty" && strictStop) {
     process.stderr.write(
-      '[cclaw] Stop blocked by iron law "stop-clean-or-checkpointed": working tree is dirty. Commit/revert changes or update checkpoint blockers before ending the session.\\n'
+      '[cclaw] Stop blocked by iron law "stop-clean-or-handoff": working tree is dirty. Commit/revert changes or record blockers in the current artifact before ending the session.\\n'
     );
     return 1;
   }
@@ -1272,13 +1064,9 @@ async function handleStopCheckpoint(runtime) {
     state.currentStage +
     ", run=" +
     state.activeRunId +
-    "). Checkpoint updated at " +
-    RUNTIME_ROOT +
-    "/state/checkpoint.json. Run metadata sync removed; active artifacts stay in " +
+    "). Active artifacts stay in " +
     RUNTIME_ROOT +
-    "/artifacts until /cc-ops archive (or cclaw archive runtime). Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match current feature intent, (3) if you discovered a non-obvious rule/pattern, append one strict-schema JSON line to " +
-    RUNTIME_ROOT +
-    "/knowledge.jsonl, (4) commit or revert pending changes.";
+    "/artifacts until archive. Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match current intent, (3) if you discovered a non-obvious rule/pattern during stage work, add it to the current artifact ## Learnings section so stage-complete can harvest it, (4) commit or revert pending changes.";
 
   if (runtime.harness === "cursor") {
     if (loopCount === 0) {
@@ -1293,116 +1081,7 @@ async function handleStopCheckpoint(runtime) {
   return 0;
 }
 
-async function handlePreCompact(runtime) {
-  const state = await readFlowState(runtime.root);
-  const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
-  const flow = state.raw;
-  const stage = state.currentStage;
-  const track = typeof flow.track === "string" ? flow.track : "standard";
-  const skipped = Array.isArray(flow.skippedStages)
-    ? flow.skippedStages.filter((value) => typeof value === "string").join(",")
-    : "";
-
-  const stageGateCatalog = toObject(flow.stageGateCatalog) || {};
-  const stageGate = toObject(stageGateCatalog[stage]) || {};
-  const passed = Array.isArray(stageGate.passed)
-    ? stageGate.passed.filter((value) => typeof value === "string").join(",")
-    : "";
-  const blocked = Array.isArray(stageGate.blocked)
-    ? stageGate.blocked.filter((value) => typeof value === "string").join(",")
-    : "";
-
-  let delegationPending = "";
-  const delegationLog = await readJsonFile(path.join(stateDir, "delegation-log.json"), {});
-  const delegationObj = toObject(delegationLog) || {};
-  const entries = Array.isArray(delegationObj.entries) ? delegationObj.entries : [];
-  const pendingAgents = entries
-    .filter((row) => row && typeof row === "object")
-    .filter(
-      (row) =>
-        row.stage === stage &&
-        row.status !== "completed" &&
-        row.status !== "waived" &&
-        typeof row.agent === "string"
-    )
-    .map((row) => row.agent);
-  if (pendingAgents.length > 0) {
-    delegationPending = [...new Set(pendingAgents)].join(",");
-  }
-
-  const knowledgeRaw = await readTextFile(path.join(runtime.root, RUNTIME_ROOT, "knowledge.jsonl"), "");
-  const knowledgeTail = knowledgeRaw
-    .split(/\\r?\\n/gu)
-    .filter((line) => line.trim().length > 0)
-    .slice(-12)
-    .join("\\n");
-
-  let gitBranch = "unknown";
-  let gitHead = "unknown";
-  let gitDirty = "unknown";
-  await new Promise((resolve) => {
-    const child = spawn("git", ["-C", runtime.root, "rev-parse", "--abbrev-ref", "HEAD"], {
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    let output = "";
-    child.stdout.on("data", (chunk) => {
-      output += String(chunk);
-    });
-    child.on("close", (code) => {
-      if (code === 0 && output.trim().length > 0) {
-        gitBranch = output.trim();
-      }
-      resolve(undefined);
-    });
-    child.on("error", () => resolve(undefined));
-  });
-  await new Promise((resolve) => {
-    const child = spawn("git", ["-C", runtime.root, "rev-parse", "--short", "HEAD"], {
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    let output = "";
-    child.stdout.on("data", (chunk) => {
-      output += String(chunk);
-    });
-    child.on("close", (code) => {
-      if (code === 0 && output.trim().length > 0) {
-        gitHead = output.trim();
-      }
-      resolve(undefined);
-    });
-    child.on("error", () => resolve(undefined));
-  });
-  gitDirty = await isGitDirty(runtime.root);
-
-  const timestamp = new Date().toISOString();
-  const digest = [
-    "# Session Digest",
-    "_Generated by pre-compact hook at " + timestamp + "_",
-    "",
-    "## Flow snapshot",
-    "- track: " + track,
-    "- current stage: " + stage,
-    "- completed: " + String(state.completedCount) + " stages",
-    "- skipped: " + (skipped.length > 0 ? skipped : "(none)"),
-    "- run: " + state.activeRunId,
-    "",
-    "## Gates (current stage)",
-    "- passed: " + (passed.length > 0 ? passed : "(none)"),
-    "- blocked: " + (blocked.length > 0 ? blocked : "(none)"),
-    "",
-    "## Outstanding delegations",
-    "- pending: " + (delegationPending.length > 0 ? delegationPending : "(none)"),
-    "",
-    "## Git",
-    "- branch: " + gitBranch,
-    "- head: " + gitHead,
-    "- worktree: " + gitDirty
-  ];
-  if (knowledgeTail.length > 0) {
-    digest.push("", "## Knowledge tail", knowledgeTail);
-  }
-  const digestFile = path.join(stateDir, "session-digest.md");
-  await writeTextFileAtomic(digestFile, digest.join("\\n") + "\\n");
+async function handlePreCompact(_runtime) {
   return 0;
 }
 
@@ -1781,7 +1460,6 @@ async function handleWorkflowGuard(runtime) {
 async function handleContextMonitor(runtime) {
   const stateDir = path.join(runtime.root, RUNTIME_ROOT, "state");
   const monitorStateFile = path.join(stateDir, "context-monitor.json");
-  const warningsFile = path.join(stateDir, "context-warnings.jsonl");
   const autoEvidenceFile = path.join(stateDir, "tdd-red-evidence.jsonl");
   const flowState = await readFlowState(runtime.root);
 
@@ -1862,14 +1540,7 @@ async function handleContextMonitor(runtime) {
       String(remainingPercent.toFixed(2)) +
       "% (" +
       band +
-      "). Consider checkpointing or compacting soon.";
-    await appendJsonLine(warningsFile, {
-      ts: now.toISOString(),
-      harness: runtime.harness,
-      band,
-      remainingPercent,
-      note
-    });
+      "). Consider leaving a handoff note or compacting soon.";
     emitAdvisoryContext(runtime, "context-monitor", note);
     process.stderr.write("[cclaw] " + note + "\\n");
     nextAdvisoryBand = band;
@@ -1920,7 +1591,8 @@ async function handleVerifyCurrentState(runtime) {
 function normalizeHookName(rawName) {
   const value = normalizeText(rawName).toLowerCase();
   if (value === "session-start") return "session-start";
-  if (value === "stop-checkpoint") return "stop-checkpoint";
+  if (value === "stop-handoff") return "stop-handoff";
+  if (value === "stop-checkpoint") return "stop-handoff";
   if (value === "pre-compact") return "pre-compact";
   if (value === "prompt-guard") return "prompt-guard";
   if (value === "workflow-guard") return "workflow-guard";
@@ -1935,7 +1607,7 @@ async function main() {
     process.stderr.write(
       "[cclaw] run-hook: usage: node " +
         RUNTIME_ROOT +
-        "/hooks/run-hook.mjs <session-start|stop-checkpoint|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state>\\n"
+        "/hooks/run-hook.mjs <session-start|stop-handoff|pre-compact|prompt-guard|workflow-guard|context-monitor|verify-current-state>\\n"
     );
     process.exitCode = 1;
     return;
@@ -1967,8 +1639,8 @@ async function main() {
       process.exitCode = await handleSessionStart(runtime);
       return;
     }
-    if (hookName === "stop-checkpoint") {
-      process.exitCode = await handleStopCheckpoint(runtime);
+    if (hookName === "stop-handoff") {
+      process.exitCode = await handleStopHandoff(runtime);
       return;
     }
     if (hookName === "pre-compact") {

package/dist/content/opencode-plugin.js

@@ -1,7 +1,7 @@
 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
+    return `// cclaw OpenCode plugin — generated by npx cclaw-cli sync
 import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
@@ -14,14 +14,7 @@ export default function cclawPlugin(ctx) {
   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");
-  const contextWarningsPath = join(stateDir, "context-warnings.jsonl");
-  const contextModePath = join(stateDir, "context-mode.json");
-  const contextsDir = join(runtimeDir, "contexts");
-  const sessionDigestPath = join(stateDir, "session-digest.md");
   const knowledgePath = join(runtimeDir, "knowledge.jsonl");
-  const knowledgeDigestPath = join(stateDir, "knowledge-digest.md");
   const metaSkillPath = join(runtimeDir, "skills/${META_SKILL_NAME}/SKILL.md");
 
   function ensureRuntimeDirs() {
@@ -86,77 +79,8 @@ export default function cclawPlugin(ctx) {
     return text.split(/\\r?\\n/).slice(-maxLines);
   }
 
-  async function readCheckpointSummary() {
-    try {
-      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"}\`;
-    } catch {
-      return "";
-    }
-  }
-
-  async function readContextMode() {
-    let mode = "default";
-    try {
-      const parsed = JSON.parse(await readFileText(contextModePath));
-      if (parsed && typeof parsed.activeMode === "string" && parsed.activeMode.trim().length > 0) {
-        mode = parsed.activeMode.trim();
-      }
-    } catch {
-      // keep default
-    }
-    const guidePath = join(contextsDir, mode + ".md");
-    const guide = existsSync(guidePath) ? "${RUNTIME_ROOT}/contexts/" + mode + ".md" : "";
-    return { mode, guide };
-  }
-
-  async function readRecentActivity() {
-    try {
-      const lines = await readTailLines(activityPath, 5);
-      if (lines.length === 0) return [];
-      return lines
-        .map((line) => {
-          try {
-            return JSON.parse(line);
-          } catch {
-            return null;
-          }
-        })
-        .filter(Boolean)
-        .map((entry) => \`- \${entry.ts || "unknown"} [\${entry.phase || "unknown"}] \${entry.tool || "unknown"} (stage=\${entry.stage || "unknown"}, run=\${entry.runId || "none"})\`);
-    } catch {
-      return [];
-    }
-  }
-
-  async function readLatestContextWarning() {
-    try {
-      const line = (await readTailLines(contextWarningsPath, 1))[0];
-      if (!line) return "";
-      try {
-        const parsed = JSON.parse(line);
-        if (parsed && typeof parsed.note === "string") return parsed.note;
-      } catch {
-        // non-json fallback
-      }
-      return line;
-    } catch {
-      return "";
-    }
-  }
-
   async function readKnowledgeDigest() {
-    const digest = (await readFileText(knowledgeDigestPath)).trim();
-    if (!digest) {
-      return readTailLines(knowledgePath, 12);
-    }
-    return digest
-      .split(/\\r?\\n/)
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-      .filter((line) => !line.startsWith("#"));
+    return readTailLines(knowledgePath, 12);
   }
 
   const BOOTSTRAP_MARKER = "<!-- cclaw-bootstrap-v1 -->";
@@ -167,30 +91,14 @@ export default function cclawPlugin(ctx) {
       BOOTSTRAP_MARKER,
       \`cclaw loaded. Flow: stage=\${flow.stage} (\${flow.completed}/8 completed, run=\${flow.activeRunId}). Active artifacts: ${RUNTIME_ROOT}/artifacts/\`
     ];
-    const contextMode = await readContextMode();
-    parts.push(
-      contextMode.guide
-        ? \`Context mode: \${contextMode.mode} (guide: \${contextMode.guide})\`
-        : \`Context mode: \${contextMode.mode}\`
-    );
-
-    const checkpoint = await readCheckpointSummary();
-    if (checkpoint) parts.push(checkpoint);
-
-    const digest = (await readFileText(sessionDigestPath)).trim();
-    if (digest) parts.push("Last session:", digest);
 
-    const activity = await readRecentActivity();
-    if (activity.length > 0) parts.push("Recent stage activity:", ...activity);
 
-    const warning = await readLatestContextWarning();
-    if (warning) parts.push("Latest context warning:", warning);
 
     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."
+      "If you discover a non-obvious rule or pattern during stage work, add it to the current artifact ## Learnings section; stage-complete harvests it into .cclaw/knowledge.jsonl. Direct JSONL append is only for explicit manual learnings operations."
     );
 
     const meta = (await readFileText(metaSkillPath)).trim();
@@ -203,13 +111,7 @@ export default function cclawPlugin(ctx) {
   let bootstrapRefreshPromise = null;
   const BOOTSTRAP_SOURCE_PATHS = [
     flowStatePath,
-    checkpointPath,
-    activityPath,
-    contextWarningsPath,
-    contextModePath,
-    sessionDigestPath,
     knowledgePath,
-    knowledgeDigestPath,
     metaSkillPath
   ];
 
@@ -684,7 +586,7 @@ export default function cclawPlugin(ctx) {
         await refreshBootstrapCache(true);
       }
       if (eventType === "session.idle") {
-        await runHookScript("stop-checkpoint", { loop_count: 0 });
+        await runHookScript("stop-handoff", { loop_count: 0 });
       }
     },
     "tool.execute.before": async (input, output) => {
@@ -744,7 +646,7 @@ export default function cclawPlugin(ctx) {
         throw new Error(
           "cclaw " + failed + " blocked tool.execute.before.\\n" +
           "Reason: " + detail + "\\n" +
-          "Diagnose: run \`cclaw doctor\` in project root.\\n" +
+          "Diagnose: run \`npx cclaw-cli doctor\` in project root.\\n" +
           "Bypass (temporary): export CCLAW_DISABLE=1 before starting OpenCode,\\n" +
           "or set \`strictness: advisory\` in .cclaw/config.yaml."
         );