greprag 0.4.0 → 0.5.1

package/dist/hook.js

@@ -1,17 +1,11 @@
 #!/usr/bin/env node
 "use strict";
-/** GrepRAG Hook — thin HTTP pipe for Claude Code hooks.
+/** GrepRAG Hook — Stop-hook turn capture for episodic memory.
  *
- * Agent-intent memory: memory is a repository, not an injection layer.
- * Write side (ambient): Stop → store. Read side (intentional): agents call
- * `greprag recall` when they need past context.
- *
- * Subcommands: store, signal, summary, recover, farewell, recap, handoff
- *
- * Lifecycle:
- *   recap(SessionStart:startup|clear) → [agent turn] → store(Stop) → farewell(SessionEnd)
- *   summary(PreCompact) → recover(SessionStart:compact)
- *   PostToolUse(ExitPlanMode | AskUserQuestion) → signal */
+ * On Stop, build the per-turn envelope from the transcript and POST to
+ * /v1/memory/turn. No LLM, no enrichment — the API just inserts the row.
+ * See C:/greprag/docs/episodic-memory.md.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -48,16 +42,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const project_anchor_1 = require("./project-anchor");
 const API_URL_DEFAULT = 'https://api.greprag.com';
-function getConfig(cwd) {
-    ensureEnv(cwd);
-    return {
-        apiUrl: process.env.GREPRAG_API_URL || API_URL_DEFAULT,
-        apiKey: process.env.GREPRAG_API_KEY || '',
-        enabled: process.env.MEMORY_HOOK_ENABLED === 'true',
-    };
-}
+const MAX_FIELD_CHARS = 500_000; // safety cap per text field
+// ---------- Env + config ---------------------------------------------------
 function loadEnvFile(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
@@ -74,14 +64,11 @@ function loadEnvFile(filePath) {
                 (value.startsWith("'") && value.endsWith("'"))) {
                 value = value.slice(1, -1);
             }
-            if (!process.env[key]) {
+            if (!process.env[key])
                 process.env[key] = value;
-            }
         }
     }
-    catch {
-        // File doesn't exist — fine
-    }
+    catch { /* file missing — fine */ }
 }
 function ensureEnv(cwd) {
     const homeDir = process.env.HOME || process.env.USERPROFILE || '';
@@ -90,6 +77,14 @@ function ensureEnv(cwd) {
     if (!process.env.GREPRAG_API_KEY)
         loadEnvFile(path.join(cwd, '.env'));
 }
+function getConfig(cwd) {
+    ensureEnv(cwd);
+    return {
+        apiUrl: process.env.GREPRAG_API_URL || API_URL_DEFAULT,
+        apiKey: process.env.GREPRAG_API_KEY || '',
+        enabled: process.env.MEMORY_HOOK_ENABLED === 'true',
+    };
+}
 async function apiCall(url, apiKey, body) {
     const res = await fetch(url, {
         method: 'POST',
@@ -115,445 +110,691 @@ function extractText(content) {
         .map((b) => b.text || '')
         .join('\n').trim();
 }
-/** Walk the transcript backwards to find the most recent real user message
- * (skipping tool_result entries). Returns empty string if not found. */
-function findLastUserMessage(transcriptPath) {
-    if (!transcriptPath)
+/** Extract text from a tool_result's content field. Can be a string or
+ *  an array of text blocks. */
+function extractToolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
         return '';
+    return content
+        .filter((b) => b?.type === 'text' || typeof b === 'string')
+        .map((b) => typeof b === 'string' ? b : (b.text || ''))
+        .join('\n');
+}
+/** Build a tool_call entry from a tool_use block. */
+function summarizeToolUse(block) {
+    const name = block.name || 'unknown';
+    const input = (block.input || {});
+    const tc = { name };
+    switch (name) {
+        case 'Bash': {
+            const cmd = input.command || '';
+            tc.target = input.description || cmd.split(/\s+/)[0] || '';
+            tc.brief = cmd.length > 800 ? cmd.slice(0, 800) + '…' : cmd;
+            break;
+        }
+        case 'Edit':
+        case 'Write':
+        case 'MultiEdit':
+        case 'NotebookEdit': {
+            tc.target = input.file_path || input.notebook_path || '';
+            break;
+        }
+        case 'Read': {
+            tc.target = input.file_path || '';
+            if (input.offset || input.limit) {
+                tc.brief = `offset=${input.offset ?? 0} limit=${input.limit ?? '?'}`;
+            }
+            break;
+        }
+        case 'Grep': {
+            tc.target = input.pattern || '';
+            const ctx = [input.path, input.glob, input.type].filter(Boolean).join(' ');
+            if (ctx)
+                tc.brief = ctx;
+            break;
+        }
+        case 'Glob': {
+            tc.target = input.pattern || '';
+            break;
+        }
+        case 'WebFetch':
+        case 'WebSearch': {
+            tc.target = input.url || input.query || '';
+            break;
+        }
+        case 'Agent':
+        case 'Task': {
+            tc.target = input.description || input.subagent_type || '';
+            tc.brief = (input.prompt || '').slice(0, 200);
+            break;
+        }
+        default: {
+            // Unknown tool — best-effort summary
+            const json = JSON.stringify(input);
+            tc.brief = json.length > 200 ? json.slice(0, 200) + '…' : json;
+        }
+    }
+    return tc;
+}
+/** Parse the transcript, extracting the latest turn (since the last real user message). */
+function parseLatestTurn(transcriptPath) {
+    const empty = {
+        userPrompt: '', agentResponse: '', toolCalls: [],
+        filesTouched: [], model: null, status: 'completed',
+        userStartTime: null,
+    };
+    if (!transcriptPath)
+        return empty;
+    let lines;
+    try {
+        lines = fs.readFileSync(transcriptPath, 'utf-8').split('\n');
+    }
+    catch {
+        return empty;
+    }
+    // Walk backwards to find the last real user message (not a tool_result).
+    let userStartIdx = -1;
+    let userPrompt = '';
+    let userStartTime = null;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const msg = (entry.message || entry);
+        const role = (msg.role || entry.type || '');
+        if (role !== 'user')
+            continue;
+        if (Array.isArray(msg.content)) {
+            const isToolResult = msg.content
+                .some(b => b?.type === 'tool_result');
+            if (isToolResult)
+                continue;
+        }
+        const text = extractText(msg.content);
+        if (text && !text.startsWith('<system') && !text.startsWith('{')) {
+            userPrompt = text;
+            userStartIdx = i;
+            if (typeof entry.timestamp === 'string')
+                userStartTime = entry.timestamp;
+            break;
+        }
+    }
+    if (userStartIdx === -1)
+        return empty;
+    // Walk forward from the user message, collecting assistant text + tool_use.
+    const agentTextParts = [];
+    const toolCalls = [];
+    const filesTouched = new Set();
+    let model = null;
+    let status = 'completed';
+    for (let i = userStartIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const msg = (entry.message || entry);
+        const role = (msg.role || entry.type || '');
+        if (role === 'assistant') {
+            if (!model && typeof msg.model === 'string')
+                model = msg.model;
+            if (Array.isArray(msg.content)) {
+                for (const b of msg.content) {
+                    if (b?.type === 'text' && typeof b.text === 'string') {
+                        agentTextParts.push(b.text);
+                    }
+                    else if (b?.type === 'tool_use') {
+                        const tc = summarizeToolUse(b);
+                        tc._useId = b.id || undefined;
+                        toolCalls.push(tc);
+                        // Files touched derivation
+                        const input = (b.input || {});
+                        if (['Edit', 'Write', 'MultiEdit'].includes(tc.name) && input.file_path) {
+                            filesTouched.add(input.file_path);
+                        }
+                        else if (tc.name === 'NotebookEdit' && input.notebook_path) {
+                            filesTouched.add(input.notebook_path);
+                        }
+                    }
+                }
+            }
+        }
+        else if (role === 'user') {
+            // tool_result blocks — pair to tool_use by tool_use_id, capture stdout
+            if (Array.isArray(msg.content)) {
+                for (const b of msg.content) {
+                    if (b?.type === 'tool_result') {
+                        const useId = b.tool_use_id || '';
+                        const out = extractToolResultText(b.content);
+                        if (useId && out) {
+                            const tc = toolCalls.find(c => c._useId === useId);
+                            if (tc)
+                                tc._output = out;
+                        }
+                    }
+                }
+            }
+            const text = extractText(msg.content);
+            if (text.includes('[Request interrupted by user]'))
+                status = 'interrupted';
+        }
+    }
+    return {
+        userPrompt,
+        agentResponse: agentTextParts.join('\n\n').trim(),
+        toolCalls,
+        filesTouched: Array.from(filesTouched).sort(),
+        model,
+        status,
+        userStartTime,
+    };
+}
+/** Walk subagent transcripts under <session>/subagents/ and pull tool_use
+ *  blocks that fired during the current turn. Returns flattened ToolCall[]
+ *  augmented with _output where a matching tool_result exists in the same
+ *  subagent transcript. Also returns files_touched derived from subagent
+ *  Edit/Write/MultiEdit/NotebookEdit calls.
+ *
+ *  Subagents have their own transcript files because Claude Code scopes them
+ *  to their own session. The main transcript only sees the Agent tool_use
+ *  itself — not the work the subagent did. Without this flattening, any
+ *  commit/deploy/PR a subagent fires would be invisible to artifact detection.
+ */
+function parseSubagentCalls(transcriptPath, sinceTime) {
+    const empty = { toolCalls: [], filesTouched: [] };
+    if (!sinceTime)
+        return empty;
+    // Subagent transcripts live at <transcriptPath without .jsonl>/subagents/*.jsonl
+    const sessionDir = transcriptPath.replace(/\.jsonl$/, '');
+    const subagentsDir = path.join(sessionDir, 'subagents');
+    if (!fs.existsSync(subagentsDir))
+        return empty;
+    let files = [];
     try {
-        const raw = fs.readFileSync(transcriptPath, 'utf-8');
-        const lines = raw.split('\n');
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i].trim();
-            if (!line)
+        files = fs.readdirSync(subagentsDir).filter(f => f.endsWith('.jsonl'));
+    }
+    catch {
+        return empty;
+    }
+    const sinceMs = new Date(sinceTime).getTime();
+    const merged = [];
+    const filesTouched = new Set();
+    for (const fname of files) {
+        const fpath = path.join(subagentsDir, fname);
+        let raw;
+        try {
+            raw = fs.readFileSync(fpath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        // Two passes: collect tool_use blocks (filtered by time), then pair
+        // tool_results to populate _output.
+        const localCalls = [];
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
                 continue;
             let entry;
             try {
-                entry = JSON.parse(line);
+                entry = JSON.parse(trimmed);
             }
             catch {
                 continue;
             }
+            const ts = typeof entry.timestamp === 'string' ? new Date(entry.timestamp).getTime() : NaN;
+            if (!Number.isFinite(ts) || ts < sinceMs)
+                continue;
             const msg = (entry.message || entry);
             const role = (msg.role || entry.type || '');
-            if (role !== 'user')
+            if (role !== 'assistant' || !Array.isArray(msg.content))
                 continue;
-            if (Array.isArray(msg.content)) {
-                const isToolResult = msg.content
-                    .some(b => b?.type === 'tool_result');
-                if (isToolResult)
+            for (const b of msg.content) {
+                if (b?.type !== 'tool_use')
                     continue;
-            }
-            const text = extractText(msg.content);
-            if (text && !text.startsWith('<system') && !text.startsWith('{')) {
-                return text;
+                const tc = summarizeToolUse(b);
+                tc._useId = b.id || undefined;
+                localCalls.push(tc);
+                const input = (b.input || {});
+                if (['Edit', 'Write', 'MultiEdit'].includes(tc.name) && input.file_path) {
+                    filesTouched.add(input.file_path);
+                }
+                else if (tc.name === 'NotebookEdit' && input.notebook_path) {
+                    filesTouched.add(input.notebook_path);
+                }
             }
         }
-    }
-    catch { /* transcript read failed */ }
-    return '';
-}
-/** Detect action in the last assistant turn — reads transcript for tool_use blocks.
- * A single turn spans multiple requestIds (text → tool_use → tool_result → text → ...).
- * Walk backwards through the transcript; stop at a real user message (non-tool_result). */
-function detectAction(transcriptPath, agentProse) {
-    if (/```/.test(agentProse))
-        return true;
-    if (!transcriptPath)
-        return false;
-    try {
-        const raw = fs.readFileSync(transcriptPath, 'utf-8');
-        const lines = raw.split('\n');
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i].trim();
-            if (!line)
+        // Pair tool_results to outputs (same subagent transcript)
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
                 continue;
             let entry;
             try {
-                entry = JSON.parse(line);
+                entry = JSON.parse(trimmed);
             }
             catch {
                 continue;
             }
             const msg = (entry.message || entry);
             const role = (msg.role || entry.type || '');
-            if (role === 'user') {
-                if (Array.isArray(msg.content)) {
-                    const isToolResult = msg.content
-                        .some(b => b?.type === 'tool_result');
-                    if (isToolResult)
-                        continue;
-                }
-                break;
-            }
-            if (role === 'assistant' && Array.isArray(msg.content)) {
-                for (const b of msg.content) {
-                    if (b?.type === 'tool_use')
-                        return true;
+            if (role !== 'user' || !Array.isArray(msg.content))
+                continue;
+            for (const b of msg.content) {
+                if (b?.type !== 'tool_result')
+                    continue;
+                const useId = b.tool_use_id || '';
+                const out = extractToolResultText(b.content);
+                if (useId && out) {
+                    const tc = localCalls.find(c => c._useId === useId);
+                    if (tc)
+                        tc._output = out;
                 }
             }
         }
+        merged.push(...localCalls);
     }
-    catch { /* transcript read failed — fall through */ }
-    return false;
-}
-/** Parse <profile-summary> tag from agent response. Returns null if not found. */
-function parseProfileSummary(text) {
-    const match = text.match(/<profile-summary>([\s\S]*?)<\/profile-summary>/);
-    return match && match[1].trim() ? match[1].trim() : null;
-}
-/** Parse <profile-detail> tags from agent response. Returns array of details. */
-function parseProfileDetails(text) {
-    const results = [];
-    const regex = /<profile-detail>([\s\S]*?)<\/profile-detail>/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        const detail = match[1].trim();
-        if (detail)
-            results.push(detail);
-    }
-    return results;
-}
-/** Stop — store the turn. Reads user message from transcript (no prior caching). */
-async function store(input) {
-    const cwd = input.cwd || process.cwd();
-    const cfg = getConfig(cwd);
-    if (!cfg.enabled || !cfg.apiKey)
-        return;
-    const agentProse = input.last_assistant_message || '';
-    if (!agentProse)
-        return;
-    const userMessage = findLastUserMessage(input.transcript_path);
-    const sessionId = input.session_id || `hook-${Date.now()}`;
-    const profileId = path.basename(cwd);
-    const hasAction = detectAction(input.transcript_path, agentProse);
-    const storePromise = apiCall(`${cfg.apiUrl}/v1/memory/store`, cfg.apiKey, {
-        profileId,
-        sessionId,
-        userMessage,
-        agentProse,
-        hasAction,
-        crystallization: 'turn',
-    });
-    let profilePromise = null;
-    const profSummary = parseProfileSummary(agentProse);
-    const profDetails = parseProfileDetails(agentProse);
-    if (profSummary || profDetails.length > 0) {
-        profilePromise = apiCall(`${cfg.apiUrl}/v1/memory/profile/summary`, cfg.apiKey, {
-            profileId,
-            summary: profSummary || undefined,
-            details: profDetails.length > 0 && !profSummary ? profDetails : undefined,
-        });
-    }
-    await Promise.all([storePromise, profilePromise].filter(Boolean));
+    return { toolCalls: merged, filesTouched: Array.from(filesTouched).sort() };
 }
-/** Find the most recently modified plan file in ~/.claude/plans/ */
-function readNewestPlanFile() {
-    const plansDir = path.join(os.homedir(), '.claude', 'plans');
+// ---------- Git branch + artifact detection -------------------------------
+function getBranch(cwd) {
     try {
-        const files = fs.readdirSync(plansDir)
-            .filter(f => f.endsWith('.md'))
-            .map(f => {
-            const full = path.join(plansDir, f);
-            return { path: full, mtime: fs.statSync(full).mtimeMs };
-        })
-            .sort((a, b) => b.mtime - a.mtime);
-        if (!files.length)
-            return null;
-        if (Date.now() - files[0].mtime > 60_000)
-            return null;
-        return fs.readFileSync(files[0].path, 'utf-8');
+        const out = (0, child_process_1.execSync)('git branch --show-current', { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return out.trim() || null;
     }
     catch {
         return null;
     }
 }
-/** Format AskUserQuestion tool data into readable Q&A text. */
-function formatQuestionAnswers(toolInput, toolResponse) {
-    const questions = toolInput.questions;
-    const answers = toolResponse.answers;
-    if (!questions?.length)
-        return '';
-    const lines = [];
-    for (const q of questions) {
-        const question = q.question || '';
-        const answer = answers?.[question] || '';
-        if (question) {
-            lines.push(`Q: ${question}`);
-            lines.push(`A: ${answer || '(no answer)'}`);
-            lines.push('');
-        }
-    }
-    return lines.join('\n').trim();
+/** Parse a PR URL (number + url) out of `gh pr create` stdout. */
+function parsePrFromOutput(out, cmd) {
+    const m = out.match(/https:\/\/github\.com\/[^\/\s]+\/[^\/\s]+\/pull\/(\d+)/);
+    if (!m)
+        return null;
+    // Try to pull --title "..." from the command for a clean title
+    const titleM = cmd.match(/--title\s+["']([^"']+)["']/);
+    return { id: '#' + m[1], url: m[0], title: titleM ? titleM[1] : undefined };
 }
-/** PostToolUse — capture high-signal tool events (plan approvals, user answers). */
-async function signal(input) {
-    const cwd = input.cwd || process.cwd();
-    const cfg = getConfig(cwd);
-    if (!cfg.enabled || !cfg.apiKey)
-        return;
-    const toolName = input.tool_name || '';
-    const sessionId = input.session_id || `hook-${Date.now()}`;
-    const profileId = path.basename(cwd);
-    let userMessage = '';
-    let agentProse = '';
-    let crystallization = '';
-    if (toolName === 'ExitPlanMode') {
-        const planContent = readNewestPlanFile();
-        if (!planContent)
-            return;
-        userMessage = '[Plan Approved]';
-        const words = planContent.split(/\s+/);
-        agentProse = words.length > 2000
-            ? words.slice(0, 2000).join(' ') + '\n\n[truncated]'
-            : planContent;
-        crystallization = 'plan';
-    }
-    else if (toolName === 'AskUserQuestion') {
-        const toolInput = input.tool_input || {};
-        const toolResponse = input.tool_response || {};
-        const formatted = formatQuestionAnswers(toolInput, toolResponse);
-        if (!formatted)
-            return;
-        userMessage = formatted;
-        agentProse = '';
-        crystallization = 'decision';
-    }
-    else {
-        return;
-    }
-    await apiCall(`${cfg.apiUrl}/v1/memory/store`, cfg.apiKey, {
-        profileId,
-        sessionId,
-        userMessage,
-        agentProse,
-        crystallization,
-    });
+/** Parse a release URL out of `gh release create` stdout. */
+function parseReleaseFromOutput(out, cmd) {
+    const m = out.match(/https:\/\/github\.com\/[^\/\s]+\/[^\/\s]+\/releases\/tag\/(\S+)/);
+    if (!m)
+        return null;
+    const titleM = cmd.match(/--title\s+["']([^"']+)["']/);
+    return { id: m[1], url: m[0], title: titleM ? titleM[1] : m[1] };
 }
-function parseTranscript(transcriptPath) {
-    const userReqs = [];
-    const files = new Set();
-    const cmds = [];
-    const responses = new Map();
-    let raw;
-    try {
-        raw = fs.readFileSync(transcriptPath, 'utf-8');
-    }
-    catch {
+/** Parse `npm publish` stdout. Format: `+ pkg@1.2.3`. */
+function parseNpmPublishFromOutput(out) {
+    const m = out.match(/^\+\s+(\S+@\S+)/m);
+    if (!m)
         return null;
-    }
-    for (const line of raw.split('\n')) {
-        if (!line.trim())
+    return { id: m[1], url: null, title: m[1] };
+}
+/** Parse `wrangler deploy` stdout. Picks the "Current Version ID" line plus
+ *  worker name and URL. */
+function parseWranglerDeployFromOutput(out) {
+    const m = out.match(/Current Version ID:\s+([a-f0-9-]+)/i);
+    if (!m)
+        return null;
+    const urlM = out.match(/https:\/\/\S+\.workers\.dev/);
+    const workerM = out.match(/Uploaded (\S+)/);
+    return { id: m[1], url: urlM ? urlM[0] : null, title: workerM ? workerM[1] : undefined };
+}
+/** Detect artifacts from tool_calls. Real artifact IDs are parsed from tool
+ *  outputs where possible; falls back to "pending" if output is missing. */
+function detectArtifacts(toolCalls, cwd) {
+    const events = [];
+    let commitCount = 0;
+    let pushDetected = false;
+    for (const tc of toolCalls) {
+        if (tc.name !== 'Bash')
             continue;
-        let entry;
-        try {
-            entry = JSON.parse(line);
+        const cmd = (tc.brief || '').trim();
+        const out = tc._output || '';
+        if (/^git commit\b/.test(cmd) || /&&\s*git commit\b/.test(cmd))
+            commitCount++;
+        if (/^git push\b/.test(cmd) || /&&\s*git push\b/.test(cmd))
+            pushDetected = true;
+        if (/^gh pr create\b/.test(cmd) || /&&\s*gh pr create\b/.test(cmd)) {
+            const parsed = parsePrFromOutput(out, cmd);
+            events.push({
+                artifactType: 'pr',
+                artifactId: parsed?.id || 'pending',
+                artifactUrl: parsed?.url || null,
+                title: parsed?.title || cmd.slice(0, 120),
+            });
         }
-        catch {
-            continue;
+        if (/^gh release create\b/.test(cmd) || /&&\s*gh release create\b/.test(cmd)) {
+            const parsed = parseReleaseFromOutput(out, cmd);
+            events.push({
+                artifactType: 'release',
+                artifactId: parsed?.id || 'pending',
+                artifactUrl: parsed?.url || null,
+                title: parsed?.title || cmd.slice(0, 120),
+            });
         }
-        const msg = (entry.message || entry);
-        const role = (msg.role || entry.type || '');
-        const content = msg.content;
-        const reqId = (entry.requestId || '');
-        if (role === 'user') {
-            const text = extractText(content);
-            if (text.length > 5 && !text.startsWith('<system') && !text.startsWith('{'))
-                userReqs.push(text.slice(0, 300));
+        if (/\bnpm publish\b/.test(cmd)) {
+            const parsed = parseNpmPublishFromOutput(out);
+            events.push({
+                artifactType: 'release',
+                artifactId: parsed?.id || 'pending',
+                artifactUrl: parsed?.url || null,
+                title: parsed?.title || cmd.slice(0, 120),
+            });
         }
-        if (role === 'assistant') {
-            const text = extractText(content);
-            if (text.length > 20 && reqId && text.length > (responses.get(reqId)?.length || 0))
-                responses.set(reqId, text);
-            if (Array.isArray(content)) {
-                for (const b of content) {
-                    const block = b;
-                    if (block?.type !== 'tool_use')
-                        continue;
-                    const inp = (block.input || {});
-                    if (typeof inp !== 'object')
-                        continue;
-                    if ((block.name === 'Write' || block.name === 'Edit') && inp.file_path)
-                        files.add(inp.file_path);
-                    if (block.name === 'Bash' && inp.command)
-                        cmds.push(inp.description || inp.command.slice(0, 150));
-                }
+        if (/wrangler deploy\b/.test(cmd) || /npm run deploy\b/.test(cmd)) {
+            const parsed = parseWranglerDeployFromOutput(out);
+            events.push({
+                artifactType: 'deploy',
+                artifactId: parsed?.id || 'pending',
+                artifactUrl: parsed?.url || null,
+                title: parsed?.title || cmd.slice(0, 120),
+            });
+        }
+        if (/^git merge\b/.test(cmd)) {
+            events.push({
+                artifactType: 'merge', artifactId: 'pending',
+                artifactUrl: null, title: cmd.slice(0, 200),
+            });
+        }
+    }
+    // For commits: lookback in git log to recover SHA + subject for each commit.
+    if (commitCount > 0) {
+        try {
+            const log = (0, child_process_1.execSync)(`git log -${commitCount} --format=%H|%s`, {
+                cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            for (const line of log.trim().split('\n')) {
+                const idx = line.indexOf('|');
+                if (idx < 0)
+                    continue;
+                const sha = line.slice(0, idx);
+                const subject = line.slice(idx + 1);
+                if (sha)
+                    events.push({
+                        artifactType: 'commit', artifactId: sha,
+                        artifactUrl: null, title: subject,
+                    });
             }
         }
+        catch { /* git log failed */ }
     }
-    const seen = new Set();
-    const uniqueReqs = userReqs.map(r => r.split('\n')[0].slice(0, 150))
-        .filter(r => { if (seen.has(r))
-        return false; seen.add(r); return true; }).slice(-10);
-    return {
-        userReqs: uniqueReqs,
-        files: Array.from(files).sort(),
-        cmds: cmds.slice(-5),
-        responses: Array.from(responses.values()).slice(-3).map(r => {
-            const t = r.slice(0, 500);
-            const dot = t.lastIndexOf('.');
-            return dot > 200 ? t.slice(0, dot + 1) : t;
-        }),
+    // For pushes: capture HEAD SHA at hook time as the push tip.
+    if (pushDetected) {
+        try {
+            const sha = (0, child_process_1.execSync)('git rev-parse HEAD', {
+                cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            events.push({
+                artifactType: 'push', artifactId: sha,
+                artifactUrl: null, title: `push to ${getBranch(cwd) || 'unknown'}`,
+            });
+        }
+        catch { /* git command failed */ }
+    }
+    return events;
+}
+// ---------- Env-var scrubbing ---------------------------------------------
+/** Build a redaction map of value → [REDACTED:VAR_NAME] from .env files and process.env. */
+function buildRedactionMap(cwd) {
+    const entries = [];
+    const seenValues = new Set();
+    const addEntry = (key, value) => {
+        if (!value || value.length < 16)
+            return;
+        if (seenValues.has(value))
+            return;
+        seenValues.add(value);
+        entries.push([value, `[REDACTED:${key}]`]);
     };
+    // Walk up looking for .env files
+    let dir = path.resolve(cwd);
+    for (let depth = 0; depth < 8; depth++) {
+        const envPath = path.join(dir, '.env');
+        if (fs.existsSync(envPath)) {
+            try {
+                const raw = fs.readFileSync(envPath, 'utf-8');
+                for (const line of raw.split('\n')) {
+                    const m = line.match(/^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.+?)\s*$/);
+                    if (!m)
+                        continue;
+                    let value = m[2].trim();
+                    if ((value.startsWith('"') && value.endsWith('"')) ||
+                        (value.startsWith("'") && value.endsWith("'"))) {
+                        value = value.slice(1, -1);
+                    }
+                    addEntry(m[1], value);
+                }
+            }
+            catch { /* skip */ }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Process env
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === 'string')
+            addEntry(key, value);
+    }
+    // Sort by value length desc so longer values are replaced first
+    entries.sort((a, b) => b[0].length - a[0].length);
+    return entries;
 }
-/** Extract raw session text from transcript — shared by summary + farewell. */
-function extractSessionText(input) {
-    const transcriptPath = input.transcript_path || '';
-    if (!transcriptPath)
-        return null;
-    const parsed = parseTranscript(transcriptPath);
-    if (!parsed)
-        return null;
-    const cwd = input.cwd || process.cwd();
-    const parts = [];
-    if (parsed.userReqs.length)
-        parts.push('User requests: ' + parsed.userReqs.join('; '));
-    if (parsed.files.length)
-        parts.push('Files modified: ' + parsed.files.slice(0, 20).join(', '));
-    if (parsed.cmds.length)
-        parts.push('Commands: ' + parsed.cmds.join('; '));
-    if (parsed.responses.length)
-        parts.push('Recent context:\n' + parsed.responses.join('\n'));
-    const rawText = parts.join('\n\n');
-    if (!rawText.trim())
-        return null;
-    return { rawText, cwd, project: path.basename(cwd) };
+function scrubString(text, map) {
+    if (!text)
+        return text;
+    let out = text;
+    for (const [value, replacement] of map) {
+        if (out.includes(value))
+            out = out.split(value).join(replacement);
+    }
+    return out;
 }
-/** Store session text to API with compaction crystallization. */
-async function storeSessionSummary(input, rawText, cwd, project, label) {
-    const cfg = getConfig(cwd);
-    if (cfg.enabled && cfg.apiKey) {
-        await apiCall(`${cfg.apiUrl}/v1/memory/store`, cfg.apiKey, {
-            profileId: project,
-            sessionId: input.session_id || `hook-${Date.now()}`,
-            userMessage: label,
-            agentProse: rawText,
-            crystallization: 'compaction',
-        });
+function scrubObject(obj, map) {
+    if (typeof obj === 'string')
+        return scrubString(obj, map);
+    if (Array.isArray(obj))
+        return obj.map(o => scrubObject(o, map));
+    if (obj && typeof obj === 'object') {
+        const out = {};
+        for (const k of Object.keys(obj)) {
+            out[k] = scrubObject(obj[k], map);
+        }
+        return out;
     }
+    return obj;
 }
-/** PreCompact — extract raw session text, send to API for LLM summarization + storage. */
-async function summary(input) {
-    const extracted = extractSessionText(input);
-    if (!extracted)
-        return;
-    await storeSessionSummary(input, extracted.rawText, extracted.cwd, extracted.project, '[Session Summary]');
+// ---------- Field-size cap ------------------------------------------------
+function capField(text) {
+    if (!text || text.length <= MAX_FIELD_CHARS)
+        return text;
+    const truncated = text.slice(0, MAX_FIELD_CHARS);
+    const originalKb = (text.length / 1000).toFixed(1);
+    return `${truncated}\n\n[truncated: original ${originalKb}KB]`;
 }
-/** SessionEnd — store final session summary (fire-and-forget to survive teardown). */
-async function farewell(input) {
-    const extracted = extractSessionText(input);
-    if (!extracted)
-        return;
-    if (extracted.rawText.split(/\s+/).length < 30)
-        return;
-    const cfg = getConfig(extracted.cwd);
-    if (!cfg.enabled || !cfg.apiKey)
-        return;
-    fetch(`${cfg.apiUrl}/v1/memory/store`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${cfg.apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            profileId: extracted.project,
-            sessionId: input.session_id || `hook-${Date.now()}`,
-            userMessage: '[Session End]',
-            agentProse: extracted.rawText,
-            crystallization: 'compaction',
-        }),
-    }).catch(() => { });
-    await new Promise(resolve => setTimeout(resolve, 300));
-}
-function isOlderThanDays(isoDate, days) {
-    return Date.now() - new Date(isoDate).getTime() > days * 24 * 60 * 60 * 1000;
-}
-/** Fetch profile + session recap, inject into stdout with memory-tools reminder. */
-async function injectRecap(input, header, footer) {
+// ---------- Store ---------------------------------------------------------
+async function store(input) {
     const cwd = input.cwd || process.cwd();
     const cfg = getConfig(cwd);
     if (!cfg.enabled || !cfg.apiKey)
         return;
-    const profileId = path.basename(cwd);
-    const result = await apiCall(`${cfg.apiUrl}/v1/memory/recap`, cfg.apiKey, { profileId });
-    if (!result?.ok)
-        return;
-    const parts = [];
-    // Memory tools reminder — one line, always. Agent-intent: memory is pull-based.
-    parts.push(`[Memory available — search past sessions: \`greprag recall "<query>" --profile ${profileId}\`. Pending messages: \`greprag inbox --profile ${profileId}\`.]`);
-    const pSummary = result.profileSummary;
-    const pDetails = result.profileDetails || [];
-    if (pSummary || pDetails.length > 0) {
-        parts.push('--- PROFILE ---');
-        if (pSummary)
-            parts.push(pSummary);
-        for (const d of pDetails)
-            parts.push(`- ${d}`);
-    }
-    const stale = !pSummary
-        || pDetails.length > 5
-        || (result.profileSummaryUpdatedAt && isOlderThanDays(result.profileSummaryUpdatedAt, 7));
-    const signals = [];
-    if (stale)
-        signals.push('<profile-summary>what this project is, what we work on, current state</profile-summary>');
-    signals.push('<profile-detail>new fact about this project</profile-detail>');
-    parts.push(`[greprag-profile: ${signals.join(' + ')}]`);
-    if (result.found && result.enrichedSummary) {
-        parts.push(header);
-        parts.push(result.enrichedSummary);
-        parts.push(footer);
-    }
-    if (parts.length > 0) {
-        process.stdout.write(parts.join('\n') + '\n');
+    const anchor = (0, project_anchor_1.readAnchor)(cwd);
+    const turn = parseLatestTurn(input.transcript_path);
+    // Flatten subagent tool_use blocks into the main turn so artifact detection
+    // catches commits/deploys/PRs a subagent fired. See adr/raw-turn-capture.md.
+    if (input.transcript_path && turn.userStartTime) {
+        const sub = parseSubagentCalls(input.transcript_path, turn.userStartTime);
+        if (sub.toolCalls.length > 0) {
+            turn.toolCalls.push(...sub.toolCalls);
+            const filesSet = new Set([...turn.filesTouched, ...sub.filesTouched]);
+            turn.filesTouched = Array.from(filesSet).sort();
+        }
     }
+    // Empty turn — nothing to capture.
+    if (!turn.userPrompt && !turn.agentResponse && turn.toolCalls.length === 0)
+        return;
+    const branch = getBranch(cwd);
+    const shipEvents = detectArtifacts(turn.toolCalls, cwd);
+    // Env-var scrub
+    const redaction = buildRedactionMap(cwd);
+    const userPrompt = capField(scrubString(turn.userPrompt, redaction));
+    const agentResponse = capField(scrubString(turn.agentResponse, redaction));
+    // Strip internal-only fields (_output, _useId) before sending to API,
+    // then scrub. The internal fields fed detectArtifacts above.
+    const toolCallsForApi = turn.toolCalls.map(tc => ({
+        name: tc.name, target: tc.target, brief: tc.brief,
+    }));
+    const toolCalls = scrubObject(toolCallsForApi, redaction);
+    const artifactRefs = shipEvents.map(ev => `${ev.artifactType}:${ev.artifactId.slice(0, 12)}`);
+    await apiCall(`${cfg.apiUrl}/v1/memory/turn`, cfg.apiKey, {
+        projectId: anchor.projectId,
+        projectName: anchor.projectName,
+        branch,
+        workingDir: cwd,
+        sessionIdExternal: input.session_id || `hook-${Date.now()}`,
+        turnId: crypto.randomUUID(),
+        model: turn.model,
+        status: turn.status,
+        userPrompt,
+        agentResponse,
+        toolCalls,
+        filesTouched: turn.filesTouched,
+        artifacts: artifactRefs,
+        shipEvents,
+    });
 }
-/** SessionStart:startup|clear — inject last session summary + memory reminder. */
-async function recap(input) {
-    await injectRecap(input, '--- LAST SESSION (auto-generated) ---', '--- END LAST SESSION ---');
+/** SessionStart — fetch recent episodic activity for this project and print
+ *  to stdout. Claude Code injects the printed text as session context. Fires
+ *  once per session. No LLM call. */
+// ---------- Local-time formatting for recap display -----------------------
+// Storage stays UTC (Cloudflare crons can only fire on UTC). The recap runs
+// on the user's machine so it converts to local time for display, avoiding
+// the UTC-vs-local-day confusion when a UTC daily window straddles two
+// local calendar days.
+function localTzShort() {
+    const parts = new Intl.DateTimeFormat('en-US', { timeZoneName: 'short' })
+        .formatToParts(new Date());
+    return parts.find(p => p.type === 'timeZoneName')?.value || '';
+}
+function fmtLocalDayHour(iso) {
+    return new Intl.DateTimeFormat('en-US', {
+        month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', hour12: true,
+    }).format(new Date(iso));
 }
-/** SessionStart:compact recovery — reinject cached session summary + memory reminder. */
-async function recover(input) {
-    await injectRecap(input, '--- SESSION RECOVERY (auto-generated) ---', '--- END SESSION RECOVERY ---');
+function fmtLocalHour(iso) {
+    return new Intl.DateTimeFormat('en-US', {
+        hour: 'numeric', minute: '2-digit', hour12: true,
+    }).format(new Date(iso));
 }
-/** Manual handoff — store user-provided recap for next session (before /clear).
- *  Fire-and-forget: sends the API request, prints confirmation immediately,
- *  then exits after a short delay to let the TCP socket flush. */
-async function handoff(input) {
+async function recap(input) {
     const cwd = input.cwd || process.cwd();
     const cfg = getConfig(cwd);
-    if (!cfg.enabled || !cfg.apiKey) {
-        process.stderr.write('[greprag-hook] Memory hook not enabled or no API key\n');
+    if (!cfg.enabled || !cfg.apiKey)
+        return;
+    const anchor = (0, project_anchor_1.readAnchor)(cwd);
+    if (!anchor.projectId)
         return;
+    const now = new Date();
+    // Local midnight today — boundary for "today's hourlies" in the user's frame
+    const localMidnight = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    const fromIso = new Date(now.getTime() - 7 * 86400_000).toISOString();
+    const toIso = now.toISOString();
+    const tz = localTzShort();
+    const url = `${cfg.apiUrl}/v1/memory/by-period`
+        + `?projectId=${encodeURIComponent(anchor.projectId)}`
+        + `&from=${encodeURIComponent(fromIso)}`
+        + `&to=${encodeURIComponent(toIso)}`
+        + `&limit=200`;
+    let data = null;
+    try {
+        const res = await fetch(url, {
+            headers: { 'Authorization': `Bearer ${cfg.apiKey}` },
+        });
+        if (!res.ok)
+            return;
+        data = await res.json();
     }
-    const message = input.message || '';
-    if (!message) {
-        process.stderr.write('[greprag-hook] No handoff message provided\n');
+    catch {
         return;
     }
-    const profileId = path.basename(cwd);
-    const sessionId = input.session_id || `handoff-${Date.now()}`;
-    fetch(`${cfg.apiUrl}/v1/memory/store`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${cfg.apiKey}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            profileId,
-            sessionId,
-            userMessage: '[Session End]',
-            agentProse: message,
-            crystallization: 'compaction',
-        }),
-    }).catch(() => { });
-    process.stdout.write('Handoff stored. Next session will pick it up via recap.\n');
-    await new Promise(resolve => setTimeout(resolve, 300));
+    const memories = data?.memories || [];
+    if (memories.length === 0)
+        return;
+    // Bucket by crystallization
+    const dailies = memories.filter(m => m.crystallization === 'episodic-daily')
+        .sort((a, b) => (a.windowStart || '').localeCompare(b.windowStart || ''));
+    const hourlies = memories.filter(m => m.crystallization === 'episodic-hourly')
+        .sort((a, b) => (a.windowStart || '').localeCompare(b.windowStart || ''));
+    const shipEvents = memories.filter(m => m.crystallization === 'ship-event'
+        && m.artifactId
+        && m.artifactId !== 'pending').sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    // Most recent daily
+    const latestDaily = dailies[dailies.length - 1];
+    // Hourlies since LOCAL midnight today (the user's frame, not UTC's)
+    const todaysHourlies = hourlies.filter(h => h.windowStart && new Date(h.windowStart).getTime() >= localMidnight.getTime());
+    // Last 5 ship-events with real IDs
+    const recentShipEvents = shipEvents.slice(-5);
+    // Nothing useful to surface
+    if (!latestDaily && todaysHourlies.length === 0 && recentShipEvents.length === 0)
+        return;
+    const parts = [];
+    parts.push(`[Recent activity in ${anchor.projectName}] — times shown in ${tz}`);
+    if (latestDaily && latestDaily.windowStart && latestDaily.windowEnd) {
+        const range = `${fmtLocalDayHour(latestDaily.windowStart)} – ${fmtLocalDayHour(latestDaily.windowEnd)}`;
+        parts.push('');
+        parts.push(`Most recent daily (${range}):`);
+        parts.push(latestDaily.content);
+    }
+    if (todaysHourlies.length > 0) {
+        parts.push('');
+        parts.push(`Since midnight today (${fmtLocalDayHour(localMidnight.toISOString())}):`);
+        for (const h of todaysHourlies) {
+            if (!h.windowStart || !h.windowEnd)
+                continue;
+            const startHr = fmtLocalHour(h.windowStart);
+            const endHr = fmtLocalHour(h.windowEnd);
+            // Pull the first numbered item from the hourly content as the gist
+            const m = h.content.match(/^\s*[0-9]+[.)]\s+([\s\S]+?)(?=\n\s*[0-9]+[.)]|\nOpen:|\nShipped:|$)/);
+            let gist = m ? m[1].trim() : h.content.trim();
+            gist = gist.replace(/\s+/g, ' ');
+            if (gist.length > 220)
+                gist = gist.slice(0, 217) + '…';
+            parts.push(`- ${startHr} – ${endHr}: ${gist}`);
+        }
+    }
+    if (recentShipEvents.length > 0) {
+        parts.push('');
+        parts.push(`Recently shipped:`);
+        for (const s of recentShipEvents) {
+            const id = (s.artifactId || '').slice(0, 12);
+            // s.content is "<artifact_type>: <title>" — strip the prefix
+            const title = s.content.replace(/^[^:]+:\s*/, '').slice(0, 120);
+            const when = fmtLocalDayHour(s.createdAt);
+            parts.push(`- ${s.artifactType} ${id} (${when}): ${title}`);
+        }
+    }
+    process.stdout.write(parts.join('\n') + '\n');
 }
-const SUBCOMMANDS = ['store', 'signal', 'summary', 'recover', 'farewell', 'recap', 'handoff'];
 async function main() {
     const subcommand = process.argv[2];
-    if (!subcommand || !SUBCOMMANDS.includes(subcommand)) {
-        process.stderr.write(`Usage: greprag-hook <${SUBCOMMANDS.join('|')}>\n`);
+    if (subcommand !== 'store' && subcommand !== 'recap') {
+        process.stderr.write(`Usage: greprag-hook <store|recap>\n`);
         process.exit(1);
     }
     let input = {};
@@ -569,24 +810,9 @@ async function main() {
     catch {
         process.exit(0);
     }
-    if (subcommand === 'signal') {
-        await signal(input);
-    }
-    else if (subcommand === 'summary') {
-        await summary(input);
-    }
-    else if (subcommand === 'farewell') {
-        await farewell(input);
-    }
-    else if (subcommand === 'recover') {
-        await recover(input);
-    }
-    else if (subcommand === 'recap') {
+    if (subcommand === 'recap') {
         await recap(input);
     }
-    else if (subcommand === 'handoff') {
-        await handoff(input);
-    }
     else {
         await store(input);
     }