aidimag 1.0.0

package/dist/capture/commit-miner.js

@@ -0,0 +1,381 @@
+/**
+ * Commit miner (Phase 2 capture pipeline).
+ *
+ * Walks git history since the last mined commit and heuristically extracts
+ * memory-worthy candidates from commit messages + touched files. Candidates
+ * land in the proposal queue (human-in-the-loop) — never directly in memory.
+ *
+ * Each proposal is anchored with COMMIT_REF evidence so Phase 3 verification
+ * can re-check it against history.
+ */
+import { execFileSync } from "node:child_process";
+import { extractTicketId, readTicketsConfig, DEFAULT_TICKET_PATTERN } from "../tickets/provider.js";
+import { debugLog } from "../debug.js";
+const MINER_CURSOR_KEY = "commit_miner_last_sha";
+const COMMIT_SEP = "\x1e"; // record separator
+const FIELD_SEP = "\x1f"; // unit separator
+/**
+ * Heuristic signal patterns → memory kind.
+ * Order matters: first match wins.
+ */
+const SIGNALS = [
+    {
+        kind: "FAILED_APPROACH",
+        patterns: [
+            /\brevert(s|ed|ing)?\b/i,
+            /\bback(\s|-)?out\b/i,
+            /\bdidn'?t work\b/i,
+            /\babandon(s|ed|ing)?\b/i,
+        ],
+    },
+    {
+        kind: "GOTCHA",
+        patterns: [
+            /\bworkaround\b/i,
+            /\bhack\b/i,
+            /\bgotcha\b/i,
+            /\bedge case\b/i,
+            /\brace condition\b/i,
+            /\bfoot(\s|-)?gun\b/i,
+            /\bsubtle\b/i,
+            /\bcareful\b/i,
+            /\bdo not\b.*\bbecause\b/i,
+        ],
+    },
+    {
+        kind: "DECISION",
+        patterns: [
+            /\bdecid(e|ed|ing)\b/i,
+            /\bswitch(ed|ing)? (from|to)\b/i,
+            /\bmigrat(e|ed|ing) (from|to)\b/i,
+            /\breplac(e|ed|ing) .+ with\b/i,
+            /\binstead of\b/i,
+            /\bchose\b/i,
+            /\badopt(s|ed|ing)?\b/i,
+            /\bADR\b/,
+        ],
+    },
+    {
+        kind: "CONVENTION",
+        patterns: [
+            /\bconvention\b/i,
+            /\balways\b.+\b(use|go|import|call)\b/i,
+            /\bnever\b.+\b(use|import|call)\b/i,
+            /\bstandardiz(e|ed|ing)\b/i,
+            /\benforce(s|d)?\b/i,
+            /\blint rule\b/i,
+        ],
+    },
+    {
+        kind: "INVARIANT",
+        patterns: [/\binvariant\b/i, /\bmust (always|never)\b/i, /\bguarantee(s|d)?\b/i],
+    },
+];
+/** Why-markers: a commit explaining reasoning is more memory-worthy. */
+const WHY_MARKERS = /\b(because|so that|otherwise|due to|the reason|to avoid|to prevent)\b/i;
+function git(repoRoot, args) {
+    return execFileSync("git", args, { cwd: repoRoot, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+}
+/** False when the repo is initialized but has no commits yet (no HEAD). */
+export function hasGitCommits(repoRoot) {
+    try {
+        execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+            cwd: repoRoot,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readCommits(repoRoot, sinceSha, maxCommits = 500) {
+    if (!hasGitCommits(repoRoot))
+        return [];
+    const range = sinceSha ? `${sinceSha}..HEAD` : "HEAD";
+    let raw;
+    try {
+        // NOTE: merges are included on purpose — GitHub "merge pull request"
+        // commits carry the PR title in the body, and squash-merges carry the
+        // full PR description. Pure merge noise ("Merge branch 'x'") has no
+        // signal words, so classifyCommit filters it naturally.
+        raw = git(repoRoot, [
+            "log",
+            range,
+            `--max-count=${maxCommits}`,
+            `--pretty=format:${COMMIT_SEP}%H${FIELD_SEP}%s${FIELD_SEP}%b${FIELD_SEP}`,
+            "--name-only",
+        ]);
+    }
+    catch (err) {
+        // sinceSha may no longer exist (rebase/gc) — fall back to full history
+        if (sinceSha)
+            return readCommits(repoRoot, null, maxCommits);
+        throw err;
+    }
+    const commits = [];
+    for (const chunk of raw.split(COMMIT_SEP)) {
+        if (!chunk.trim())
+            continue;
+        const [sha, subject, body, fileBlock] = chunk.split(FIELD_SEP);
+        if (!sha)
+            continue;
+        const files = (fileBlock ?? "")
+            .split("\n")
+            .map((f) => f.trim())
+            .filter(Boolean);
+        commits.push({ sha: sha.trim(), subject: subject ?? "", body: body ?? "", files });
+    }
+    return commits;
+}
+export function classifyCommit(c) {
+    const text = `${c.subject}\n${c.body}`;
+    for (const { kind, patterns } of SIGNALS) {
+        for (const re of patterns) {
+            const m = text.match(re);
+            if (m)
+                return { kind, matched: m[0] };
+        }
+    }
+    // a long explanatory body with why-markers is a DECISION candidate even without keywords
+    if (c.body.length > 120 && WHY_MARKERS.test(c.body)) {
+        return { kind: "DECISION", matched: "explanatory body" };
+    }
+    return null;
+}
+function buildClaim(c, kind) {
+    let subject = c.subject.trim().replace(/\.+$/, "");
+    let bodyLines = c.body
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith("Co-authored-by") && !l.startsWith("Signed-off-by"));
+    // merge commits: the subject is boilerplate ("Merge pull request #123 …");
+    // the PR title is the first body line — promote it.
+    if (/^Merge (pull request|branch)/i.test(subject) && bodyLines.length) {
+        subject = bodyLines[0].replace(/\.+$/, "");
+        bodyLines = bodyLines.slice(1);
+    }
+    const why = bodyLines.join(" ").slice(0, 300);
+    const prefix = kind === "FAILED_APPROACH"
+        ? "An approach was abandoned"
+        : kind === "GOTCHA"
+            ? "There is a gotcha"
+            : kind === "DECISION"
+                ? "A decision was made"
+                : kind === "CONVENTION"
+                    ? "A convention applies"
+                    : "An invariant holds";
+    return why ? `${prefix}: ${subject} — ${why}` : `${prefix}: ${subject}`;
+}
+/** Files that say nothing about the code — never useful as memory scope. */
+const SCOPE_NOISE = /^(\.idea\/|\.vscode\/|\.aidimag\/|\.github\/workflows\/.*\.lock|\.gitignore$|\.DS_Store$|node_modules\/)/;
+/** Reduce touched files to a few representative scope paths (common directories). */
+export function scopeFromFiles(files, maxPaths = 4) {
+    files = files.filter((f) => !SCOPE_NOISE.test(f));
+    if (files.length === 0)
+        return [];
+    if (files.length <= maxPaths)
+        return files;
+    const dirs = new Map();
+    for (const f of files) {
+        const dir = f.includes("/") ? f.slice(0, f.lastIndexOf("/")) : ".";
+        dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+    }
+    return [...dirs.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, maxPaths)
+        .map(([d]) => d);
+}
+export function mineCommits(store, repoRoot, opts = {}) {
+    if (!hasGitCommits(repoRoot)) {
+        return { scanned: 0, proposed: [], skippedDuplicates: 0, lastSha: null, noCommits: true };
+    }
+    const sinceSha = opts.full ? null : store.getMeta(MINER_CURSOR_KEY);
+    const commits = readCommits(repoRoot, sinceSha, opts.maxCommits ?? 500);
+    if (commits.length === 0 && sinceSha) {
+        return {
+            scanned: 0,
+            proposed: [],
+            skippedDuplicates: 0,
+            lastSha: sinceSha,
+            noNewCommits: true,
+        };
+    }
+    // T1 ticket extraction (offline): per-commit from the message; for
+    // incremental mining (the post-commit hook path) the current branch name is
+    // a trustworthy fallback — for full-history scans it would mislabel.
+    const ticketPattern = readTicketsConfig(repoRoot).pattern ?? DEFAULT_TICKET_PATTERN;
+    let branchTicket = null;
+    if (sinceSha) {
+        try {
+            const branch = git(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+            branchTicket = extractTicketId(branch, ticketPattern);
+        }
+        catch {
+            // detached HEAD etc — message extraction still applies
+        }
+    }
+    const proposed = [];
+    let skippedDuplicates = 0;
+    for (const c of commits) {
+        const hit = classifyCommit(c);
+        if (!hit)
+            continue;
+        const ticketRef = extractTicketId(`${c.subject}\n${c.body}`, ticketPattern) ?? branchTicket ?? undefined;
+        const input = {
+            kind: hit.kind,
+            claim: buildClaim(c, hit.kind),
+            paths: scopeFromFiles(c.files),
+            evidence: [
+                { type: "COMMIT_REF", payload: c.sha },
+                ...(ticketRef ? [{ type: "TICKET_REF", payload: ticketRef }] : []),
+            ],
+            source: "commit-miner",
+            sourceRef: c.sha,
+            rationale: `Matched signal "${hit.matched}" in commit ${c.sha.slice(0, 8)}: ${c.subject}`,
+            ticketRef,
+        };
+        const p = store.propose(input);
+        if (p)
+            proposed.push(p);
+        else
+            skippedDuplicates++;
+    }
+    // advance cursor to current HEAD (newest commit is first in `git log` output)
+    const head = commits.length > 0 ? commits[0].sha : sinceSha;
+    if (head)
+        store.setMeta(MINER_CURSOR_KEY, head);
+    return { scanned: commits.length, proposed, skippedDuplicates, lastSha: head ?? null };
+}
+// ---------------------------------------------------------------- LLM mining (deep tier)
+const LLM_DIFF_CHARS = 6_000;
+const LLM_MAX_COMMITS = 40; // per run — LLM mining is the deep tier
+export const COMMIT_EXTRACT_INSTRUCTIONS = `You are mining a git commit for durable, project-specific knowledge worth remembering across AI coding sessions: decisions (and rejected alternatives), conventions, gotchas, failed approaches, invariants, architecture facts.
+
+Rules:
+1. Most commits contain NOTHING durable — routine features/fixes/refactors. Return zero claims for those. Do NOT invent.
+2. When there IS signal, SYNTHESIZE a falsifiable claim about the codebase — do not parrot the commit message. Bad: "A decision was made: use Redis". Good: "Rate limiting uses Redis (src/limits); the in-memory limiter was abandoned because multi-instance deploys need shared counters".
+3. Use the DIFF, not just the message — renamed modules, deleted approaches, and added config tell the real story.
+4. kinds: DECISION, CONVENTION, GOTCHA, FAILED_APPROACH, ARCHITECTURE, INVARIANT, GUARDRAIL (guardrail_level never|ask-first|always), SKILL, TODO_CONTEXT.
+5. Scope with the touched paths; add "static_check" (cheap shell command, exit 0 iff true) when an honest one exists.
+6. 0–2 claims per commit. Zero is the common case.
+
+Respond with ONLY: {"claims":[{"kind":"DECISION","claim":"...","paths":["src/x"],"symbols":[],"guardrail_level":null,"rationale":"...","static_check":null}]}`;
+function commitDiff(repoRoot, sha) {
+    try {
+        return git(repoRoot, ["show", sha, "--stat", "--patch", "--format="]).slice(0, LLM_DIFF_CHARS);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * LLM-powered deep mining: reads message + diff, synthesizes claims with
+ * suggested STATIC_CHECKs. Requires a text provider (OpenAI/Ollama); the
+ * caller falls back to regex mining when none is available. Same cursor as
+ * regex mining — the two modes are alternatives over the same history.
+ */
+export async function mineCommitsLlm(store, repoRoot, opts = {}) {
+    const { getTextProvider } = await import("../knowledge/llm.js");
+    const { parseClaims } = await import("../knowledge/extract.js");
+    const provider = await getTextProvider();
+    if (!provider) {
+        const r = mineCommits(store, repoRoot, opts);
+        return { ...r, provider: null };
+    }
+    if (!hasGitCommits(repoRoot)) {
+        return { scanned: 0, proposed: [], skippedDuplicates: 0, lastSha: null, noCommits: true, provider: null };
+    }
+    const sinceSha = opts.full ? null : store.getMeta(MINER_CURSOR_KEY);
+    const commits = readCommits(repoRoot, sinceSha, Math.min(opts.maxCommits ?? LLM_MAX_COMMITS, LLM_MAX_COMMITS));
+    if (commits.length === 0 && sinceSha) {
+        return {
+            scanned: 0,
+            proposed: [],
+            skippedDuplicates: 0,
+            lastSha: sinceSha,
+            noNewCommits: true,
+            provider: `${provider.name}/${provider.model}`,
+        };
+    }
+    const ticketPattern = readTicketsConfig(repoRoot).pattern ?? DEFAULT_TICKET_PATTERN;
+    const proposed = [];
+    let skippedDuplicates = 0;
+    for (const c of commits) {
+        // Pure merge noise never carries signal — skip the LLM call entirely.
+        if (/^Merge branch /i.test(c.subject) && !c.body.trim())
+            continue;
+        const user = `Commit ${c.sha.slice(0, 12)}\nSubject: ${c.subject}\nBody:\n${c.body || "(none)"}\n\n` +
+            `Diff (truncated):\n${commitDiff(repoRoot, c.sha)}`;
+        let claims;
+        try {
+            claims = parseClaims(await provider.generate(COMMIT_EXTRACT_INSTRUCTIONS, user));
+        }
+        catch (err) {
+            debugLog(`llm mining commit ${c.sha.slice(0, 8)} (skipped)`, err);
+            continue; // provider hiccup on one commit shouldn't kill the run
+        }
+        const ticketRef = extractTicketId(`${c.subject}\n${c.body}`, ticketPattern) ?? undefined;
+        for (const cl of claims.slice(0, 2)) {
+            const evidence = [{ type: "COMMIT_REF", payload: c.sha }];
+            if (cl.staticCheck)
+                evidence.push({ type: "STATIC_CHECK", payload: cl.staticCheck });
+            if (ticketRef)
+                evidence.push({ type: "TICKET_REF", payload: ticketRef });
+            const p = store.propose({
+                kind: cl.kind,
+                claim: cl.claim,
+                paths: cl.paths ?? scopeFromFiles(c.files),
+                symbols: cl.symbols,
+                guardrailLevel: cl.guardrailLevel,
+                evidence,
+                source: "commit-miner",
+                sourceRef: c.sha,
+                rationale: cl.rationale ?? `LLM-mined from commit ${c.sha.slice(0, 8)}: ${c.subject}`,
+                ticketRef,
+            });
+            if (p)
+                proposed.push(p);
+            else
+                skippedDuplicates++;
+        }
+    }
+    const head = commits.length > 0 ? commits[0].sha : sinceSha;
+    if (head)
+        store.setMeta(MINER_CURSOR_KEY, head);
+    return {
+        scanned: commits.length,
+        proposed,
+        skippedDuplicates,
+        lastSha: head ?? null,
+        provider: `${provider.name}/${provider.model}`,
+    };
+}
+/** Human-readable summary of a mine run (CLI + MCP). */
+export function describeMineResult(r, opts = {}) {
+    if (r.noCommits)
+        return "No git commits yet — make an initial commit before mining history.";
+    if (r.noNewCommits) {
+        return (`No new commits since the last mine (cursor @ ${r.lastSha?.slice(0, 8) ?? "?"}). ` +
+            "Use full=true (or `dim mine --full`) to rescan all history.");
+    }
+    const llmNote = opts.llmRequested && !opts.llmProvider
+        ? " (no LLM provider — fell back to keyword mining; run Ollama or set OPENAI_API_KEY for llm=true)"
+        : opts.llmProvider
+            ? ` with ${opts.llmProvider}`
+            : "";
+    let msg = `Scanned ${r.scanned} commit(s)${llmNote}: ${r.proposed.length} proposal(s) queued` +
+        (r.skippedDuplicates ? `, ${r.skippedDuplicates} duplicate(s) skipped` : "") +
+        (r.lastSha ? ` (cursor @ ${r.lastSha.slice(0, 8)})` : "");
+    if (r.proposed.length === 0 && r.scanned > 0) {
+        msg +=
+            "\nNone matched memory-worthy signals — try descriptive commit messages" +
+                (opts.llmRequested ? "." : " or enable llm=true / `dim mine --llm`.");
+    }
+    else if (r.proposed.length > 0) {
+        msg += "\nReview with `dim review`.";
+    }
+    return msg;
+}
+//# sourceMappingURL=commit-miner.js.map

package/dist/capture/harvest.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Transcript harvester — out-of-band capture of the context humans type into
+ * AI chats. Claude Code persists every session as JSONL under
+ * ~/.claude/projects/<path-slug>/*.jsonl; the USER messages in there are the
+ * highest-signal capture source aidimag has: they're the facts a human already
+ * decided were worth teaching an AI ("we use X because Y", "never touch Z").
+ *
+ * `dim harvest` extracts durable, falsifiable claims from those messages with
+ * the configured LLM provider (OpenAI/Ollama, same fallback as knowledge
+ * ingestion) and queues them as proposals (source `harvest:claude-code`) —
+ * nothing becomes active memory without `dim review`.
+ *
+ * Privacy: opt-in by invocation, local-only (transcripts never leave the
+ * machine except to the LLM provider you configured), and secret-looking lines
+ * are redacted before extraction. `--install-hook` wires a Claude Code
+ * SessionEnd hook so harvesting runs automatically when a session closes.
+ */
+import type { MemoryStore } from "../db/store.js";
+export interface HarvestResult {
+    sessionsScanned: number;
+    messagesConsidered: number;
+    proposed: number;
+    duplicates: number;
+    provider: string | null;
+    transcriptDir: string | null;
+}
+/** Claude Code stores transcripts under a slug of the project's absolute path. */
+export declare function claudeProjectDir(repoRoot: string): string | null;
+/** Very conservative redaction: drop lines that look like secrets before they reach any LLM. */
+export declare function redactSecrets(text: string): string;
+/** Extract genuine human-typed messages from one Claude Code session JSONL. */
+export declare function userMessagesFromTranscript(jsonl: string): string[];
+export declare const HARVEST_EXTRACT_INSTRUCTIONS = "You are reviewing messages a DEVELOPER typed into an AI coding assistant while working on their project. These messages often contain durable project knowledge the developer was teaching the AI: decisions, conventions, gotchas, failed approaches, architecture facts, rules.\n\nExtract that durable knowledge as FALSIFIABLE claims. Rules:\n\n1. Only durable, project-specific facts the HUMAN stated \u2014 not the task of the day, not questions, not generic programming advice.\n2. Write each claim as a checkable statement about the codebase.\n3. kinds: DECISION, CONVENTION, GOTCHA, FAILED_APPROACH, ARCHITECTURE, INVARIANT, GUARDRAIL (set guardrail_level: never|ask-first|always), SKILL, TODO_CONTEXT.\n4. Scope with paths/symbols when the messages name them; else leave empty.\n5. In \"rationale\", QUOTE the fragment of the developer's message the claim came from.\n6. Extract 0\u20138 claims. Zero is fine \u2014 most sessions contain none. Do NOT invent.\n\nRespond with ONLY a JSON object of this exact shape:\n{\"claims\":[{\"kind\":\"CONVENTION\",\"claim\":\"...\",\"paths\":[\"src/x\"],\"symbols\":[],\"guardrail_level\":null,\"rationale\":\"user said: \\\"...\\\"\"}]}";
+/**
+ * Harvest new/updated Claude Code sessions for this repo into the proposal
+ * queue. Cursor-tracked by file mtime; `all` rescans everything (the proposal
+ * dedupe index absorbs repeats).
+ */
+export declare function harvestClaudeSessions(store: MemoryStore, repoRoot: string, opts?: {
+    all?: boolean;
+}): Promise<HarvestResult>;
+/**
+ * Wire `dim harvest -q` into the repo's Claude Code SessionEnd hook
+ * (.claude/settings.json) so every session is harvested when it closes.
+ * Additive: merges with existing settings, never clobbers other hooks.
+ */
+export declare function installClaudeSessionEndHook(repoRoot: string): {
+    installed: boolean;
+    settingsPath: string;
+};

package/dist/capture/harvest.js

@@ -0,0 +1,207 @@
+/**
+ * Transcript harvester — out-of-band capture of the context humans type into
+ * AI chats. Claude Code persists every session as JSONL under
+ * ~/.claude/projects/<path-slug>/*.jsonl; the USER messages in there are the
+ * highest-signal capture source aidimag has: they're the facts a human already
+ * decided were worth teaching an AI ("we use X because Y", "never touch Z").
+ *
+ * `dim harvest` extracts durable, falsifiable claims from those messages with
+ * the configured LLM provider (OpenAI/Ollama, same fallback as knowledge
+ * ingestion) and queues them as proposals (source `harvest:claude-code`) —
+ * nothing becomes active memory without `dim review`.
+ *
+ * Privacy: opt-in by invocation, local-only (transcripts never leave the
+ * machine except to the LLM provider you configured), and secret-looking lines
+ * are redacted before extraction. `--install-hook` wires a Claude Code
+ * SessionEnd hook so harvesting runs automatically when a session closes.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { getTextProvider } from "../knowledge/llm.js";
+import { parseClaims } from "../knowledge/extract.js";
+import { debugLog } from "../debug.js";
+const CURSOR_META_KEY = "harvest_claude_last_mtime";
+/** Ignore short/noisy user turns ("yes", "continue", slash commands…). */
+const MIN_MESSAGE_CHARS = 40;
+/** Cap what we send to the LLM per session (chars). */
+const MAX_SESSION_CHARS = 24_000;
+/** Claude Code stores transcripts under a slug of the project's absolute path. */
+export function claudeProjectDir(repoRoot) {
+    const slug = path.resolve(repoRoot).replace(/[^a-zA-Z0-9]/g, "-");
+    const dir = path.join(homedir(), ".claude", "projects", slug);
+    return existsSync(dir) ? dir : null;
+}
+/** Very conservative redaction: drop lines that look like secrets before they reach any LLM. */
+export function redactSecrets(text) {
+    const SECRET_LINE = /(api[-_]?key|secret|token|password|passwd|authorization|bearer\s+[a-z0-9_-]{16,}|-----BEGIN [A-Z ]*PRIVATE KEY|aws_access_key_id|sk-[a-zA-Z0-9]{20,}|ghp_[a-zA-Z0-9]{20,}|xox[baprs]-)/i;
+    return text
+        .split("\n")
+        .map((line) => (SECRET_LINE.test(line) ? "[REDACTED — possible secret]" : line))
+        .join("\n");
+}
+/** Extract genuine human-typed messages from one Claude Code session JSONL. */
+export function userMessagesFromTranscript(jsonl) {
+    const out = [];
+    for (const line of jsonl.split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "user" || entry.isMeta)
+            continue;
+        const message = entry.message;
+        if (!message || message.role !== "user")
+            continue;
+        let text = "";
+        if (typeof message.content === "string") {
+            text = message.content;
+        }
+        else if (Array.isArray(message.content)) {
+            // tool_result blocks are machine output, not the human — skip them
+            text = message.content
+                .filter((c) => c.type === "text" && typeof c.text === "string")
+                .map((c) => c.text)
+                .join("\n");
+        }
+        text = text.trim();
+        // skip injected command/system scaffolding and trivial turns
+        if (!text || text.startsWith("<") || text.startsWith("/"))
+            continue;
+        if (text.length < MIN_MESSAGE_CHARS)
+            continue;
+        out.push(text);
+    }
+    return out;
+}
+export const HARVEST_EXTRACT_INSTRUCTIONS = `You are reviewing messages a DEVELOPER typed into an AI coding assistant while working on their project. These messages often contain durable project knowledge the developer was teaching the AI: decisions, conventions, gotchas, failed approaches, architecture facts, rules.
+
+Extract that durable knowledge as FALSIFIABLE claims. Rules:
+
+1. Only durable, project-specific facts the HUMAN stated — not the task of the day, not questions, not generic programming advice.
+2. Write each claim as a checkable statement about the codebase.
+3. kinds: DECISION, CONVENTION, GOTCHA, FAILED_APPROACH, ARCHITECTURE, INVARIANT, GUARDRAIL (set guardrail_level: never|ask-first|always), SKILL, TODO_CONTEXT.
+4. Scope with paths/symbols when the messages name them; else leave empty.
+5. In "rationale", QUOTE the fragment of the developer's message the claim came from.
+6. Extract 0–8 claims. Zero is fine — most sessions contain none. Do NOT invent.
+
+Respond with ONLY a JSON object of this exact shape:
+{"claims":[{"kind":"CONVENTION","claim":"...","paths":["src/x"],"symbols":[],"guardrail_level":null,"rationale":"user said: \\"...\\""}]}`;
+function pendingSessions(dir, sinceMtimeMs, all) {
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => {
+        const abs = path.join(dir, f);
+        return { file: f, abs, mtimeMs: statSync(abs).mtimeMs };
+    })
+        .filter((s) => all || s.mtimeMs > sinceMtimeMs)
+        .sort((a, b) => a.mtimeMs - b.mtimeMs);
+}
+/**
+ * Harvest new/updated Claude Code sessions for this repo into the proposal
+ * queue. Cursor-tracked by file mtime; `all` rescans everything (the proposal
+ * dedupe index absorbs repeats).
+ */
+export async function harvestClaudeSessions(store, repoRoot, opts = {}) {
+    const result = {
+        sessionsScanned: 0,
+        messagesConsidered: 0,
+        proposed: 0,
+        duplicates: 0,
+        provider: null,
+        transcriptDir: null,
+    };
+    const dir = claudeProjectDir(repoRoot);
+    if (!dir)
+        return result;
+    result.transcriptDir = dir;
+    const provider = await getTextProvider();
+    if (!provider)
+        return result;
+    result.provider = `${provider.name}/${provider.model}`;
+    const cursor = opts.all ? 0 : parseFloat(store.getMeta(CURSOR_META_KEY) ?? "0") || 0;
+    const sessions = pendingSessions(dir, cursor, Boolean(opts.all));
+    let maxMtime = cursor;
+    for (const s of sessions) {
+        result.sessionsScanned++;
+        maxMtime = Math.max(maxMtime, s.mtimeMs);
+        let messages;
+        try {
+            messages = userMessagesFromTranscript(readFileSync(s.abs, "utf8"));
+        }
+        catch (err) {
+            debugLog(`harvest transcript ${s.file} (skipped)`, err);
+            continue; // unreadable/partial file — retry next run (cursor still advances past it)
+        }
+        if (!messages.length)
+            continue;
+        result.messagesConsidered += messages.length;
+        const corpus = redactSecrets(messages.join("\n\n---\n\n")).slice(0, MAX_SESSION_CHARS);
+        let claims;
+        try {
+            const raw = await provider.generate(HARVEST_EXTRACT_INSTRUCTIONS, `Developer messages from one coding session on this project:\n\n----- BEGIN MESSAGES -----\n${corpus}\n----- END MESSAGES -----`);
+            claims = parseClaims(raw);
+        }
+        catch (err) {
+            debugLog(`harvest llm extraction ${s.file} (skipped)`, err);
+            continue; // provider hiccup — this session retries on the next --all run
+        }
+        const sessionId = s.file.replace(/\.jsonl$/, "");
+        for (const c of claims) {
+            const p = store.propose({
+                kind: c.kind,
+                claim: c.claim,
+                paths: c.paths,
+                symbols: c.symbols,
+                guardrailLevel: c.guardrailLevel,
+                rationale: c.rationale ?? "Stated by the user in a Claude Code session.",
+                evidence: [
+                    { type: "HUMAN_ATTESTED", payload: `stated by user in Claude Code session ${sessionId.slice(0, 8)}` },
+                ],
+                source: "harvest:claude-code",
+                sourceRef: sessionId,
+            });
+            if (p)
+                result.proposed++;
+            else
+                result.duplicates++;
+        }
+    }
+    if (maxMtime > cursor)
+        store.setMeta(CURSOR_META_KEY, String(maxMtime));
+    return result;
+}
+// ---------------------------------------------------------------- hook install
+const HOOK_COMMAND = "dim harvest -q";
+/**
+ * Wire `dim harvest -q` into the repo's Claude Code SessionEnd hook
+ * (.claude/settings.json) so every session is harvested when it closes.
+ * Additive: merges with existing settings, never clobbers other hooks.
+ */
+export function installClaudeSessionEndHook(repoRoot) {
+    const settingsPath = path.join(repoRoot, ".claude", "settings.json");
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+        }
+        catch {
+            throw new Error(`${settingsPath} exists but is not valid JSON — fix it before installing the hook.`);
+        }
+    }
+    const hooks = (settings.hooks ??= {});
+    const sessionEnd = (hooks.SessionEnd ??= []);
+    const already = sessionEnd.some((m) => m.hooks?.some((h) => h.command?.includes("dim harvest")));
+    if (already)
+        return { installed: false, settingsPath };
+    sessionEnd.push({ hooks: [{ type: "command", command: HOOK_COMMAND }] });
+    mkdirSync(path.dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    return { installed: true, settingsPath };
+}
+//# sourceMappingURL=harvest.js.map