cclaw-cli 0.5.17 → 0.7.0

package/dist/cli.d.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
-import type { HarnessId } from "./types.js";
+import type { FlowTrack, HarnessId, InitProfile } from "./types.js";
 type CommandName = "init" | "sync" | "doctor" | "upgrade" | "uninstall" | "archive";
 interface ParsedArgs {
     command?: CommandName;
     harnesses?: HarnessId[];
+    track?: FlowTrack;
+    profile?: InitProfile;
     reconcileGates?: boolean;
     archiveName?: string;
     showHelp?: boolean;
@@ -11,5 +13,7 @@ interface ParsedArgs {
 }
 export declare function usage(): string;
 declare function parseHarnesses(raw: string): HarnessId[];
+declare function parseTrack(raw: string): FlowTrack;
+declare function parseProfile(raw: string): InitProfile;
 declare function parseArgs(argv: string[]): ParsedArgs;
-export { parseArgs, parseHarnesses };
+export { parseArgs, parseHarnesses, parseTrack, parseProfile };

package/dist/cli.js

@@ -3,11 +3,12 @@ import { readFileSync, realpathSync } from "node:fs";
 import process from "node:process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { HARNESS_IDS } from "./types.js";
+import { FLOW_TRACKS, HARNESS_IDS, INIT_PROFILES } from "./types.js";
 import { doctorChecks, doctorSucceeded } from "./doctor.js";
 import { initCclaw, syncCclaw, uninstallCclaw, upgradeCclaw } from "./install.js";
 import { error, info } from "./logger.js";
 import { archiveRun } from "./runs.js";
+import { RUNTIME_ROOT } from "./constants.js";
 const INSTALLER_COMMANDS = ["init", "sync", "doctor", "upgrade", "uninstall", "archive"];
 export function usage() {
     return `cclaw - installer-first flow toolkit
@@ -19,7 +20,9 @@ Usage:
 
 Commands:
   init       Bootstrap .cclaw runtime, state, and harness shims in this project.
-             Flags: --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex).
+             Flags: --profile=<id>      Pre-fill defaults. One of: minimal | standard | full. Default: standard.
+                    --harnesses=<list>  Comma list of harnesses (claude,cursor,opencode,codex). Overrides the profile default.
+                    --track=<id>        Flow track for new runs (standard | quick). Overrides the profile default.
   sync       Regenerate harness shim files from the current .cclaw config (non-destructive).
   doctor     Run health checks against the local .cclaw runtime. Exit code 2 on failure.
              Flags: --reconcile-gates   Recompute current-stage gate evidence before checks.
@@ -77,6 +80,20 @@ function parseHarnesses(raw) {
     }
     return requested;
 }
+function parseTrack(raw) {
+    const trimmed = raw.trim();
+    if (!FLOW_TRACKS.includes(trimmed)) {
+        throw new Error(`Unknown track: ${trimmed}. Supported: ${FLOW_TRACKS.join(", ")}`);
+    }
+    return trimmed;
+}
+function parseProfile(raw) {
+    const trimmed = raw.trim();
+    if (!INIT_PROFILES.includes(trimmed)) {
+        throw new Error(`Unknown profile: ${trimmed}. Supported: ${INIT_PROFILES.join(", ")}`);
+    }
+    return trimmed;
+}
 function parseArgs(argv) {
     const parsed = {};
     const helpFlag = argv.find((arg) => arg === "--help" || arg === "-h");
@@ -96,6 +113,14 @@ function parseArgs(argv) {
             parsed.harnesses = parseHarnesses(flag.replace("--harnesses=", ""));
             continue;
         }
+        if (flag.startsWith("--track=")) {
+            parsed.track = parseTrack(flag.replace("--track=", ""));
+            continue;
+        }
+        if (flag.startsWith("--profile=")) {
+            parsed.profile = parseProfile(flag.replace("--profile=", ""));
+            continue;
+        }
         if (flag === "--reconcile-gates") {
             parsed.reconcileGates = true;
             continue;
@@ -123,9 +148,14 @@ async function runCommand(parsed, ctx) {
     if (command === "init") {
         await initCclaw({
             projectRoot: ctx.cwd,
-            harnesses: parsed.harnesses
+            harnesses: parsed.harnesses,
+            track: parsed.track,
+            profile: parsed.profile
         });
-        info(ctx, "Initialized .cclaw runtime and generated harness shims");
+        const profileNote = parsed.profile ? ` profile=${parsed.profile}` : "";
+        const trackNote = parsed.track ? ` track=${parsed.track}` : "";
+        const suffix = profileNote || trackNote ? ` (${(profileNote + trackNote).trim()})` : "";
+        info(ctx, `Initialized .cclaw runtime and generated harness shims${suffix}`);
         return 0;
     }
     if (command === "sync") {
@@ -153,6 +183,16 @@ async function runCommand(parsed, ctx) {
             ? ` Snapshotted ${archived.snapshottedStateFiles.length} state file(s) under ${archived.archivePath}/state and wrote archive-manifest.json.`
             : "";
         info(ctx, `Archived active artifacts to ${archived.archivePath}. Flow state reset to brainstorm.${snapshotSummary}`);
+        const k = archived.knowledge;
+        if (k.overThreshold) {
+            info(ctx, `Knowledge curation recommended: ${k.knowledgePath} now has ${k.activeEntryCount} active entries (soft threshold ${k.softThreshold}). Run \`/cc-learn curate\` to plan a soft-archive of stale/duplicate entries to ${RUNTIME_ROOT}/knowledge.archive.md.`);
+        }
+        else if (k.activeEntryCount > 0) {
+            info(ctx, `Knowledge: ${k.activeEntryCount}/${k.softThreshold} active entries. Run \`/cc-learn curate\` if you want a sweep before the next run.`);
+        }
+        else {
+            info(ctx, `Knowledge: 0 active entries in ${k.knowledgePath}. Capture lessons from this run with \`/cc-learn add\` before they fade.`);
+        }
         return 0;
     }
     await uninstallCclaw(ctx.cwd);
@@ -190,4 +230,4 @@ function isDirectExecution() {
 if (isDirectExecution()) {
     void main();
 }
-export { parseArgs, parseHarnesses };
+export { parseArgs, parseHarnesses, parseTrack, parseProfile };

package/dist/config.d.ts

@@ -1,5 +1,15 @@
-import type { HarnessId, VibyConfig } from "./types.js";
+import type { FlowTrack, HarnessId, InitProfile, LanguageRulePack, VibyConfig } from "./types.js";
 export declare function configPath(projectRoot: string): string;
-export declare function createDefaultConfig(harnesses?: HarnessId[]): VibyConfig;
+export declare function createDefaultConfig(harnesses?: HarnessId[], defaultTrack?: FlowTrack): VibyConfig;
+/**
+ * Build a VibyConfig for a named init profile. Profile defaults are applied
+ * first, then any explicit overrides (CLI flags) win. This keeps the profile
+ * contract deterministic and testable.
+ */
+export declare function createProfileConfig(profile: InitProfile, overrides?: {
+    harnesses?: HarnessId[];
+    defaultTrack?: FlowTrack;
+    languageRulePacks?: LanguageRulePack[];
+}): VibyConfig;
 export declare function readConfig(projectRoot: string): Promise<VibyConfig>;
 export declare function writeConfig(projectRoot: string, config: VibyConfig): Promise<void>;

package/dist/config.js

@@ -3,17 +3,23 @@ import path from "node:path";
 import { parse, stringify } from "yaml";
 import { CCLAW_VERSION, DEFAULT_HARNESSES, FLOW_VERSION, RUNTIME_ROOT } from "./constants.js";
 import { exists, writeFileSafe } from "./fs-utils.js";
-import { HARNESS_IDS } from "./types.js";
+import { FLOW_TRACKS, HARNESS_IDS, LANGUAGE_RULE_PACKS } from "./types.js";
 const CONFIG_PATH = `${RUNTIME_ROOT}/config.yaml`;
 const HARNESS_ID_SET = new Set(HARNESS_IDS);
+const FLOW_TRACK_SET = new Set(FLOW_TRACKS);
+const LANGUAGE_RULE_PACK_SET = new Set(LANGUAGE_RULE_PACKS);
 const SUPPORTED_HARNESSES_TEXT = HARNESS_IDS.join(", ");
+const SUPPORTED_TRACKS_TEXT = FLOW_TRACKS.join(", ");
+const SUPPORTED_LANGUAGE_RULE_PACKS_TEXT = LANGUAGE_RULE_PACKS.join(", ");
 const ALLOWED_CONFIG_KEYS = new Set([
     "version",
     "flowVersion",
     "harnesses",
     "autoAdvance",
     "promptGuardMode",
-    "gitHookGuards"
+    "gitHookGuards",
+    "defaultTrack",
+    "languageRulePacks"
 ]);
 function configFixExample() {
     return `harnesses:
@@ -23,22 +29,66 @@ function configFixExample() {
 function configValidationError(configFilePath, reason) {
     return new Error(`Invalid cclaw config at ${configFilePath}: ${reason}\n` +
         `Supported harnesses: ${SUPPORTED_HARNESSES_TEXT}\n` +
+        `Supported tracks: ${SUPPORTED_TRACKS_TEXT}\n` +
+        `Supported languageRulePacks: ${SUPPORTED_LANGUAGE_RULE_PACKS_TEXT}\n` +
         `Example config:\n${configFixExample()}\n` +
         `After fixing, run: cclaw sync`);
 }
 export function configPath(projectRoot) {
     return path.join(projectRoot, CONFIG_PATH);
 }
-export function createDefaultConfig(harnesses = DEFAULT_HARNESSES) {
+export function createDefaultConfig(harnesses = DEFAULT_HARNESSES, defaultTrack = "standard") {
     return {
         version: CCLAW_VERSION,
         flowVersion: FLOW_VERSION,
         harnesses,
         autoAdvance: false,
         promptGuardMode: "advisory",
-        gitHookGuards: false
+        gitHookGuards: false,
+        defaultTrack,
+        languageRulePacks: []
     };
 }
+/**
+ * Build a VibyConfig for a named init profile. Profile defaults are applied
+ * first, then any explicit overrides (CLI flags) win. This keeps the profile
+ * contract deterministic and testable.
+ */
+export function createProfileConfig(profile, overrides = {}) {
+    const base = createDefaultConfig();
+    switch (profile) {
+        case "minimal":
+            return {
+                ...base,
+                harnesses: overrides.harnesses ?? ["claude"],
+                autoAdvance: false,
+                promptGuardMode: "advisory",
+                gitHookGuards: false,
+                defaultTrack: overrides.defaultTrack ?? "quick",
+                languageRulePacks: overrides.languageRulePacks ?? []
+            };
+        case "standard":
+            return {
+                ...base,
+                harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
+                autoAdvance: false,
+                promptGuardMode: "advisory",
+                gitHookGuards: false,
+                defaultTrack: overrides.defaultTrack ?? "standard",
+                languageRulePacks: overrides.languageRulePacks ?? []
+            };
+        case "full":
+            return {
+                ...base,
+                harnesses: overrides.harnesses ?? DEFAULT_HARNESSES,
+                autoAdvance: false,
+                promptGuardMode: "strict",
+                gitHookGuards: true,
+                defaultTrack: overrides.defaultTrack ?? "standard",
+                languageRulePacks: overrides.languageRulePacks ?? [...LANGUAGE_RULE_PACKS]
+            };
+    }
+}
 export async function readConfig(projectRoot) {
     const fullPath = configPath(projectRoot);
     if (!(await exists(fullPath))) {
@@ -89,13 +139,37 @@ export async function readConfig(projectRoot) {
         throw configValidationError(fullPath, `"gitHookGuards" must be a boolean`);
     }
     const gitHookGuards = typeof gitHookGuardsRaw === "boolean" ? gitHookGuardsRaw : false;
+    const defaultTrackRaw = parsed.defaultTrack;
+    if (Object.prototype.hasOwnProperty.call(parsed, "defaultTrack") &&
+        (typeof defaultTrackRaw !== "string" || !FLOW_TRACK_SET.has(defaultTrackRaw))) {
+        throw configValidationError(fullPath, `"defaultTrack" must be one of: ${SUPPORTED_TRACKS_TEXT}`);
+    }
+    const defaultTrack = typeof defaultTrackRaw === "string" && FLOW_TRACK_SET.has(defaultTrackRaw)
+        ? defaultTrackRaw
+        : "standard";
+    const languageRulePacksRaw = parsed.languageRulePacks;
+    const hasLanguageRulePacksField = Object.prototype.hasOwnProperty.call(parsed, "languageRulePacks");
+    if (hasLanguageRulePacksField && !Array.isArray(languageRulePacksRaw)) {
+        throw configValidationError(fullPath, `"languageRulePacks" must be an array`);
+    }
+    const rawPacks = (languageRulePacksRaw ?? []);
+    const invalidPacks = rawPacks.filter((pack) => typeof pack !== "string" || !LANGUAGE_RULE_PACK_SET.has(pack));
+    if (invalidPacks.length > 0) {
+        const formatted = invalidPacks
+            .map((item) => (typeof item === "string" ? item : JSON.stringify(item)))
+            .join(", ");
+        throw configValidationError(fullPath, `unknown languageRulePacks id(s): ${formatted}`);
+    }
+    const languageRulePacks = [...new Set(rawPacks)];
     return {
         version: parsed.version ?? CCLAW_VERSION,
         flowVersion: parsed.flowVersion ?? FLOW_VERSION,
         harnesses,
         autoAdvance,
         promptGuardMode,
-        gitHookGuards
+        gitHookGuards,
+        defaultTrack,
+        languageRulePacks
     };
 }
 export async function writeConfig(projectRoot, config) {

package/dist/constants.d.ts

@@ -4,9 +4,9 @@ export declare const RUNTIME_ROOT = ".cclaw";
 export declare const CCLAW_VERSION = "0.1.1";
 export declare const FLOW_VERSION = "1.0.0";
 export declare const DEFAULT_HARNESSES: HarnessId[];
-export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks"];
+export declare const REQUIRED_DIRS: readonly [".cclaw", ".cclaw/commands", ".cclaw/skills", ".cclaw/contexts", ".cclaw/templates", ".cclaw/artifacts", ".cclaw/state", ".cclaw/runs", ".cclaw/rules", ".cclaw/adapters", ".cclaw/agents", ".cclaw/hooks", ".cclaw/custom-skills"];
 export declare const REQUIRED_GITIGNORE_PATTERNS: readonly ["# cclaw generated artifacts", ".cclaw/", ".claude/commands/cc-*.md", ".claude/commands/cc.md", ".cursor/commands/cc-*.md", ".cursor/commands/cc.md", ".opencode/commands/cc-*.md", ".opencode/commands/cc.md", ".codex/commands/cc-*.md", ".codex/commands/cc.md", ".claude/hooks/hooks.json", ".cursor/hooks.json", ".codex/hooks.json", ".opencode/plugins/cclaw-plugin.mjs", ".cursor/rules/cclaw-workflow.mdc"];
 export declare const COMMAND_FILE_ORDER: FlowStage[];
-export declare const UTILITY_COMMANDS: readonly ["learn", "next"];
+export declare const UTILITY_COMMANDS: readonly ["learn", "next", "status"];
 export declare const SUBAGENT_SKILL_FOLDERS: readonly ["subagent-dev", "parallel-dispatch"];
 export type UtilityCommand = (typeof UTILITY_COMMANDS)[number];

package/dist/constants.js

@@ -20,7 +20,8 @@ export const REQUIRED_DIRS = [
     `${RUNTIME_ROOT}/rules`,
     `${RUNTIME_ROOT}/adapters`,
     `${RUNTIME_ROOT}/agents`,
-    `${RUNTIME_ROOT}/hooks`
+    `${RUNTIME_ROOT}/hooks`,
+    `${RUNTIME_ROOT}/custom-skills`
 ];
 export const REQUIRED_GITIGNORE_PATTERNS = [
     "# cclaw generated artifacts",
@@ -49,7 +50,7 @@ export const COMMAND_FILE_ORDER = [
     "review",
     "ship"
 ];
-export const UTILITY_COMMANDS = ["learn", "next"];
+export const UTILITY_COMMANDS = ["learn", "next", "status"];
 export const SUBAGENT_SKILL_FOLDERS = [
     "subagent-dev",
     "parallel-dispatch"

package/dist/content/hooks.d.ts

@@ -11,6 +11,7 @@ export interface HookRuntimeOptions {
 export declare const RUNTIME_SHELL_DETECT_ROOT = "HARNESS=\"codex\"\nif [ -n \"${CLAUDE_PROJECT_DIR:-}\" ]; then\n  HARNESS=\"claude\"\nelif [ -n \"${CURSOR_PROJECT_DIR:-}\" ] || [ -n \"${CURSOR_PROJECT_ROOT:-}\" ]; then\n  HARNESS=\"cursor\"\nelif [ -n \"${OPENCODE_PROJECT_DIR:-}\" ] || [ -n \"${OPENCODE_PROJECT_ROOT:-}\" ]; then\n  HARNESS=\"opencode\"\nfi\n\nROOT=\"\"\nfor candidate in \"${CCLAW_PROJECT_ROOT:-}\" \"${CLAUDE_PROJECT_DIR:-}\" \"${CURSOR_PROJECT_DIR:-}\" \"${CURSOR_PROJECT_ROOT:-}\" \"${OPENCODE_PROJECT_DIR:-}\" \"${OPENCODE_PROJECT_ROOT:-}\" \"${PWD:-}\"; do\n  if [ -n \"$candidate\" ] && [ -d \"$candidate/.cclaw\" ]; then\n    ROOT=\"$candidate\"\n    break\n  fi\ndone\nif [ -z \"$ROOT\" ]; then\n  ROOT=\"${CCLAW_PROJECT_ROOT:-${CLAUDE_PROJECT_DIR:-${CURSOR_PROJECT_DIR:-${CURSOR_PROJECT_ROOT:-${OPENCODE_PROJECT_DIR:-${OPENCODE_PROJECT_ROOT:-${PWD}}}}}}}\"\nfi";
 export declare function sessionStartScript(_options?: HookRuntimeOptions): string;
 export declare function stopCheckpointScript(): string;
+export declare function preCompactScript(): string;
 export { claudeHooksJsonWithObservation as claudeHooksJson } from "./observe.js";
 export { cursorHooksJsonWithObservation as cursorHooksJson } from "./observe.js";
 export { codexHooksJsonWithObservation as codexHooksJson } from "./observe.js";

package/dist/content/hooks.js

@@ -616,6 +616,151 @@ case "$HARNESS" in
 esac
 `;
 }
+export function preCompactScript() {
+    return `#!/usr/bin/env bash
+# cclaw pre-compact hook — generated by cclaw sync
+# Persists a session digest before the harness compacts/clears context, so the
+# next session-start hook can restore the most important state without the agent
+# having to re-derive it from scratch.
+set -uo pipefail
+
+${DETECT_ROOT}
+
+INPUT=$(cat 2>/dev/null || echo '{}')
+
+STATE_DIR="$ROOT/${RUNTIME_ROOT}/state"
+STATE_FILE="$STATE_DIR/flow-state.json"
+DELEGATION_FILE="$STATE_DIR/delegation-log.json"
+KNOWLEDGE_FILE="$ROOT/${RUNTIME_ROOT}/knowledge.md"
+DIGEST_FILE="$STATE_DIR/session-digest.md"
+DIGEST_TMP="$STATE_DIR/session-digest.md.tmp.$$"
+
+mkdir -p "$STATE_DIR" 2>/dev/null || true
+
+cleanup_digest_tmp() {
+  rm -f "$DIGEST_TMP" 2>/dev/null || true
+}
+trap cleanup_digest_tmp EXIT INT TERM
+
+STAGE="none"
+TRACK="standard"
+COMPLETED="0"
+SKIPPED=""
+ACTIVE_RUN="none"
+PASSED_GATES=""
+BLOCKED_GATES=""
+
+if [ -f "$STATE_FILE" ]; then
+  if command -v jq >/dev/null 2>&1; then
+    STAGE=$(jq -r '.currentStage // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
+    TRACK=$(jq -r '.track // "standard"' "$STATE_FILE" 2>/dev/null || echo "standard")
+    COMPLETED=$(jq -r '(.completedStages // []) | length' "$STATE_FILE" 2>/dev/null || echo "0")
+    SKIPPED=$(jq -r '(.skippedStages // []) | join(",")' "$STATE_FILE" 2>/dev/null || echo "")
+    ACTIVE_RUN=$(jq -r '.activeRunId // "none"' "$STATE_FILE" 2>/dev/null || echo "none")
+    PASSED_GATES=$(jq -r --arg stage "$STAGE" '(.stageGates[$stage].passed // []) | join(",")' "$STATE_FILE" 2>/dev/null || echo "")
+    BLOCKED_GATES=$(jq -r --arg stage "$STAGE" '(.stageGates[$stage].blocked // []) | join(",")' "$STATE_FILE" 2>/dev/null || echo "")
+  elif command -v python3 >/dev/null 2>&1; then
+    OUTPUT=$(python3 - "$STATE_FILE" <<'PY'
+import json, sys
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+except Exception:
+    data = {}
+stage = data.get("currentStage") or "none"
+track = data.get("track") or "standard"
+completed = data.get("completedStages") or []
+skipped = data.get("skippedStages") or []
+run = data.get("activeRunId") or "none"
+gates = (data.get("stageGates") or {}).get(stage) or {}
+passed = gates.get("passed") or []
+blocked = gates.get("blocked") or []
+print(stage)
+print(track)
+print(len(completed) if isinstance(completed, list) else 0)
+print(",".join(skipped) if isinstance(skipped, list) else "")
+print(run)
+print(",".join(passed) if isinstance(passed, list) else "")
+print(",".join(blocked) if isinstance(blocked, list) else "")
+PY
+)
+    {
+      IFS= read -r STAGE
+      IFS= read -r TRACK
+      IFS= read -r COMPLETED
+      IFS= read -r SKIPPED
+      IFS= read -r ACTIVE_RUN
+      IFS= read -r PASSED_GATES
+      IFS= read -r BLOCKED_GATES
+    } <<EOF
+$OUTPUT
+EOF
+  fi
+fi
+
+DELEGATION_PENDING=""
+if [ -f "$DELEGATION_FILE" ] && command -v jq >/dev/null 2>&1; then
+  DELEGATION_PENDING=$(jq -r --arg stage "$STAGE" '
+    (.entries // [])
+    | map(select((.stage // "") == $stage and (.status // "") != "completed" and (.status // "") != "waived"))
+    | map(.agent // "unknown")
+    | unique
+    | join(",")
+  ' "$DELEGATION_FILE" 2>/dev/null || echo "")
+fi
+
+KNOWLEDGE_TAIL=""
+if [ -f "$KNOWLEDGE_FILE" ] && [ -s "$KNOWLEDGE_FILE" ]; then
+  KNOWLEDGE_TAIL=$(tail -n 12 "$KNOWLEDGE_FILE" 2>/dev/null || echo "")
+fi
+
+GIT_HEAD=""
+GIT_BRANCH=""
+GIT_DIRTY="unknown"
+if command -v git >/dev/null 2>&1 && git -C "$ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  GIT_HEAD=$(git -C "$ROOT" rev-parse --short HEAD 2>/dev/null || echo "")
+  GIT_BRANCH=$(git -C "$ROOT" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
+  if [ -n "$(git -C "$ROOT" status --porcelain 2>/dev/null)" ]; then
+    GIT_DIRTY="dirty"
+  else
+    GIT_DIRTY="clean"
+  fi
+fi
+
+TS=$(date -u +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || echo "")
+
+{
+  printf '# Session Digest\n'
+  printf '_Generated by pre-compact hook at %s_\n\n' "$TS"
+  printf '## Flow snapshot\n'
+  printf '- track: %s\n' "$TRACK"
+  printf '- current stage: %s\n' "$STAGE"
+  printf '- completed: %s stages\n' "$COMPLETED"
+  printf '- skipped: %s\n' "\${SKIPPED:-(none)}"
+  printf '- run: %s\n\n' "$ACTIVE_RUN"
+  printf '## Gates (current stage)\n'
+  printf '- passed: %s\n' "\${PASSED_GATES:-(none)}"
+  printf '- blocked: %s\n\n' "\${BLOCKED_GATES:-(none)}"
+  printf '## Outstanding delegations\n'
+  printf '- pending: %s\n\n' "\${DELEGATION_PENDING:-(none)}"
+  printf '## Git\n'
+  printf '- branch: %s\n' "\${GIT_BRANCH:-(unknown)}"
+  printf '- head: %s\n' "\${GIT_HEAD:-(unknown)}"
+  printf '- worktree: %s\n\n' "$GIT_DIRTY"
+  if [ -n "$KNOWLEDGE_TAIL" ]; then
+    printf '## Knowledge tail\n'
+    printf '%s\n' "$KNOWLEDGE_TAIL"
+  fi
+} > "$DIGEST_TMP" 2>/dev/null || true
+
+if [ -s "$DIGEST_TMP" ]; then
+  mv "$DIGEST_TMP" "$DIGEST_FILE" 2>/dev/null || rm -f "$DIGEST_TMP" 2>/dev/null || true
+fi
+
+trap - EXIT INT TERM
+exit 0
+`;
+}
 // ---------------------------------------------------------------------------
 // hooks.json generators are defined in observe.ts (shared across harnesses).
 // ---------------------------------------------------------------------------