cclaw-cli 0.46.6 → 0.46.7

package/dist/content/observe.d.ts

@@ -16,8 +16,6 @@ export interface WorkflowGuardOptions {
 }
 export declare function workflowGuardScript(options?: WorkflowGuardOptions): string;
 export declare function contextMonitorScript(): string;
-export declare function summarizeObservationsRuntimeModule(): string;
-export declare function summarizeObservationsScript(): string;
 export declare function claudeHooksJsonWithObservation(): string;
 export declare function cursorHooksJsonWithObservation(): string;
 /**

package/dist/content/observe.js

@@ -913,641 +913,6 @@ if [ -s "$TMP_STATE" ]; then
   mv "$TMP_STATE" "$MONITOR_STATE" 2>/dev/null || rm -f "$TMP_STATE" 2>/dev/null || true
 fi
 
-exit 0
-`;
-}
-export function summarizeObservationsRuntimeModule() {
-    return `#!/usr/bin/env node
-import fs from "node:fs";
-
-const [, , observationsPath, learningsPath, timestampArg] = process.argv;
-
-function readTailText(filePath, maxBytes = 524288) {
-  let fd;
-  try {
-    fd = fs.openSync(filePath, "r");
-    const size = fs.fstatSync(fd).size;
-    if (!Number.isFinite(size) || size <= 0) return "";
-    const bytesToRead = Math.min(size, maxBytes);
-    const buffer = Buffer.allocUnsafe(bytesToRead);
-    fs.readSync(fd, buffer, 0, bytesToRead, size - bytesToRead);
-    return buffer.toString("utf8");
-  } catch {
-    return "";
-  } finally {
-    if (fd !== undefined) {
-      try {
-        fs.closeSync(fd);
-      } catch {
-        // ignore
-      }
-    }
-  }
-}
-
-function readTailLines(filePath, maxLines, maxBytes = 524288) {
-  const raw = readTailText(filePath, maxBytes).trim();
-  if (!raw) return [];
-  return raw.split(/\\r?\\n/).slice(-maxLines);
-}
-
-function writeAppend(filePath, lines) {
-  if (!lines.length) return;
-  try {
-    fs.appendFileSync(filePath, lines.join("\\n") + "\\n", "utf8");
-  } catch {
-    // advisory-only runtime path
-  }
-}
-
-function parseLine(line) {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-function toText(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return "";
-  }
-}
-
-const keyPattern = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const errorPattern = /(error|fail|timeout|exception)/i;
-const timestamp = timestampArg || new Date().toISOString();
-const observationLines = readTailLines(observationsPath, 4000, 1024 * 1024);
-const learningLines = readTailLines(learningsPath, 6000, 1024 * 1024);
-
-const observations = observationLines
-  .map(parseLine)
-  .filter(Boolean);
-
-if (observations.length < 5) {
-  process.exit(0);
-}
-
-const toolUsage = new Map();
-const toolErrors = new Map();
-const stageErrors = new Map();
-const longPayload = new Map();
-
-for (const obs of observations) {
-  const toolRaw = typeof obs.tool === "string" ? obs.tool : "unknown";
-  const stageRaw = typeof obs.stage === "string" ? obs.stage : "none";
-  const tool = toolRaw.trim().replace(/[^A-Za-z0-9._-]+/g, "-") || "unknown";
-  const stage = stageRaw.trim().replace(/[^A-Za-z0-9._-]+/g, "-") || "none";
-  const payload = toText(obs.data);
-  toolUsage.set(tool, (toolUsage.get(tool) || 0) + 1);
-  if (payload.length >= 1500) {
-    longPayload.set(tool, (longPayload.get(tool) || 0) + 1);
-  }
-  if (obs.event === "tool_complete" && errorPattern.test(payload)) {
-    toolErrors.set(tool, (toolErrors.get(tool) || 0) + 1);
-    stageErrors.set(stage, (stageErrors.get(stage) || 0) + 1);
-  }
-}
-
-const candidates = [];
-
-for (const [tool, errors] of toolErrors.entries()) {
-  if (errors < 3) continue;
-  candidates.push({
-    ts: timestamp,
-    skill: "observation",
-    type: "pitfall",
-    key: "frequent-errors-" + tool,
-    insight: "Tool " + tool + " produced " + errors + " error-like completions in a single session; add a preflight checklist before using it.",
-    confidence: Math.min(9, 4 + Math.floor(errors / 2)),
-    source: "observed"
-  });
-}
-
-for (const [tool, total] of toolUsage.entries()) {
-  if (total < 8) continue;
-  const errors = toolErrors.get(tool) || 0;
-  if (errors > Math.max(1, Math.floor(total * 0.15))) continue;
-  candidates.push({
-    ts: timestamp,
-    skill: "observation",
-    type: "pattern",
-    key: "reliable-tool-" + tool,
-    insight: "Tool " + tool + " was used " + total + " times with low failure rate; prefer it as a first option for similar tasks.",
-    confidence: Math.min(8, 3 + Math.floor(total / 3)),
-    source: "observed"
-  });
-}
-
-for (const [stage, errors] of stageErrors.entries()) {
-  if (stage === "none" || errors < 4) continue;
-  candidates.push({
-    ts: timestamp,
-    skill: "observation",
-    type: "pitfall",
-    key: "stage-hotspot-" + stage,
-    insight: "Stage " + stage + " produced " + errors + " error-like tool completions in one session; add stage-specific checks before execution.",
-    confidence: Math.min(8, 3 + Math.floor(errors / 2)),
-    source: "observed"
-  });
-}
-
-for (const [tool, count] of longPayload.entries()) {
-  if (count < 3) continue;
-  candidates.push({
-    ts: timestamp,
-    skill: "observation",
-    type: "preference",
-    key: "truncate-heavy-payloads-" + tool,
-    insight: "Tool " + tool + " produced large payloads repeatedly; summarize outputs earlier to avoid context pressure.",
-    confidence: Math.min(7, 3 + Math.floor(count / 2)),
-    source: "observed"
-  });
-}
-
-const toolFilePathCounts = new Map();
-function extractFilePathsFromPayload(dataVal) {
-  const text = toText(dataVal);
-  if (!text) return [];
-  const found = [];
-  const seen = new Set();
-  try {
-    const obj = JSON.parse(text);
-    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-      const keys = [
-        "path",
-        "file_path",
-        "filePath",
-        "target_file",
-        "file",
-        "filepath",
-        "old_path",
-        "new_path",
-        "targetPath"
-      ];
-      for (const k of keys) {
-        if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
-        const v = obj[k];
-        if (typeof v === "string" && v.length > 1 && (v.includes("/") || v.includes("\\\\"))) {
-          const norm = v.replace(/\\\\/g, "/").replace(/\\/+/g, "/");
-          if (!seen.has(norm)) {
-            seen.add(norm);
-            found.push(norm);
-          }
-        }
-      }
-    }
-  } catch {
-    // ignore JSON parse errors
-  }
-  return found;
-}
-
-for (const obs of observations) {
-  const toolRaw = typeof obs.tool === "string" ? obs.tool : "unknown";
-  const tool = toolRaw.trim().replace(/[^A-Za-z0-9._-]+/g, "-") || "unknown";
-  for (const filePath of extractFilePathsFromPayload(obs.data)) {
-    const pairKey = JSON.stringify([tool, filePath]);
-    toolFilePathCounts.set(pairKey, (toolFilePathCounts.get(pairKey) || 0) + 1);
-  }
-}
-
-for (const [pairKey, uses] of toolFilePathCounts.entries()) {
-  if (uses < 5) continue;
-  let tool = "unknown";
-  let filePath = "";
-  try {
-    const parsed = JSON.parse(pairKey);
-    if (!Array.isArray(parsed) || parsed.length !== 2) continue;
-    if (typeof parsed[0] === "string") tool = parsed[0];
-    if (typeof parsed[1] === "string") filePath = parsed[1];
-  } catch {
-    continue;
-  }
-  if (!filePath) continue;
-  const parts = filePath.split(/[/\\\\]/);
-  let basename = parts[parts.length - 1] || filePath;
-  basename = basename.trim().replace(/[^A-Za-z0-9._-]+/g, "-") || "file";
-  const key = "file-affinity-" + tool + "-" + basename;
-  if (!keyPattern.test(key)) continue;
-  candidates.push({
-    ts: timestamp,
-    skill: "observation",
-    type: "pattern",
-    key: key,
-    insight:
-      "Tool " +
-      tool +
-      " frequently targets " +
-      filePath +
-      "; consider pre-loading it for this stage.",
-    confidence: 4,
-    source: "observed"
-  });
-}
-
-if (observations.length >= 10) {
-  const stages = new Set();
-  for (const obs of observations) {
-    const s = typeof obs.stage === "string" ? obs.stage.trim() : "none";
-    stages.add(s || "none");
-  }
-  if (stages.size === 1) {
-    const onlyStage = [...stages][0];
-    if (onlyStage && onlyStage !== "none") {
-      const stageSan = onlyStage.replace(/[^A-Za-z0-9._-]+/g, "-") || "none";
-      const times = [];
-      for (const obs of observations) {
-        if (typeof obs.ts === "string") {
-          const ms = Date.parse(obs.ts);
-          if (!Number.isNaN(ms)) times.push(ms);
-        }
-      }
-      times.sort((a, b) => a - b);
-      if (times.length >= 2) {
-        const spanMin = Math.max(
-          1,
-          Math.round((times[times.length - 1] - times[0]) / 60000)
-        );
-        const M = observations.length;
-        const velKey = "stage-velocity-" + stageSan;
-        if (keyPattern.test(velKey)) {
-          candidates.push({
-            ts: timestamp,
-            skill: "observation",
-            type: "operational",
-            key: velKey,
-            insight:
-              "Stage " +
-              onlyStage +
-              " took approximately " +
-              spanMin +
-              " minutes with " +
-              M +
-              " tool calls.",
-            confidence: 3,
-            source: "observed"
-          });
-        }
-      }
-    }
-  }
-}
-
-const valid = [];
-const bestCandidate = new Map();
-for (const candidate of candidates) {
-  if (typeof candidate.key !== "string" || !keyPattern.test(candidate.key)) continue;
-  if (typeof candidate.insight !== "string" || candidate.insight.trim().length < 16) continue;
-  if (!Number.isInteger(candidate.confidence) || candidate.confidence < 1 || candidate.confidence > 10) continue;
-  const token = candidate.key + ":" + candidate.type;
-  const current = bestCandidate.get(token);
-  if (!current || candidate.confidence > current.confidence) {
-    bestCandidate.set(token, candidate);
-  }
-}
-for (const value of bestCandidate.values()) {
-  valid.push(value);
-}
-
-const bestExisting = new Map();
-for (const line of learningLines) {
-  const parsed = parseLine(line);
-  if (!parsed) continue;
-  if (typeof parsed.key !== "string" || typeof parsed.type !== "string") continue;
-  if (typeof parsed.confidence !== "number" || !Number.isInteger(parsed.confidence)) continue;
-  const token = parsed.key + ":" + parsed.type;
-  const current = bestExisting.get(token) || 0;
-  if (parsed.confidence > current) {
-    bestExisting.set(token, parsed.confidence);
-  }
-}
-
-const appended = [];
-for (const candidate of valid) {
-  const token = candidate.key + ":" + candidate.type;
-  const current = bestExisting.get(token) || 0;
-  if (candidate.confidence > current) {
-    appended.push(JSON.stringify(candidate));
-    bestExisting.set(token, candidate.confidence);
-  }
-}
-
-writeAppend(learningsPath, appended);
-process.exit(0);
-`;
-}
-export function summarizeObservationsScript() {
-    return `#!/usr/bin/env bash
-# cclaw stop-summarize hook — generated by cclaw sync
-# Analyzes recent observations and creates learnings entries.
-# Runs as part of the stop hook chain.
-set -uo pipefail
-
-${RUNTIME_SHELL_DETECT_ROOT}
-
-OBS_FILE="$ROOT/${RUNTIME_ROOT}/observations.jsonl"
-LEARNINGS_FILE="$ROOT/${RUNTIME_ROOT}/learnings.jsonl"
-ACTIVITY_FILE="$ROOT/${RUNTIME_ROOT}/state/stage-activity.jsonl"
-LOCK_DIR="$ROOT/${RUNTIME_ROOT}/state/.observe.lock"
-mkdir -p "$ROOT/${RUNTIME_ROOT}/state" 2>/dev/null || true
-[ -f "$LEARNINGS_FILE" ] || : > "$LEARNINGS_FILE" 2>/dev/null || true
-
-# Guard
-[ -f "$OBS_FILE" ] || exit 0
-[ -s "$OBS_FILE" ] || exit 0
-
-acquire_lock() {
-  local attempt=0
-  while ! mkdir "$LOCK_DIR" 2>/dev/null; do
-    attempt=$((attempt + 1))
-    if [ "$attempt" -ge 200 ]; then
-      return 1
-    fi
-    sleep 0.02
-  done
-  return 0
-}
-
-release_lock() {
-  rmdir "$LOCK_DIR" 2>/dev/null || true
-}
-
-rotate_file() {
-  local file_path="$1"
-  local keep_lines="$2"
-  if [ ! -f "$file_path" ]; then
-    return
-  fi
-  local line_count
-  line_count=$(wc -l < "$file_path" 2>/dev/null | tr -d ' ')
-  if [ -z "$line_count" ]; then
-    return
-  fi
-  if [ "$line_count" -gt $((keep_lines * 2)) ]; then
-    local tmp_path="\${file_path}.tmp.$$"
-    if tail -n "$keep_lines" "$file_path" > "$tmp_path" 2>/dev/null; then
-      mv "$tmp_path" "$file_path" 2>/dev/null || rm -f "$tmp_path" 2>/dev/null || true
-    fi
-  fi
-}
-
-acquire_lock || exit 0
-trap release_lock EXIT INT TERM
-
-# Count observations in this session
-OBS_COUNT=$(wc -l < "$OBS_FILE" 2>/dev/null | tr -d ' ')
-[ "$OBS_COUNT" -lt 5 ] && exit 0
-
-TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || echo "")
-RUNTIME_SUMMARIZER="$ROOT/${RUNTIME_ROOT}/hooks/summarize-observations.mjs"
-if command -v node >/dev/null 2>&1 && [ -f "$RUNTIME_SUMMARIZER" ]; then
-  node "$RUNTIME_SUMMARIZER" "$OBS_FILE" "$LEARNINGS_FILE" "$TS" >/dev/null 2>&1 || true
-elif command -v python3 >/dev/null 2>&1; then
-  python3 - "$OBS_FILE" "$LEARNINGS_FILE" "$TS" <<'PY' >/dev/null 2>&1
-import json
-import re
-import sys
-from collections import Counter
-from pathlib import Path
-
-obs_path = Path(sys.argv[1])
-learnings_path = Path(sys.argv[2])
-timestamp = sys.argv[3]
-
-error_pattern = re.compile(r"(error|fail)", re.IGNORECASE)
-key_pattern = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
-
-observations = []
-for line in obs_path.read_text(encoding="utf-8").splitlines():
-    line = line.strip()
-    if not line:
-        continue
-    try:
-        value = json.loads(line)
-    except Exception:
-        continue
-    if isinstance(value, dict):
-        observations.append(value)
-
-if len(observations) < 5:
-    raise SystemExit(0)
-
-tool_counts: Counter[str] = Counter()
-error_counts: Counter[str] = Counter()
-stage_error_counts: Counter[str] = Counter()
-
-for event in observations:
-    tool = event.get("tool")
-    if not isinstance(tool, str) or not tool:
-        tool = "unknown"
-    stage = event.get("stage")
-    if not isinstance(stage, str) or not stage:
-        stage = "none"
-
-    tool_counts[tool] += 1
-
-    payload = event.get("data")
-    if isinstance(payload, str):
-        payload_text = payload
-    else:
-        try:
-            payload_text = json.dumps(payload, ensure_ascii=False)
-        except Exception:
-            payload_text = ""
-
-    if event.get("event") == "tool_complete" and error_pattern.search(payload_text):
-        error_counts[tool] += 1
-        stage_error_counts[stage] += 1
-
-candidates: list[dict[str, object]] = []
-if error_counts:
-    top_tool, top_count = error_counts.most_common(1)[0]
-    if top_count >= 3:
-        candidates.append({
-            "ts": timestamp,
-            "skill": "observation",
-            "type": "pitfall",
-            "key": f"frequent-errors-{top_tool}",
-            "insight": f"Tool {top_tool} had {top_count} error-like outputs in one session; add a preflight checklist before using it.",
-            "confidence": min(9, 4 + (top_count // 2)),
-            "source": "observed"
-        })
-
-if tool_counts:
-    top_tool, top_total = tool_counts.most_common(1)[0]
-    if top_total >= 8 and error_counts.get(top_tool, 0) <= 1:
-        candidates.append({
-            "ts": timestamp,
-            "skill": "observation",
-            "type": "pattern",
-            "key": f"reliable-tool-{top_tool}",
-            "insight": f"Tool {top_tool} was used {top_total} times with low failure rate; prefer it as first option for similar tasks.",
-            "confidence": min(8, 3 + (top_total // 3)),
-            "source": "observed"
-        })
-
-if stage_error_counts:
-    top_stage, top_stage_count = stage_error_counts.most_common(1)[0]
-    if top_stage != "none" and top_stage_count >= 4:
-        candidates.append({
-            "ts": timestamp,
-            "skill": "observation",
-            "type": "pitfall",
-            "key": f"stage-hotspot-{top_stage}",
-            "insight": f"Stage {top_stage} produced {top_stage_count} error-like tool completions in one session; stage-specific guardrails are needed.",
-            "confidence": min(8, 3 + (top_stage_count // 2)),
-            "source": "observed"
-        })
-
-def is_valid(entry: dict[str, object]) -> bool:
-    ts = entry.get("ts")
-    key = entry.get("key")
-    insight = entry.get("insight")
-    conf = entry.get("confidence")
-    typ = entry.get("type")
-    source = entry.get("source")
-
-    if not isinstance(ts, str) or not ts:
-        return False
-    if not isinstance(key, str) or not key_pattern.match(key):
-        return False
-    if not isinstance(insight, str) or len(insight.strip()) < 16:
-        return False
-    if not isinstance(conf, int) or conf < 1 or conf > 10:
-        return False
-    if typ not in {"pitfall", "pattern", "preference"}:
-        return False
-    if source not in {"observed", "user-stated"}:
-        return False
-    return True
-
-best_existing: dict[str, int] = {}
-if learnings_path.exists():
-    for line in learnings_path.read_text(encoding="utf-8").splitlines():
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            entry = json.loads(line)
-        except Exception:
-            continue
-        if not isinstance(entry, dict):
-            continue
-        key = entry.get("key")
-        typ = entry.get("type")
-        conf = entry.get("confidence")
-        if isinstance(key, str) and isinstance(typ, str) and isinstance(conf, int):
-            token = f"{key}:{typ}"
-            best_existing[token] = max(best_existing.get(token, 0), conf)
-
-appended: list[str] = []
-with learnings_path.open("a", encoding="utf-8") as handle:
-    for candidate in candidates:
-        if not is_valid(candidate):
-            continue
-        token = f"{candidate['key']}:{candidate['type']}"
-        confidence = int(candidate["confidence"])
-        if confidence <= best_existing.get(token, 0):
-            continue
-        handle.write(json.dumps(candidate, ensure_ascii=False) + "\\n")
-        best_existing[token] = confidence
-        appended.append(str(candidate["key"]))
-
-raise SystemExit(0)
-PY
-elif command -v jq >/dev/null 2>&1; then
-  ERROR_PATTERNS=$(jq -r 'select(.event=="tool_complete") | select(.data | test("error|Error|ERROR|fail|Fail|FAIL"; "g")) | .tool' "$OBS_FILE" 2>/dev/null | sort | uniq -c | sort -rn | head -3)
-  if [ -n "$ERROR_PATTERNS" ]; then
-    TOP_ERROR_TOOL=$(echo "$ERROR_PATTERNS" | head -1 | awk '{print $2}')
-    TOP_ERROR_COUNT=$(echo "$ERROR_PATTERNS" | head -1 | awk '{print $1}')
-    if [ "$TOP_ERROR_COUNT" -ge 3 ]; then
-      CANDIDATE=$(jq -n -c \\
-        --arg ts "$TS" \\
-        --arg tool "$TOP_ERROR_TOOL" \\
-        --arg count "$TOP_ERROR_COUNT" \\
-        '{ts:$ts,skill:"observation",type:"pitfall",key:("frequent-errors-"+$tool),insight:("Tool "+$tool+" had "+$count+" error-like outputs in one session; add a preflight checklist before using it."),confidence:(5 + (($count|tonumber) / 2 | floor)),source:"observed"}' 2>/dev/null || echo "")
-      if [ -n "$CANDIDATE" ]; then
-        CANDIDATE=$(echo "$CANDIDATE" | jq -c 'if .confidence > 10 then .confidence = 10 else . end' 2>/dev/null || echo "")
-      fi
-
-      if [ -n "$CANDIDATE" ]; then
-        CANDIDATE_OK=$(echo "$CANDIDATE" | jq -r '
-          (.ts|type=="string") and
-          (.key|type=="string") and
-          (.type|type=="string") and
-          (.insight|type=="string" and (length >= 16)) and
-          (.confidence|type=="number" and . >= 1 and . <= 10) and
-          (.source|type=="string")
-        ' 2>/dev/null || echo "false")
-        if [ "$CANDIDATE_OK" = "true" ]; then
-          CANDIDATE_KEY=$(echo "$CANDIDATE" | jq -r '.key' 2>/dev/null || echo "")
-          CANDIDATE_TYPE=$(echo "$CANDIDATE" | jq -r '.type' 2>/dev/null || echo "")
-          CANDIDATE_CONF=$(echo "$CANDIDATE" | jq -r '.confidence' 2>/dev/null || echo "0")
-          EXISTING_CONF=$(jq -r --arg key "$CANDIDATE_KEY" --arg type "$CANDIDATE_TYPE" '
-            select(.key == $key and .type == $type) | (.confidence // 0)
-          ' "$LEARNINGS_FILE" 2>/dev/null | sort -nr | head -1)
-          [ -n "$EXISTING_CONF" ] || EXISTING_CONF=0
-          if [ "$CANDIDATE_CONF" -gt "$EXISTING_CONF" ]; then
-            printf '%s\\n' "$CANDIDATE" >> "$LEARNINGS_FILE" 2>/dev/null || true
-          fi
-        fi
-      fi
-    fi
-  fi
-fi
-
-# Archive observations (rotate to prevent unbounded growth)
-ARCHIVE_DIR="$ROOT/${RUNTIME_ROOT}/observations.archive"
-mkdir -p "$ARCHIVE_DIR" 2>/dev/null
-ARCHIVE_FILE="$ARCHIVE_DIR/$(date -u +"%Y%m%d-%H%M%S").jsonl"
-cp "$OBS_FILE" "$ARCHIVE_FILE" 2>/dev/null || true
-: > "$OBS_FILE" 2>/dev/null || true
-
-# Retain only the most recent 30 archives.
-ARCHIVE_LIST=$(ls -1t "$ARCHIVE_DIR"/*.jsonl 2>/dev/null || true)
-COUNT=0
-for file in $ARCHIVE_LIST; do
-  COUNT=$((COUNT + 1))
-  if [ "$COUNT" -gt 30 ]; then
-    rm -f "$file" 2>/dev/null || true
-  fi
-done
-
-# Write session digest for cross-session context
-STATE_FILE="$ROOT/${RUNTIME_ROOT}/state/flow-state.json"
-DIGEST_FILE="$ROOT/${RUNTIME_ROOT}/state/session-digest.md"
-STAGE_NOW="none"
-RUN_DIGEST_ID="none"
-if [ -f "$STATE_FILE" ]; then
-  if command -v jq >/dev/null 2>&1; then
-    STAGE_NOW=$(jq -r '.currentStage // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
-    RUN_DIGEST_ID=$(jq -r '.activeRunId // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
-  fi
-fi
-{
-  printf '%s\\n' "# Session Digest"
-  printf '%s\\n' "- Stage: $STAGE_NOW"
-  printf '%s\\n' "- Observations: $OBS_COUNT"
-  printf '%s\\n' "- Timestamp: $TS"
-  printf '%s\\n' "- Run: $RUN_DIGEST_ID"
-} > "$DIGEST_FILE" 2>/dev/null || true
-
-# Keep stage activity bounded by line count.
-rotate_file "$ACTIVITY_FILE" 2000
-
-release_lock
-trap - EXIT INT TERM
-
 exit 0
 `;
 }

package/package.json

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