@theglitchking/semantic-memory 1.6.1 → 1.7.1

package/dist/{profile-SIWAVD7O.js → profile-SNULTJ27.js}

@@ -5,11 +5,11 @@ import {
   readSpeakerProfile,
   speakerProfileTemplate,
   updateProfileSection
-} from "./chunk-ZLIHQZ4C.js";
-import "./chunk-HZ7B5KHY.js";
+} from "./chunk-6TIKWOY4.js";
+import "./chunk-EXAUVIGW.js";
 import "./chunk-EYVFC745.js";
-import "./chunk-H2BES6FU.js";
 import "./chunk-J7LYDRML.js";
+import "./chunk-H2BES6FU.js";
 import "./chunk-PZ5AY32C.js";
 export {
   PROFILE_SECTIONS,
@@ -19,4 +19,4 @@ export {
   speakerProfileTemplate,
   updateProfileSection
 };
-//# sourceMappingURL=profile-SIWAVD7O.js.map
+//# sourceMappingURL=profile-SNULTJ27.js.map

package/dist/profile-SNULTJ27.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{schema-UJNYYRZZ.js → schema-RDYUK6CC.js}

@@ -2,7 +2,7 @@ import {
   installDefaultSchema,
   loadSchema,
   validateNote
-} from "./chunk-HUG7E25D.js";
+} from "./chunk-Y7H76Q7F.js";
 import "./chunk-J7LYDRML.js";
 import "./chunk-PZ5AY32C.js";
 export {
@@ -10,4 +10,4 @@ export {
   loadSchema,
   validateNote
 };
-//# sourceMappingURL=schema-UJNYYRZZ.js.map
+//# sourceMappingURL=schema-RDYUK6CC.js.map

package/dist/schema-RDYUK6CC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skill-curator-D7HHZaUI.d.ts

@@ -0,0 +1,71 @@
+type LedgerAction = "land" | "patch" | "stale" | "archive" | "restore" | "promote" | "merge" | "reject" | "rollback";
+interface FileChange {
+    path: string;
+    /** sha256 of the bytes before (null: the file did not exist) */
+    before: string | null;
+    after: string | null;
+}
+interface LedgerEntry {
+    id: string;
+    ts: string;
+    action: LedgerAction;
+    actor: "user" | "curator" | "reviewer";
+    skill: string;
+    why: string;
+    files: FileChange[];
+    /** rollback: the entry it reversed */
+    reverts?: string;
+}
+declare function readLedger(repo: string): LedgerEntry[];
+/** Undo one entry: every file it touched goes back to its exact bytes before (or aside, if it did not exist). */
+declare function rollback(repo: string, id: string): LedgerEntry;
+
+declare const STALE_DAYS = 14;
+declare const ARCHIVE_DAYS = 30;
+declare const CURATOR_INTERVAL_DAYS = 7;
+declare const IDLE_HOURS = 2;
+declare const curatorStatePath: (repo: string) => string;
+interface CuratorState {
+    first_seen?: string;
+    last_run?: string;
+    last_report?: string;
+    flagged?: {
+        name: string;
+        reason: string;
+        at: string;
+    }[];
+}
+declare function readState(repo: string): CuratorState;
+interface CuratorAction {
+    skill: string;
+    path: string;
+    action: "stale" | "archive" | "reactivate" | "keep" | "skip";
+    why: string;
+}
+declare function plan(repo: string, now?: number, env?: NodeJS.ProcessEnv): CuratorAction[];
+/** Run the curator. Dry run: report only. Returns the actions (and the ledger ids of the changes made). */
+declare function curate(repo: string, opts?: {
+    dryRun?: boolean;
+    now?: number;
+    env?: NodeJS.ProcessEnv;
+}): {
+    actions: CuratorAction[];
+    ledger: string[];
+};
+/** Whether SessionStart should start the curator now (and records first sight of the repo). */
+declare function curatorDue(repo: string, now?: number): boolean;
+/** Bring an archived skill back where it was, active again. */
+declare function restore(repo: string, name: string): LedgerEntry;
+declare function listArchived(repo: string): string[];
+/** Run each landed learned skill's Verify command (they were approved by a person); flag failures, archive nothing. */
+declare function verifySkills(repo: string, opts?: {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}): {
+    skill: string;
+    result: "pass" | "fail" | "prose" | "none";
+    detail: string;
+}[];
+declare const curatorState: typeof readState;
+
+export { ARCHIVE_DAYS as A, CURATOR_INTERVAL_DAYS as C, IDLE_HOURS as I, type LedgerEntry as L, STALE_DAYS as S, restore as a, rollback as b, curate as c, type CuratorAction as d, curatorDue as e, curatorState as f, curatorStatePath as g, listArchived as l, plan as p, readLedger as r, verifySkills as v };

package/dist/skill-land-EHXZW47F.js

@@ -0,0 +1,31 @@
+import {
+  approveDraft,
+  describeDrafts,
+  destinationFor,
+  evalDraft,
+  rejectDraft,
+  reviewedPrompts
+} from "./chunk-3ML5ESXI.js";
+import "./chunk-2BFG4IBC.js";
+import "./chunk-TKHWVISV.js";
+import "./chunk-N77YCMSX.js";
+import "./chunk-BSXIGPDY.js";
+import "./chunk-MTLYF357.js";
+import "./chunk-PMOZKUEM.js";
+import "./chunk-ZSWI3Y4Y.js";
+import "./chunk-J7LYDRML.js";
+import "./chunk-VQCNWRTL.js";
+import "./chunk-GYR7U6KA.js";
+import "./chunk-M2PC64DB.js";
+import "./chunk-R6GNP7DS.js";
+import "./chunk-H2BES6FU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  approveDraft,
+  describeDrafts,
+  destinationFor,
+  evalDraft,
+  rejectDraft,
+  reviewedPrompts
+};
+//# sourceMappingURL=skill-land-EHXZW47F.js.map

package/dist/skill-land-EHXZW47F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skill-ledger-AYXVNFX7.js

@@ -0,0 +1,18 @@
+import {
+  applyChange,
+  archiveDir,
+  ledgerPath,
+  readLedger,
+  rollback
+} from "./chunk-TKHWVISV.js";
+import "./chunk-R6GNP7DS.js";
+import "./chunk-H2BES6FU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  applyChange,
+  archiveDir,
+  ledgerPath,
+  readLedger,
+  rollback
+};
+//# sourceMappingURL=skill-ledger-AYXVNFX7.js.map

package/dist/skill-ledger-AYXVNFX7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skill-merge-HBZBALZX.js

@@ -0,0 +1,24 @@
+import {
+  MERGE_MIN_OVERLAP,
+  consolidateOn,
+  mergeCandidates,
+  proposeMerges
+} from "./chunk-2OMDSTSS.js";
+import "./chunk-2BFG4IBC.js";
+import "./chunk-N77YCMSX.js";
+import "./chunk-PMOZKUEM.js";
+import "./chunk-ZSWI3Y4Y.js";
+import "./chunk-J7LYDRML.js";
+import "./chunk-VQCNWRTL.js";
+import "./chunk-GYR7U6KA.js";
+import "./chunk-M2PC64DB.js";
+import "./chunk-R6GNP7DS.js";
+import "./chunk-H2BES6FU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  MERGE_MIN_OVERLAP,
+  consolidateOn,
+  mergeCandidates,
+  proposeMerges
+};
+//# sourceMappingURL=skill-merge-HBZBALZX.js.map

package/dist/skill-merge-HBZBALZX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skill-review-BNvHipn9.d.ts

@@ -0,0 +1,182 @@
+import { ReviewJob } from './core/skill-queue.js';
+import { ReviewOutcome } from './core/skill-worker.js';
+
+declare const SKILL_SCOPES: readonly ["directory", "project", "global"];
+declare const SKILL_STATUSES: readonly ["draft", "active", "stale", "archived"];
+declare const SKILL_SECTIONS: readonly ["When to use", "Steps", "Pitfalls", "Verify"];
+type SkillScope = (typeof SKILL_SCOPES)[number];
+type SkillStatus = (typeof SKILL_STATUSES)[number];
+interface SkillLoopMeta {
+    schema: 1;
+    scope: SkillScope;
+    status: SkillStatus;
+    pinned: boolean;
+    triggers: string[];
+    applies_to: {
+        paths: string[];
+        commands: string[];
+    };
+    provenance: {
+        sessions: string[];
+        failures: string[];
+        corrections: string[];
+    };
+    cites: string[];
+    supersedes: string[];
+}
+interface ParsedSkill {
+    name: string;
+    description: string;
+    /** null when the file has no `skill_loop:` block: not a learned skill */
+    meta: SkillLoopMeta | null;
+    /** the raw `skill_loop` value, for lint messages on a malformed block */
+    rawMeta: unknown;
+    body: string;
+    /** `## ` headings in the body, in order */
+    sections: string[];
+    frontmatter: Record<string, unknown>;
+}
+declare function parseSkill(raw: string): ParsedSkill;
+/** A learned skill's SKILL.md text. Field order is fixed so a re-render of an unchanged skill is byte-identical. */
+declare function renderSkill(skill: {
+    name: string;
+    description: string;
+    meta: SkillLoopMeta;
+    body: string;
+    extra?: Record<string, unknown>;
+}): string;
+interface SkillFile {
+    path: string;
+    /** directory holding SKILL.md; its basename is the skill's name in Claude Code */
+    dir: string;
+    scope: SkillScope;
+    learned: boolean;
+    skill: ParsedSkill;
+}
+/** Every skill Claude Code would load for this repo: directory, project and global scope. */
+declare function findSkills(projectRoot: string, opts?: {
+    home?: string;
+    global?: boolean;
+}): SkillFile[];
+interface SkillFinding {
+    path: string;
+    rule: "frontmatter" | "name" | "description" | "skill_loop" | "provenance" | "sections" | "cites" | "applies_to" | "secrets" | "name_clash";
+    severity: "error" | "warn";
+    message: string;
+}
+interface SkillLintContext {
+    /** repo root the skill belongs to (applies_to paths resolve against it) */
+    projectRoot: string;
+    facts?: Set<string>;
+    /** every other skill Claude Code would load alongside (for name clashes) */
+    others?: SkillFile[];
+}
+/** Lint one learned skill. `dirName` is the folder name Claude Code will use (defaults to the skill's name). */
+declare function lintSkill(path: string, raw: string, ctx: SkillLintContext, dirName?: string): SkillFinding[];
+/** Lint every learned skill this repo would load (and its drafts, when given). */
+declare function lintSkills(projectRoot: string, opts?: {
+    home?: string;
+    extra?: string[];
+}): {
+    files: number;
+    findings: SkillFinding[];
+};
+
+interface ScopeDecision {
+    scope: Exclude<SkillScope, "global">;
+    /** directory scope: the subdirectory (repo-relative) */
+    directory?: string;
+    /** Jev said this holds in any repo: offer promotion once another repo has it too */
+    globalCandidate: boolean;
+    why: string;
+}
+declare function decideScope(repo: string, draft: {
+    name: string;
+    description: string;
+    body: string;
+    applies_to?: {
+        paths?: string[];
+    };
+}, env?: NodeJS.ProcessEnv): Promise<ScopeDecision>;
+
+declare const draftsDir: (repo: string) => string;
+interface DraftRecord {
+    id: string;
+    kind: "new" | "patch" | "merge";
+    name: string;
+    scope: SkillScope;
+    /** patch: the SKILL.md it replaces, and that file's sha256 when the draft was made */
+    target?: string;
+    base_sha256?: string;
+    session_id: string;
+    created: string;
+    warnings: string[];
+    /** directory scope: where it lands (repo-relative subdirectory) */
+    directory?: string;
+    scope_why?: string;
+    /** Jev thinks it holds in any repo */
+    global_candidate?: boolean;
+    /** other repos with the same lesson: review offers one global skill replacing the copies */
+    promotion?: {
+        repo: string;
+        path: string;
+    }[];
+    /** merge: the SKILL.md files the merged skill replaces (archived when it lands) */
+    supersedes?: string[];
+    /** filled by skill evals (Phase 14) when they run at approval time */
+    evals?: Record<string, unknown>;
+}
+/**
+ * The session's timeline from its transcript: prompts, tool calls, and the errors they returned. Fail-soft.
+ * `since`: only entries after it (a follow-up review of a resumed session).
+ */
+declare function transcriptTimeline(path: string | null, max?: number, since?: string): string[];
+declare function buildBrief(job: ReviewJob, skills?: SkillFile[]): string;
+interface ReviewerDraft {
+    kind: "new" | "patch";
+    target?: string;
+    name: string;
+    description: string;
+    scope: string;
+    applies_to?: {
+        paths?: string[];
+        commands?: string[];
+    };
+    triggers?: string[];
+    provenance?: {
+        sessions?: string[];
+        failures?: string[];
+        corrections?: string[];
+    };
+    cites?: string[];
+    body: string;
+}
+/** The JSON object in the reviewer's answer (bare, or inside a ```json fence). */
+declare function parseReviewerJson(text: string): {
+    drafts: ReviewerDraft[];
+    none_reason?: string;
+} | null;
+type ScopeResolver = (d: ReviewerDraft) => Promise<ScopeDecision>;
+/**
+ * Turn one reviewer draft into a draft folder, or say why not. `resolveScope` decides the final scope
+ * (skill-scope.ts: deterministic rules, then Jev); the reviewer's own choice is never trusted for it.
+ */
+declare function materializeDraft(repo: string, job: ReviewJob, d: ReviewerDraft, skills: SkillFile[], resolveScope?: ScopeResolver, env?: NodeJS.ProcessEnv, merge?: {
+    supersedes: string[];
+}): Promise<{
+    id?: string;
+    rejected?: string;
+}>;
+declare function listDrafts(repo: string): {
+    dir: string;
+    record: DraftRecord;
+}[];
+interface ReviewOptions {
+    env?: NodeJS.ProcessEnv;
+    resolveScope?: ScopeResolver;
+    maxTurns?: number;
+}
+/** Review one queued session (the worker's review function). */
+declare function reviewSession(job: ReviewJob, opts?: ReviewOptions): Promise<ReviewOutcome>;
+
+export { type DraftRecord as D, type ParsedSkill as P, type ReviewOptions as R, type SkillLoopMeta as S, SKILL_SCOPES as a, SKILL_SECTIONS as b, SKILL_STATUSES as c, type SkillFile as d, type SkillFinding as e, type SkillScope as f, type SkillStatus as g, buildBrief as h, decideScope as i, draftsDir as j, findSkills as k, lintSkill as l, lintSkills as m, listDrafts as n, reviewSession as o, parseSkill as p, type ReviewerDraft as q, renderSkill as r, type ScopeResolver as s, materializeDraft as t, parseReviewerJson as u, transcriptTimeline as v };

package/dist/skill-schema-RVB3EHEF.js

@@ -0,0 +1,30 @@
+import {
+  GENERATED_BY,
+  SKILL_SCOPES,
+  SKILL_SECTIONS,
+  SKILL_STATUSES,
+  factIds,
+  findSkills,
+  isLearned,
+  lintSkill,
+  lintSkills,
+  parseSkill,
+  renderSkill
+} from "./chunk-ZSWI3Y4Y.js";
+import "./chunk-J7LYDRML.js";
+import "./chunk-H2BES6FU.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  GENERATED_BY,
+  SKILL_SCOPES,
+  SKILL_SECTIONS,
+  SKILL_STATUSES,
+  factIds,
+  findSkills,
+  isLearned,
+  lintSkill,
+  lintSkills,
+  parseSkill,
+  renderSkill
+};
+//# sourceMappingURL=skill-schema-RVB3EHEF.js.map

package/dist/skill-schema-RVB3EHEF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "semantic-sidekick activation + mode hooks. SessionStart reconciles .mcp.json + resets mode + preloads vault context. UserPromptSubmit injects vault search results (mode-aware, fingerprinted). Stop emits mode-specific transition-capture prompts (research\u2192synthesis, outage\u2192postmortem, vault-first\u2192generic capture). PostToolUseFailure (opt-in, SEMANTIC_MEMORY_FAILURE_HOOK=1) looks up a knowledge-base fact for a failed Bash/MCP call.",
+  "description": "semantic-sidekick activation + mode hooks. SessionStart reconciles .mcp.json + resets mode + preloads vault context. UserPromptSubmit injects vault search results (mode-aware, fingerprinted). Stop emits mode-specific transition-capture prompts (research\u2192synthesis, outage\u2192postmortem, vault-first\u2192generic capture). PostToolUseFailure (opt-in, SEMANTIC_MEMORY_FAILURE_HOOK=1) looks up a knowledge-base fact for a failed Bash/MCP call. PostToolUse (Skill) and SessionEnd feed the skill loop (v1.7, off by default: SEMANTIC_MEMORY_SKILL_LOOP=1).",
   "hooks": {
     "SessionStart": [
       {
@@ -11,6 +11,10 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/vault-context.js\""
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/skill-loop.js\""
           }
         ]
       }
@@ -45,6 +49,27 @@
           }
         ]
       }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/skill-loop.js\""
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/skill-loop.js\""
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/jev-bridge.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""semantic-memory → Jev, through jev-loop's router (v1.7 jev mode). Stdlib only.
+
+    echo '{"cwd": "...", "caller": "semantic-memory-judge", "state": "...",
+           "questions": [{"key": "a", "instructions": "..."}]}' | python3 jev-bridge.py
+
+Prints one JSON line: {"scores": {key: probability}, "tokens": n} or {"scores": {}, "error": "..."}.
+Never raises, never exits non-zero: every failure is an empty answer with a reason.
+
+The only way semantic-memory reaches TypeSafe is `router.ask`, which redacts the state and every
+question (redact.py), caches answers, writes the usage ledger under the caller's name and enforces the
+batch budget. This file never builds a request itself and never prints the key.
+
+Callers: semantic-memory-hook (the failure hook) and semantic-memory-judge / semantic-memory-skill-loop.
+jev-loop counts all three as batch (capped and cached) until it lists semantic-memory-hook as live. The
+hook caller has its own daily ceiling here, SEMANTIC_MEMORY_JEV_DAILY_TOKENS (default 500000).
+"""
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+CALLERS = {"semantic-memory-hook", "semantic-memory-judge", "semantic-memory-skill-loop"}
+LIVE_CALLER = "semantic-memory-hook"
+
+
+def out(obj):
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def live_tokens_today(logs, caller):
+    """Tokens this caller spent today, from jev-loop's usage ledger (numbers only)."""
+    day, used = datetime.now().date().isoformat(), 0
+    for path in Path(logs).glob("jev-usage-*.jsonl"):
+        for line in path.read_text().splitlines():
+            try:
+                r = json.loads(line)
+            except ValueError:
+                continue
+            if r.get("caller") == caller and str(r.get("time", "")).startswith(day):
+                used += r.get("input_tokens", 0) + r.get("output_tokens", 0)
+    return used
+
+
+def main():
+    try:
+        req = json.loads(sys.stdin.read() or "{}")
+    except ValueError as e:
+        return out({"scores": {}, "error": f"bad input: {e}"})
+    caller = req.get("caller")
+    if caller not in CALLERS:
+        return out({"scores": {}, "error": f"unknown caller {caller!r}"})
+    state, questions = req.get("state"), req.get("questions") or []
+    if not isinstance(state, str) or not state or not questions:
+        return out({"scores": {}, "error": "state and questions are required"})
+    if not all(isinstance(q, dict) and q.get("key") and isinstance(q.get("instructions"), str) for q in questions):
+        return out({"scores": {}, "error": "each question needs a key and instructions"})
+
+    jev_dir = Path(os.environ.get("JEV_LOOP_DIR") or Path.home() / ".claude" / "jev-loop")
+    if not (jev_dir / "router.py").exists():
+        return out({"scores": {}, "error": f"jev-loop not found at {jev_dir}"})
+    if not os.environ.get("TYPESAFE_API_KEY"):
+        # cron and plain shells have no Claude settings env: read the key the way jev-loop's daily.sh does
+        try:
+            settings = Path(os.environ.get("SEMANTIC_MEMORY_CLAUDE_SETTINGS") or Path.home() / ".claude" / "settings.json")
+            os.environ["TYPESAFE_API_KEY"] = json.loads(settings.read_text())["env"]["TYPESAFE_API_KEY"]
+        except Exception:
+            return out({"scores": {}, "error": "TYPESAFE_API_KEY is not set"})
+
+    # the router names its caller from argv[0] (older jev-loop) or JEV_CALLER: set both before importing it
+    os.environ["JEV_CALLER"] = caller
+    sys.argv = [caller]
+    sys.path.insert(0, str(jev_dir))
+    try:
+        import router  # noqa: E402
+    except Exception as e:
+        return out({"scores": {}, "error": f"router import failed: {type(e).__name__}: {e}"})
+
+    cwd = req.get("cwd") or os.getcwd()
+    if router.repo_for(cwd, []) == "excluded":
+        return out({"scores": {}, "error": "excluded path: nothing sent"})
+
+    if caller == LIVE_CALLER:
+        cap = int(os.environ.get("SEMANTIC_MEMORY_JEV_DAILY_TOKENS") or 500_000)
+        used = live_tokens_today(router.LOGS, caller)
+        if used >= cap:
+            return out({"scores": {}, "error": f"daily ceiling reached: {used} of {cap} tokens (SEMANTIC_MEMORY_JEV_DAILY_TOKENS)", "ceiling": True})
+    timeout = req.get("timeout_seconds")
+    if isinstance(timeout, (int, float)) and timeout > 0:
+        router.R["timeout_seconds"] = timeout
+
+    state = state[: router.R["max_prompt_chars"]]
+    items = [(q["key"], q["instructions"]) for q in questions]
+    try:
+        scores, tokens = router.ask_all(state, items)
+    except Exception as e:  # JevBudget, HTTP errors, timeouts: no answer, never a crash
+        router.flush_ledger()
+        return out({"scores": {}, "error": f"{type(e).__name__}: {e}"[:300]})
+    router.flush_ledger()
+    out({"scores": {k: v for k, v in scores.items() if isinstance(v, (int, float))}, "tokens": tokens})
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BaseException as e:  # noqa: BLE001 — the bridge must never crash its caller
+        out({"scores": {}, "error": f"{type(e).__name__}: {e}"[:300]})

package/hooks/session-start.js

@@ -18,6 +18,11 @@ import { reconcile } from "./reconcile.js";
 
 async function main() {
   const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // recursion guard: a skill-loop claude run (v1.7) must not reconcile or update anything
+  if (process.env.SEMANTIC_MEMORY_REVIEWER === "1") {
+    emit();
+    return;
+  }
 
   // 1. Reconcile — no-deps, always runs.
   try {

package/hooks/skill-loop.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// skill-loop.js — the skill loop's hooks (v1.7). Off by default: with the skill loop off (or inside a
+// skill-loop claude run) every event leaves at once, writes nothing and spawns nothing.
+//
+//   SessionStart                → once per session (startup / resume): "N skill drafts waiting"; starts the curator
+//                                 detached when it is due (every 7 days, repo quiet >= 2 h)
+//   PostToolUse (matcher Skill) → one usage line in .claude/.semantic-memory/skill-usage.jsonl
+//   SessionEnd                  → a review job when the session has signal (a failure, a correction or many
+//                                 tool calls), and the repo's worker started detached. Must finish well inside
+//                                 SessionEnd's 1.5 s: it only writes the job and spawns.
+//
+// Never blocks the session and never fails it: errors are swallowed (SIDEKICK_DEBUG=1 prints them).
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const DEBUG = process.env.SIDEKICK_DEBUG === "1";
+const debug = (msg) => DEBUG && process.stderr.write(`[skill-loop] ${msg}\n`);
+const dist = (m) => new URL(`../dist/core/${m}.js`, import.meta.url).href;
+
+function readStdinJson() {
+  try {
+    const raw = readFileSync(0, "utf8");
+    return raw.trim() ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+export async function main(input = readStdinJson(), env = process.env) {
+  if (env.SEMANTIC_MEMORY_REVIEWER === "1") return;
+  const cwd = input.cwd || env.CLAUDE_PROJECT_DIR || process.cwd();
+  const { featureOn } = await import(dist("features"));
+  if (!featureOn("skill_loop", cwd, env)) return;
+  const ev = await import(dist("skill-evidence"));
+  const root = ev.repoRoot(cwd);
+  const session_id = typeof input.session_id === "string" ? input.session_id : null;
+  if (input.hook_event_name === "SessionStart") {
+    if (input.source === "clear" || input.source === "compact") return;
+    const { listDrafts } = await import(dist("skill-review"));
+    const n = listDrafts(root).length;
+    const { curatorDue } = await import(dist("skill-curator"));
+    if (curatorDue(root)) {
+      const { spawn } = await import("node:child_process");
+      const cli = new URL("../dist/cli/index.js", import.meta.url).pathname;
+      spawn(process.execPath, [cli, "skill-loop", "curate", "--auto"], { cwd: root, env, detached: true, stdio: "ignore" }).unref();
+    }
+    if (n) process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: `[skill loop] ${n} skill draft${n > 1 ? "s" : ""} waiting for review (\`/skill-loop review\`).` } }) + "\n");
+  } else if (input.hook_event_name === "PostToolUse" && input.tool_name === "Skill") {
+    const skill = input.tool_input?.skill;
+    if (typeof skill === "string" && skill) ev.appendEvidence(root, "usage", { session_id, skill, via: "tool" }, env);
+  } else if (input.hook_event_name === "SessionEnd") {
+    const q = await import(dist("skill-queue"));
+    const job = q.sessionJob(root, input, env);
+    if (!job) return;
+    q.enqueue(job, env);
+    const { spawnWorker } = await import(dist("skill-worker"));
+    spawnWorker(root, env);
+  }
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((e) => debug(e.message));
+}