cclaw-cli 0.5.4 → 0.5.5

package/dist/content/hooks.js

@@ -1,19 +1,12 @@
 /**
  * Hook generators for all supported harnesses.
  *
- * SessionStart: injects using-cclaw + flow state + learnings + checkpoint/activity summary.
+ * SessionStart: injects using-cclaw + flow state + knowledge + checkpoint/activity summary.
  * Stop: writes checkpoint.json and reminds about flow consistency.
- * PreToolUse/PostToolUse and summarize chain are generated in observe.ts.
+ * Harness hook JSON wiring is generated in observe.ts.
  */
 import { RUNTIME_ROOT } from "../constants.js";
 import { META_SKILL_NAME } from "./meta-skill.js";
-function shellLiteral(value) {
-    return value
-        .replace(/\\/gu, "\\\\")
-        .replace(/"/gu, '\\"')
-        .replace(/\$/gu, "\\$")
-        .replace(/`/gu, "\\`");
-}
 const ESCAPE_FN = `escape_json() {
   local str="$1"
   str=\${str//\\\\/\\\\\\\\}
@@ -43,14 +36,10 @@ if [ -z "$ROOT" ]; then
 fi`;
 /** Shared bash preamble for generated hook scripts. */
 export const RUNTIME_SHELL_DETECT_ROOT = DETECT_ROOT;
-export function sessionStartScript(options = {}) {
-    const globalLearningsEnabled = options.globalLearningsEnabled === true;
-    const globalLearningsPath = options.globalLearningsPath?.trim() ?? "";
-    const globalLearningsPathLiteral = shellLiteral(globalLearningsPath);
-    const globalLearningsEnabledLiteral = globalLearningsEnabled ? "true" : "false";
+export function sessionStartScript(_options = {}) {
     return `#!/usr/bin/env bash
 # cclaw session-start hook — generated by cclaw sync
-# Injects using-cclaw + flow status + run pointer + top learnings + checkpoint/activity summary.
+# Injects using-cclaw + flow status + active artifacts + knowledge snapshot + checkpoint/activity summary.
 set -euo pipefail
 
 ${DETECT_ROOT}
@@ -62,12 +51,7 @@ SUGGESTION_MEMORY_FILE="$ROOT/${RUNTIME_ROOT}/state/suggestion-memory.json"
 CONTEXT_WARNINGS_FILE="$ROOT/${RUNTIME_ROOT}/state/context-warnings.jsonl"
 CONTEXT_MODE_FILE="$ROOT/${RUNTIME_ROOT}/state/context-mode.json"
 CONTEXTS_DIR="$ROOT/${RUNTIME_ROOT}/contexts"
-LEARNINGS_FILE="$ROOT/${RUNTIME_ROOT}/learnings.jsonl"
-GLOBAL_LEARNINGS_ENABLED="${globalLearningsEnabledLiteral}"
-GLOBAL_LEARNINGS_FILE="${globalLearningsPathLiteral}"
-if [ "$GLOBAL_LEARNINGS_ENABLED" = "true" ] && [ -z "$GLOBAL_LEARNINGS_FILE" ]; then
-  GLOBAL_LEARNINGS_FILE="$HOME/.cclaw-global-learnings.jsonl"
-fi
+KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.md"
 META_SKILL="$ROOT/${RUNTIME_ROOT}/skills/${META_SKILL_NAME}/SKILL.md"
 
 # --- Read flow state ---
@@ -325,82 +309,14 @@ if [ -f "$META_SKILL" ]; then
   META_CONTENT=$(cat "$META_SKILL" 2>/dev/null || echo "")
 fi
 
-# --- Read top learnings with decay ---
-LEARNINGS_SUMMARY=""
-LEARNING_LINES=""
-for source_file in "$LEARNINGS_FILE" "$GLOBAL_LEARNINGS_FILE"; do
-  [ -n "$source_file" ] || continue
-  if [ "$source_file" = "$GLOBAL_LEARNINGS_FILE" ] && [ "$GLOBAL_LEARNINGS_ENABLED" != "true" ]; then
-    continue
-  fi
-  [ -f "$source_file" ] || continue
-  [ -s "$source_file" ] || continue
-  CHUNK=$(tail -n 30 "$source_file" 2>/dev/null || echo "")
-  [ -n "$CHUNK" ] || continue
-  if [ -n "$LEARNING_LINES" ]; then
-    LEARNING_LINES="$LEARNING_LINES
-$CHUNK"
-  else
-    LEARNING_LINES="$CHUNK"
-  fi
-done
-
-if [ -n "$LEARNING_LINES" ]; then
-  if command -v jq >/dev/null 2>&1; then
-    NOW_EPOCH=$(date +%s 2>/dev/null || echo "0")
-    LEARNINGS_SUMMARY=$(printf '%s\n' "$LEARNING_LINES" | jq -r -s --arg now "$NOW_EPOCH" '
-      [.[] | select(.key != null)]
-      | group_by([.key, .type])
-      | map(sort_by(.ts) | last)
-      | map(
-          . as $e |
-          (if $e.source == "user-stated" then 0
-           else (try ((($now|tonumber) - ($e.ts // "" | fromdateiso8601)) / 2592000 | floor) catch 0)
-           end) as $months |
-          ($e.confidence - $months) as $eff |
-          . + {effective_confidence: (if $eff < 0 then 0 else $eff end)}
-        )
-      | sort_by(-.effective_confidence)
-      | .[0:3]
-      | map("- " + .key + " (conf " + (.effective_confidence|tostring) + "): " + .insight)
-      | join("\\n")
-    ' 2>/dev/null || echo "")
-  else
-    LEARNINGS_SUMMARY=$(printf '%s\n' "$LEARNING_LINES" | tail -n 3 2>/dev/null || echo "")
-  fi
-fi
-
-STAGE_LEARNINGS=""
-STAGE_LEARNING_LINES=""
-for source_file in "$LEARNINGS_FILE" "$GLOBAL_LEARNINGS_FILE"; do
-  [ -n "$source_file" ] || continue
-  if [ "$source_file" = "$GLOBAL_LEARNINGS_FILE" ] && [ "$GLOBAL_LEARNINGS_ENABLED" != "true" ]; then
-    continue
-  fi
-  [ -f "$source_file" ] || continue
-  [ -s "$source_file" ] || continue
-  CHUNK=$(tail -n 50 "$source_file" 2>/dev/null || echo "")
-  [ -n "$CHUNK" ] || continue
-  if [ -n "$STAGE_LEARNING_LINES" ]; then
-    STAGE_LEARNING_LINES="$STAGE_LEARNING_LINES
-$CHUNK"
-  else
-    STAGE_LEARNING_LINES="$CHUNK"
-  fi
-done
-
-if [ "$STAGE" != "none" ] && [ -n "$STAGE_LEARNING_LINES" ] && command -v jq >/dev/null 2>&1; then
-  STAGE_LEARNINGS=$(printf '%s\n' "$STAGE_LEARNING_LINES" | jq -r -s --arg stage "$STAGE" '
-    [.[] | select(.key != null and (.key | contains($stage)))]
-    | sort_by(-.confidence)
-    | .[0:2]
-    | map("- [stage] " + .key + ": " + .insight)
-    | join("\\n")
-  ' 2>/dev/null || echo "")
+# --- Load knowledge snapshot (append-only markdown) ---
+KNOWLEDGE_SUMMARY=""
+if [ -f "$KNOWLEDGE_FILE" ] && [ -s "$KNOWLEDGE_FILE" ]; then
+  KNOWLEDGE_SUMMARY=$(tail -n 30 "$KNOWLEDGE_FILE" 2>/dev/null || echo "")
 fi
 
 # --- Build context message ---
-CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN). Active run artifacts: ${RUNTIME_ROOT}/runs/$ACTIVE_RUN/artifacts/"
+CTX="cclaw loaded. Flow: stage=$STAGE ($COMPLETED/8 completed, run=$ACTIVE_RUN). Active artifacts: ${RUNTIME_ROOT}/artifacts/"
 if [ -n "$CONTEXT_MODE_NOTE" ]; then
   CTX="$CTX
 $CONTEXT_MODE_NOTE"
@@ -429,15 +345,10 @@ if [ -n "$STAGE_SUGGESTION" ]; then
 $STAGE_SUGGESTION
 To disable suggestions persistently set ${RUNTIME_ROOT}/state/suggestion-memory.json -> enabled=false."
 fi
-if [ -n "$LEARNINGS_SUMMARY" ]; then
-  CTX="$CTX
-Top learnings:
-$LEARNINGS_SUMMARY"
-fi
-if [ -n "$STAGE_LEARNINGS" ]; then
+if [ -n "$KNOWLEDGE_SUMMARY" ]; then
   CTX="$CTX
-Stage learnings ($STAGE):
-$STAGE_LEARNINGS"
+Knowledge snapshot (latest entries):
+$KNOWLEDGE_SUMMARY"
 fi
 if [ -n "$META_CONTENT" ]; then
   CTX="$CTX
@@ -678,98 +589,11 @@ if [ "$CHECKPOINT_WRITTEN" -eq 0 ]; then
   CHECKPOINT_NOTE="Checkpoint update failed. Review ${RUNTIME_ROOT}/state/checkpoint.json manually."
 fi
 
-RUN_SYNC_NOTE="Run metadata sync skipped."
-if [ -n "$ACTIVE_RUN" ] && [ "$ACTIVE_RUN" != "none" ] && [ "$ACTIVE_RUN" != "run-pending" ]; then
-  RUN_DIR="$ROOT/${RUNTIME_ROOT}/runs/$ACTIVE_RUN"
-  RUN_META_FILE="$RUN_DIR/run.json"
-  RUN_HANDOFF_FILE="$RUN_DIR/handoff.md"
-  if [ -f "$RUN_META_FILE" ] && [ -f "$STATE_FILE" ] && command -v python3 >/dev/null 2>&1; then
-    if python3 - "$STATE_FILE" "$RUN_META_FILE" "$RUN_HANDOFF_FILE" "$ACTIVE_RUN" "$TS" <<'PY'
-import json
-import sys
-from pathlib import Path
-
-state_path, run_meta_path, handoff_path, active_run, timestamp = sys.argv[1:6]
-
-try:
-    state = json.loads(Path(state_path).read_text(encoding="utf-8"))
-except Exception:
-    raise SystemExit(1)
-
-try:
-    meta = json.loads(Path(run_meta_path).read_text(encoding="utf-8"))
-except Exception:
-    raise SystemExit(1)
-
-if not isinstance(state, dict) or not isinstance(meta, dict):
-    raise SystemExit(1)
-
-completed = state.get("completedStages")
-if not isinstance(completed, list):
-    completed = []
-completed = [stage for stage in completed if isinstance(stage, str)]
-
-guard_evidence = state.get("guardEvidence")
-if not isinstance(guard_evidence, dict):
-    guard_evidence = {}
-guard_evidence = {k: v for k, v in guard_evidence.items() if isinstance(k, str) and isinstance(v, str)}
-
-stage_gate_catalog = state.get("stageGateCatalog")
-if not isinstance(stage_gate_catalog, dict):
-    stage_gate_catalog = {}
-
-snapshot = {
-    "currentStage": state.get("currentStage") if isinstance(state.get("currentStage"), str) else "brainstorm",
-    "completedStages": completed,
-    "guardEvidence": guard_evidence,
-    "stageGateCatalog": stage_gate_catalog,
-}
-meta["stateSnapshot"] = snapshot
-Path(run_meta_path).write_text(json.dumps(meta, indent=2) + "\\n", encoding="utf-8")
-
-title = meta.get("title") if isinstance(meta.get("title"), str) and meta.get("title") else active_run
-created_at = meta.get("createdAt") if isinstance(meta.get("createdAt"), str) and meta.get("createdAt") else "unknown"
-archived_at = meta.get("archivedAt") if isinstance(meta.get("archivedAt"), str) and meta.get("archivedAt") else None
-completed_display = ", ".join(completed) if completed else "(none)"
-
-handoff_lines = [
-    "# Run Handoff",
-    "",
-    f"- ID: {active_run}",
-    f"- Title: {title}",
-    f"- Created: {created_at}",
-    f"- Archived: {archived_at if archived_at else 'active'}",
-    "",
-    "## Flow Snapshot",
-    f"- Active stage: {snapshot['currentStage']}",
-    f"- Completed stages: {completed_display}",
-    f"- Active run ID in flow-state: {state.get('activeRunId') if isinstance(state.get('activeRunId'), str) else active_run}",
-    "",
-    "## Paths",
-    f"- Active artifacts: ${RUNTIME_ROOT}/artifacts/",
-    f"- Run artifacts snapshot: ${RUNTIME_ROOT}/runs/{active_run}/artifacts/",
-    f"- Flow state: ${RUNTIME_ROOT}/state/flow-state.json",
-    "",
-    "## Resume",
-    "1. Open ${RUNTIME_ROOT}/state/flow-state.json and verify current stage.",
-    "2. Review ${RUNTIME_ROOT}/artifacts/ for the latest working artifacts.",
-    "3. Continue using /cc or /cc-next from the current stage.",
-    "",
-    f"- Last updated: {timestamp}",
-]
-Path(handoff_path).write_text("\\n".join(handoff_lines) + "\\n", encoding="utf-8")
-PY
-    then
-      RUN_SYNC_NOTE="Run metadata synchronized for $ACTIVE_RUN."
-    else
-      RUN_SYNC_NOTE="Run metadata sync failed for $ACTIVE_RUN."
-    fi
-  fi
-fi
+RUN_SYNC_NOTE="Run metadata sync removed; active artifacts stay in ${RUNTIME_ROOT}/artifacts until cclaw archive."
 
 # --- Escape for JSON ---
 ${ESCAPE_FN}
-MSG=$(escape_json "Cclaw: session ending (stage=$STAGE, run=$ACTIVE_RUN). $CHECKPOINT_NOTE $RUN_SYNC_NOTE Before stopping: (1) confirm flow-state reflects reality, (2) ensure artifact changes match active run intent, (3) log reusable learnings, (4) commit or revert pending changes.")
+MSG=$(escape_json "Cclaw: session ending (stage=$STAGE, run=$ACTIVE_RUN). $CHECKPOINT_NOTE $RUN_SYNC_NOTE 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 it to ${RUNTIME_ROOT}/knowledge.md, (4) commit or revert pending changes.")
 
 # --- Output harness-specific JSON ---
 case "$HARNESS" in
@@ -793,8 +617,7 @@ esac
 `;
 }
 // ---------------------------------------------------------------------------
-// hooks.json generators — NOW use observe.ts versions with PreToolUse/PostToolUse
-// These are kept as fallbacks for when observation is disabled.
+// hooks.json generators are defined in observe.ts (shared across harnesses).
 // ---------------------------------------------------------------------------
 export { claudeHooksJsonWithObservation as claudeHooksJson } from "./observe.js";
 export { cursorHooksJsonWithObservation as cursorHooksJson } from "./observe.js";
@@ -802,151 +625,70 @@ export { codexHooksJsonWithObservation as codexHooksJson } from "./observe.js";
 // ---------------------------------------------------------------------------
 // OpenCode plugin — JS module
 // ---------------------------------------------------------------------------
-export function opencodePluginJs(options = {}) {
-    const globalLearningsEnabledLiteral = options.globalLearningsEnabled === true ? "true" : "false";
-    const globalLearningsPathLiteral = JSON.stringify(options.globalLearningsPath?.trim() ?? "");
+export function opencodePluginJs(_options = {}) {
     return `// cclaw OpenCode plugin — generated by cclaw sync
-import {
-  appendFileSync,
-  closeSync,
-  existsSync,
-  fstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  readSync
-} from "node:fs";
-import { homedir } from "node:os";
-import { isAbsolute, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 export default function cclawPlugin(ctx) {
   const root = ctx.directory || process.cwd();
   const runtimeDir = join(root, "${RUNTIME_ROOT}");
-  const stateDir = join(root, "${RUNTIME_ROOT}/state");
-  const observationsPath = join(root, "${RUNTIME_ROOT}/observations.jsonl");
-  const learningsPath = join(root, "${RUNTIME_ROOT}/learnings.jsonl");
-  const checkpointPath = join(root, "${RUNTIME_ROOT}/state/checkpoint.json");
-  const activityPath = join(root, "${RUNTIME_ROOT}/state/stage-activity.jsonl");
-  const suggestionMemoryPath = join(root, "${RUNTIME_ROOT}/state/suggestion-memory.json");
-  const contextWarningsPath = join(root, "${RUNTIME_ROOT}/state/context-warnings.jsonl");
-  const contextModePath = join(root, "${RUNTIME_ROOT}/state/context-mode.json");
-  const contextsDir = join(root, "${RUNTIME_ROOT}/contexts");
-  const sessionDigestPath = join(root, "${RUNTIME_ROOT}/state/session-digest.md");
-  const observeDisabledPath = join(root, "${RUNTIME_ROOT}/.observe-disabled");
-  const globalLearningsEnabled = ${globalLearningsEnabledLiteral};
-  const globalLearningsPathRaw = ${globalLearningsPathLiteral};
+  const stateDir = join(runtimeDir, "state");
+  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.md");
+  const metaSkillPath = join(runtimeDir, "skills/${META_SKILL_NAME}/SKILL.md");
 
-  function readFlowState() {
+  function ensureRuntimeDirs() {
     try {
-      const raw = readFileSync(join(root, "${RUNTIME_ROOT}/state/flow-state.json"), "utf8");
-      const state = JSON.parse(raw);
-      return {
-        stage: state.currentStage || "none",
-        completed: (state.completedStages || []).length,
-        activeRunId: state.activeRunId || "none",
-      };
+      mkdirSync(runtimeDir, { recursive: true });
     } catch {
-      return { stage: "none", completed: 0, activeRunId: "none" };
+      // ignore
     }
-  }
-
-  function readMetaSkill() {
     try {
-      return readFileSync(join(root, "${RUNTIME_ROOT}/skills/${META_SKILL_NAME}/SKILL.md"), "utf8");
+      mkdirSync(stateDir, { recursive: true });
     } catch {
-      return "";
+      // ignore
     }
   }
 
-  function readTailText(filePath, maxBytes = 65536) {
-    let fd;
+  function readFlowState() {
     try {
-      fd = openSync(filePath, "r");
-      const size = fstatSync(fd).size;
-      if (!Number.isFinite(size) || size <= 0) return "";
-      const bytesToRead = Math.min(size, maxBytes);
-      const buffer = Buffer.allocUnsafe(bytesToRead);
-      readSync(fd, buffer, 0, bytesToRead, size - bytesToRead);
-      return buffer.toString("utf8");
+      const raw = readFileSync(flowStatePath, "utf8");
+      const state = JSON.parse(raw);
+      return {
+        stage: typeof state.currentStage === "string" ? state.currentStage : "none",
+        completed: Array.isArray(state.completedStages) ? state.completedStages.length : 0,
+        activeRunId: typeof state.activeRunId === "string" ? state.activeRunId : "none"
+      };
     } catch {
-      return "";
-    } finally {
-      if (fd !== undefined) {
-        try {
-          closeSync(fd);
-        } catch {
-          // ignore
-        }
-      }
-    }
-  }
-
-  function readTailLines(filePath, maxLines, maxBytes = 65536) {
-    const raw = readTailText(filePath, maxBytes).trim();
-    if (!raw) return [];
-    return raw.split(/\\r?\\n/).slice(-maxLines);
-  }
-
-  function resolveGlobalLearningsPath(rawPath) {
-    if (!rawPath || typeof rawPath !== "string" || rawPath.trim().length === 0) {
-      return join(homedir(), ".cclaw-global-learnings.jsonl");
-    }
-    const trimmed = rawPath.trim();
-    if (trimmed.startsWith("~/")) {
-      return join(homedir(), trimmed.slice(2));
-    }
-    if (isAbsolute(trimmed)) {
-      return trimmed;
-    }
-    return join(root, trimmed);
-  }
-
-  function learningFiles() {
-    const files = [learningsPath];
-    if (globalLearningsEnabled) {
-      const globalPath = resolveGlobalLearningsPath(globalLearningsPathRaw);
-      if (globalPath !== learningsPath) {
-        files.push(globalPath);
-      }
-    }
-    return files;
-  }
-
-  function readLearningLines(maxLines, maxBytes) {
-    const combined = [];
-    for (const filePath of learningFiles()) {
-      combined.push(...readTailLines(filePath, maxLines, maxBytes));
+      return { stage: "none", completed: 0, activeRunId: "none" };
     }
-    return combined;
   }
 
-  function readTopLearnings() {
+  function readFileText(filePath) {
     try {
-      const lines = readLearningLines(30, 65536);
-      if (lines.length === 0) return [];
-      const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-      const deduped = new Map();
-      for (const e of entries) {
-        const key = e.key + ":" + e.type;
-        if (!deduped.has(key) || e.ts > deduped.get(key).ts) deduped.set(key, e);
-      }
-      const now = Date.now();
-      return [...deduped.values()]
-        .map(e => {
-          const months = e.source === "user-stated" ? 0 : Math.floor((now - new Date(e.ts).getTime()) / (30 * 86400000));
-          const eff = Math.max(0, e.confidence - months);
-          return { ...e, effective_confidence: eff };
-        })
-        .sort((a, b) => b.effective_confidence - a.effective_confidence)
-        .slice(0, 3);
+      return readFileSync(filePath, "utf8");
     } catch {
-      return [];
+      return "";
     }
   }
 
+  function readTailLines(filePath, maxLines) {
+    const text = readFileText(filePath).trim();
+    if (!text) return [];
+    return text.split(/\\r?\\n/).slice(-maxLines);
+  }
+
   function readCheckpointSummary() {
     try {
-      const raw = readFileSync(checkpointPath, "utf8");
+      const raw = 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 {
@@ -957,13 +699,12 @@ export default function cclawPlugin(ctx) {
   function readContextMode() {
     let mode = "default";
     try {
-      const raw = readFileSync(contextModePath, "utf8");
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(readFileText(contextModePath));
       if (parsed && typeof parsed.activeMode === "string" && parsed.activeMode.trim().length > 0) {
         mode = parsed.activeMode.trim();
       }
     } catch {
-      // use default mode
+      // keep default
     }
     const guidePath = join(contextsDir, mode + ".md");
     const guide = existsSync(guidePath) ? "${RUNTIME_ROOT}/contexts/" + mode + ".md" : "";
@@ -972,40 +713,32 @@ export default function cclawPlugin(ctx) {
 
   function readRecentActivity() {
     try {
-      const lines = readTailLines(activityPath, 5, 32768);
+      const lines = 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"})\`);
+      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 [];
     }
   }
 
-  function readSessionDigest() {
-    try {
-      const digest = readFileSync(sessionDigestPath, "utf8").trim();
-      return digest;
-    } catch {
-      return "";
-    }
-  }
-
   function readLatestContextWarning() {
     try {
-      const line = readTailLines(contextWarningsPath, 1, 8192)[0];
+      const line = readTailLines(contextWarningsPath, 1)[0];
       if (!line) return "";
       try {
         const parsed = JSON.parse(line);
-        if (parsed && typeof parsed.note === "string") {
-          return parsed.note;
-        }
+        if (parsed && typeof parsed.note === "string") return parsed.note;
       } catch {
-        // non-json line fallback
+        // non-json fallback
       }
       return line;
     } catch {
@@ -1013,95 +746,42 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function stageSuggestionFor(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 waves 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] || "";
-  }
-
-  function readStageSuggestion(stage) {
-    let memory = { enabled: true, mutedStages: [] };
-    try {
-      const parsed = JSON.parse(readFileSync(suggestionMemoryPath, "utf8"));
-      if (parsed && typeof parsed === "object") {
-        memory = {
-          enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : true,
-          mutedStages: Array.isArray(parsed.mutedStages)
-            ? parsed.mutedStages.filter((item) => typeof item === "string")
-            : []
-        };
-      }
-    } catch {
-      // use defaults
-    }
-    if (!memory.enabled || memory.mutedStages.includes(stage)) {
-      return "";
-    }
-    return stageSuggestionFor(stage);
-  }
-
-  function readStageLearnings(stage) {
-    try {
-      const lines = readLearningLines(60, 131072);
-      const entries = lines
-        .map((line) => {
-          try {
-            return JSON.parse(line);
-          } catch {
-            return null;
-          }
-        })
-        .filter(Boolean);
-      if (entries.length === 0) return [];
-      return entries
-        .filter((entry) => typeof entry.key === "string" && entry.key.toLowerCase().includes(stage.toLowerCase()))
-        .sort((a, b) => (Number(b.confidence) || 0) - (Number(a.confidence) || 0))
-        .slice(0, 2)
-        .map((entry) => "- [stage] " + entry.key + ": " + entry.insight);
-    } catch {
-      return [];
-    }
+  function readKnowledgeSnapshot() {
+    return readTailLines(knowledgePath, 30);
   }
 
   function buildBootstrap() {
-    const { stage, completed, activeRunId } = readFlowState();
-    const meta = readMetaSkill();
-    const learnings = readTopLearnings();
-    const checkpoint = readCheckpointSummary();
-    const activity = readRecentActivity();
-    const digest = readSessionDigest();
-    const warning = readLatestContextWarning();
+    const flow = readFlowState();
+    const parts = [
+      \`cclaw loaded. Flow: stage=\${flow.stage} (\${flow.completed}/8 completed, run=\${flow.activeRunId}). Active artifacts: ${RUNTIME_ROOT}/artifacts/\`
+    ];
     const contextMode = readContextMode();
-    const stageSuggestion = readStageSuggestion(stage);
-    const stageLearnings = readStageLearnings(stage);
-    const parts = [\`cclaw loaded. Flow: stage=\${stage} (\${completed}/8 completed, run=\${activeRunId}). Active run artifacts: ${RUNTIME_ROOT}/runs/\${activeRunId}/artifacts/\`];
     parts.push(
       contextMode.guide
         ? \`Context mode: \${contextMode.mode} (guide: \${contextMode.guide})\`
         : \`Context mode: \${contextMode.mode}\`
     );
+
+    const checkpoint = readCheckpointSummary();
     if (checkpoint) parts.push(checkpoint);
+
+    const digest = readFileText(sessionDigestPath).trim();
     if (digest) parts.push("Last session:", digest);
+
+    const activity = readRecentActivity();
     if (activity.length > 0) parts.push("Recent stage activity:", ...activity);
+
+    const warning = readLatestContextWarning();
     if (warning) parts.push("Latest context warning:", warning);
-    if (stageSuggestion) {
-      parts.push(stageSuggestion, "To disable suggestions persistently set .cclaw/state/suggestion-memory.json -> enabled=false.");
-    }
-    if (learnings.length > 0) {
-      parts.push("Top learnings:");
-      for (const l of learnings) parts.push(\`- \${l.key} (conf \${l.effective_confidence}): \${l.insight}\`);
-    }
-    if (stageLearnings.length > 0) {
-      parts.push(\`Stage learnings (\${stage}):\`, ...stageLearnings);
-    }
+
+    const knowledge = readKnowledgeSnapshot();
+    if (knowledge.length > 0) parts.push("Knowledge snapshot (latest entries):", ...knowledge);
+
+    parts.push(
+      "If you discover a non-obvious rule or pattern, append it to .cclaw/knowledge.md using type: rule, pattern, or lesson."
+    );
+
+    const meta = readFileText(metaSkillPath).trim();
     if (meta) parts.push("", meta);
     return parts.join("\\n");
   }
@@ -1110,23 +790,6 @@ export default function cclawPlugin(ctx) {
     console.log(buildBootstrap());
   }
 
-  function observationEnabled() {
-    return !existsSync(observeDisabledPath);
-  }
-
-  function ensureRuntimeDirs() {
-    try {
-      mkdirSync(runtimeDir, { recursive: true });
-    } catch {
-      // ignore
-    }
-    try {
-      mkdirSync(stateDir, { recursive: true });
-    } catch {
-      // ignore
-    }
-  }
-
   async function runHookScript(scriptFileName, payload = {}) {
     const { spawnSync } = await import("node:child_process");
     const scriptPath = join(root, "${RUNTIME_ROOT}/hooks/" + scriptFileName);
@@ -1143,53 +806,9 @@ export default function cclawPlugin(ctx) {
     }
   }
 
-  function toText(value) {
-    if (typeof value === "string") return value;
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return value == null ? "" : String(value);
-    }
-  }
-
-  function truncateText(value, maxLen = 2000) {
-    const text = toText(value);
-    return text.length > maxLen ? text.slice(0, maxLen) : text;
-  }
-
-  function extractToolName(payload) {
-    const candidates = [
-      payload?.tool,
-      payload?.toolName,
-      payload?.tool_name,
-      payload?.name,
-      payload?.id,
-      payload?.command,
-      payload?.tool?.name,
-      payload?.tool?.id,
-      payload?.input?.tool,
-      payload?.input?.toolName,
-      payload?.input?.tool_name,
-      payload?.input?.name,
-      payload?.input?.id,
-      payload?.input?.command,
-      payload?.input?.tool?.name,
-      payload?.input?.tool?.id
-    ];
-    for (const value of candidates) {
-      if (typeof value === "string" && value.trim()) return value.trim();
-    }
-    return "unknown";
-  }
-
   function normalizeToolPayload(input, output) {
-    if (typeof output === "undefined") {
-      return input ?? {};
-    }
-    return {
-      input: input ?? {},
-      output: output ?? {}
-    };
+    if (typeof output === "undefined") return input ?? {};
+    return { input: input ?? {}, output: output ?? {} };
   }
 
   function resolveEventType(payload) {
@@ -1212,77 +831,41 @@ export default function cclawPlugin(ctx) {
     return payload;
   }
 
-  function appendJsonLine(filePath, value) {
-    try {
-      appendFileSync(filePath, JSON.stringify(value) + "\\n", "utf8");
-    } catch {
-      // ignore
-    }
-  }
-
-  function recordToolEvent(phase, payload) {
-    if (!observationEnabled()) return;
-    const flow = readFlowState();
-    const ts = new Date().toISOString();
-    const tool = extractToolName(payload);
-    const event = phase === "pre" ? "tool_start" : "tool_complete";
-    ensureRuntimeDirs();
-    appendJsonLine(observationsPath, {
-      ts,
-      event,
-      tool,
-      phase,
-      stage: flow.stage,
-      runId: flow.activeRunId,
-      data: truncateText(payload)
-    });
-    appendJsonLine(activityPath, {
-      ts,
-      event,
-      tool,
-      phase,
-      stage: flow.stage,
-      runId: flow.activeRunId
-    });
-  }
+  ensureRuntimeDirs();
 
   return {
     event: async (payload) => {
       const eventType = resolveEventType(payload);
       const eventData = resolveEventData(payload);
-      if (eventType === "session.created" || eventType === "session.resumed" || eventType === "session.compacted" || eventType === "session.cleared") {
+      if (
+        eventType === "session.created" ||
+        eventType === "session.resumed" ||
+        eventType === "session.compacted" ||
+        eventType === "session.cleared"
+      ) {
         emitBootstrap();
       }
-      if (eventType === "session.updated") {
-        // no-op: tracked via activity log
-      }
       if (eventType === "session.idle") {
-        if (!observationEnabled()) return;
-        await runHookScript("summarize-observations.sh");
         await runHookScript("stop-checkpoint.sh", { loop_count: 0 });
       }
       if (eventType === "tool.execute.before") {
         const toolPayload = normalizeToolPayload(eventData, undefined);
         await runHookScript("prompt-guard.sh", toolPayload);
         await runHookScript("workflow-guard.sh", toolPayload);
-        recordToolEvent("pre", toolPayload);
       }
       if (eventType === "tool.execute.after") {
         const toolPayload = normalizeToolPayload(eventData, undefined);
         await runHookScript("context-monitor.sh", toolPayload);
-        recordToolEvent("post", toolPayload);
       }
     },
     "tool.execute.before": async (input, output) => {
       const payload = normalizeToolPayload(input, output);
       await runHookScript("prompt-guard.sh", payload);
       await runHookScript("workflow-guard.sh", payload);
-      recordToolEvent("pre", payload);
     },
     "tool.execute.after": async (input, output) => {
       const payload = normalizeToolPayload(input, output);
       await runHookScript("context-monitor.sh", payload);
-      recordToolEvent("post", payload);
     },
     "experimental.chat.system.transform": (payload) => {
       const bootstrap = buildBootstrap();
@@ -1294,7 +877,7 @@ export default function cclawPlugin(ctx) {
         return { ...payload, system: \`\${payload.system}\\n\\n\${bootstrap}\` };
       }
       return payload;
-    },
+    }
   };
 }
 `;
@@ -1307,7 +890,7 @@ export function hooksAgentsMdBlock() {
 
 Cclaw generates real hook integrations across harnesses:
 - **Claude/Cursor/Codex:** lifecycle rehydration + PreToolUse/PostToolUse + Stop
-- **OpenCode:** session lifecycle + system transform rehydration + bootstrap parity (digest/warnings/suggestions/stage learnings)
+- **OpenCode:** session lifecycle + system transform rehydration + bootstrap parity (digest/warnings/knowledge snapshot)
 
 | Harness | Hook file | Events |
 |---------|-----------|--------|
@@ -1319,7 +902,5 @@ Cclaw generates real hook integrations across harnesses:
 Hook state files:
 - \`${RUNTIME_ROOT}/state/stage-activity.jsonl\`
 - \`${RUNTIME_ROOT}/state/checkpoint.json\`
-
-Disable observation: \`touch ${RUNTIME_ROOT}/.observe-disabled\`
 `;
 }