qualitative-research-pro 1.0.0

package/hooks/dist/passive-learner.mjs

@@ -0,0 +1,220 @@
+// src/passive-learner.ts
+import { readFileSync as readFileSync2, appendFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import { join as join2, extname, basename as basename2 } from "path";
+import { homedir } from "os";
+
+// src/shared/project-identity.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { readFileSync, existsSync } from "fs";
+import { join, basename, resolve } from "path";
+var cachedIdentity = null;
+function getProjectIdentity() {
+  if (cachedIdentity) return cachedIdentity;
+  const projectPath = getGitRoot();
+  if (!projectPath) return null;
+  const hash = createHash("md5").update(projectPath).digest("hex").slice(0, 12);
+  const name = detectProjectName(projectPath);
+  cachedIdentity = { hash, name, path: projectPath };
+  return cachedIdentity;
+}
+function getGitRoot() {
+  if (process.env.CLAUDE_PROJECT_DIR) {
+    return resolve(process.env.CLAUDE_PROJECT_DIR);
+  }
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      timeout: 500,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+function detectProjectName(projectPath) {
+  const pkgPath = join(projectPath, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.name && typeof pkg.name === "string") return pkg.name;
+    } catch {
+    }
+  }
+  const goModPath = join(projectPath, "go.mod");
+  if (existsSync(goModPath)) {
+    try {
+      const content = readFileSync(goModPath, "utf-8");
+      const match = /^module\s+(\S+)/m.exec(content);
+      if (match) {
+        const parts = match[1].trim().split("/");
+        return parts[parts.length - 1];
+      }
+    } catch {
+    }
+  }
+  const pyPath = join(projectPath, "pyproject.toml");
+  if (existsSync(pyPath)) {
+    try {
+      const content = readFileSync(pyPath, "utf-8");
+      const section = content.match(/\[project\]\s*\n([\s\S]*?)(?:\n\[|$)/);
+      if (section) {
+        const nameMatch = /^name\s*=\s*"(.+?)"/m.exec(section[1]);
+        if (nameMatch) return nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  const cargoPath = join(projectPath, "Cargo.toml");
+  if (existsSync(cargoPath)) {
+    try {
+      const content = readFileSync(cargoPath, "utf-8");
+      const section = content.match(/\[package\]\s*\n([\s\S]*?)(?:\n\[|$)/);
+      if (section) {
+        const nameMatch = /^name\s*=\s*"(.+?)"/m.exec(section[1]);
+        if (nameMatch) return nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  return basename(projectPath);
+}
+
+// src/passive-learner.ts
+var ERROR_FIX_PATTERNS = [
+  { error: /Cannot find module ['"](.+?)['"]/i, label: "missing-import" },
+  { error: /Property ['"](.+?)['"] does not exist/i, label: "missing-property" },
+  { error: /Type ['"](.+?)['"] is not assignable/i, label: "type-mismatch" },
+  { error: /ENOENT.*['"](.+?)['"]/i, label: "missing-file" },
+  { error: /SyntaxError/i, label: "syntax-error" }
+];
+function detectFilePattern(filePath) {
+  const ext = extname(filePath);
+  const name = basename2(filePath);
+  if (/\.(test|spec)\.(ts|js|tsx|jsx)$/.test(name)) {
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      session: "",
+      type: "file_pattern",
+      pattern: "test-file-creation",
+      detail: `Test file: ${name} (${ext})`,
+      confidence: 0.5
+    };
+  }
+  if (filePath.includes(".claude/hooks")) {
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      session: "",
+      type: "file_pattern",
+      pattern: "hook-development",
+      detail: `Hook file: ${name}`,
+      confidence: 0.5
+    };
+  }
+  return null;
+}
+function detectEditPattern(oldStr, newStr) {
+  if (!oldStr && /^import\s/.test(newStr.trim())) {
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      session: "",
+      type: "edit_pattern",
+      pattern: "add-import",
+      detail: newStr.trim().slice(0, 80),
+      confidence: 0.3
+    };
+  }
+  if (newStr.includes("try") && newStr.includes("catch") && !oldStr.includes("try")) {
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      session: "",
+      type: "edit_pattern",
+      pattern: "add-error-handling",
+      detail: "try-catch block added",
+      confidence: 0.4
+    };
+  }
+  if (/:\s*(string|number|boolean|Record|Array|Promise)/.test(newStr) && !/:\s*(string|number|boolean|Record|Array|Promise)/.test(oldStr)) {
+    return {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      session: "",
+      type: "edit_pattern",
+      pattern: "add-type-annotation",
+      detail: "Type annotation added",
+      confidence: 0.3
+    };
+  }
+  return null;
+}
+function detectErrorFix(output) {
+  if (!output) return null;
+  for (const { error, label } of ERROR_FIX_PATTERNS) {
+    const match = error.exec(output);
+    if (match) {
+      return {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        session: "",
+        type: "error_fix",
+        pattern: label,
+        detail: match[0].slice(0, 100),
+        confidence: 0.6
+      };
+    }
+  }
+  return null;
+}
+function main() {
+  let raw = "";
+  try {
+    raw = readFileSync2(0, "utf-8");
+  } catch {
+    return;
+  }
+  if (!raw) {
+    console.log("{}");
+    return;
+  }
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    console.log("{}");
+    return;
+  }
+  const instincts = [];
+  const sessionId = input.session_id?.slice(0, 8) || "unknown";
+  if (input.tool_name === "Edit" && input.tool_input?.file_path) {
+    const fileInst = detectFilePattern(input.tool_input.file_path);
+    if (fileInst) instincts.push({ ...fileInst, session: sessionId });
+    if (input.tool_input.old_string && input.tool_input.new_string) {
+      const editInst = detectEditPattern(input.tool_input.old_string, input.tool_input.new_string);
+      if (editInst) instincts.push({ ...editInst, session: sessionId });
+    }
+  }
+  if (input.tool_name === "Write" && input.tool_input?.file_path) {
+    const fileInst = detectFilePattern(input.tool_input.file_path);
+    if (fileInst) instincts.push({ ...fileInst, session: sessionId });
+  }
+  if (input.tool_name === "Bash" && input.tool_output) {
+    const errInst = detectErrorFix(input.tool_output);
+    if (errInst) instincts.push({ ...errInst, session: sessionId });
+  }
+  if (instincts.length > 0) {
+    const identity = getProjectIdentity();
+    if (identity) {
+      for (const inst of instincts) {
+        inst.project = identity.hash;
+        inst.projectName = identity.name;
+      }
+    }
+    const logDir = join2(homedir(), ".claude");
+    if (!existsSync2(logDir)) mkdirSync(logDir, { recursive: true });
+    const logPath = join2(logDir, "instincts.jsonl");
+    for (const inst of instincts) {
+      appendFileSync(logPath, JSON.stringify(inst) + "\n");
+    }
+  }
+  console.log("{}");
+}
+main();

package/hooks/dist/pre-compact-continuity.mjs

@@ -0,0 +1,467 @@
+// src/pre-compact-continuity.ts
+import * as fs2 from "fs";
+import * as path from "path";
+import { homedir as homedir2 } from "os";
+
+// src/transcript-parser.ts
+import * as fs from "fs";
+function parseTranscript(transcriptPath) {
+  const summary = {
+    lastTodos: [],
+    recentToolCalls: [],
+    lastAssistantMessage: "",
+    filesModified: [],
+    errorsEncountered: []
+  };
+  if (!fs.existsSync(transcriptPath)) {
+    return summary;
+  }
+  const content = fs.readFileSync(transcriptPath, "utf-8");
+  const lines = content.split("\n").filter((line) => line.trim());
+  const allToolCalls = [];
+  const modifiedFiles = /* @__PURE__ */ new Set();
+  const errors = [];
+  let lastTodoState = [];
+  let lastAssistant = "";
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.role === "assistant" && typeof entry.content === "string") {
+        lastAssistant = entry.content;
+      } else if (entry.type === "assistant" && typeof entry.content === "string") {
+        lastAssistant = entry.content;
+      }
+      if (entry.tool_name || entry.type === "tool_use") {
+        const toolName = entry.tool_name || entry.name;
+        if (toolName) {
+          const toolCall = {
+            name: toolName,
+            timestamp: entry.timestamp,
+            input: entry.tool_input,
+            success: true
+            // Will be updated by result
+          };
+          if (toolName === "TodoWrite" || toolName.toLowerCase().includes("todowrite")) {
+            const input = entry.tool_input;
+            if (input?.todos) {
+              lastTodoState = input.todos.map((t, idx) => ({
+                id: t.id || `todo-${idx}`,
+                content: t.content || "",
+                status: t.status || "pending"
+              }));
+            }
+          }
+          if (toolName === "Edit" || toolName === "Write" || toolName.toLowerCase().includes("edit") || toolName.toLowerCase().includes("write")) {
+            const input = entry.tool_input;
+            const filePath = input?.file_path || input?.path;
+            if (filePath && typeof filePath === "string") {
+              modifiedFiles.add(filePath);
+            }
+          }
+          if (toolName === "Bash" || toolName.toLowerCase().includes("bash")) {
+            const input = entry.tool_input;
+            if (input?.command) {
+              toolCall.input = { command: input.command };
+            }
+          }
+          allToolCalls.push(toolCall);
+        }
+      }
+      if (entry.type === "tool_result" || entry.tool_result !== void 0) {
+        const result = entry.tool_result;
+        if (result) {
+          const exitCode = result.exit_code ?? result.exitCode;
+          if (exitCode !== void 0 && exitCode !== 0) {
+            if (allToolCalls.length > 0) {
+              allToolCalls[allToolCalls.length - 1].success = false;
+            }
+            const errorMsg = result.stderr || result.error || "Command failed";
+            const lastTool = allToolCalls[allToolCalls.length - 1];
+            const command = lastTool?.input?.command || "unknown command";
+            errors.push(`${command}: ${errorMsg.substring(0, 200)}`);
+          }
+        }
+        if (entry.error) {
+          errors.push(entry.error.substring(0, 200));
+          if (allToolCalls.length > 0) {
+            allToolCalls[allToolCalls.length - 1].success = false;
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  summary.lastTodos = lastTodoState;
+  summary.recentToolCalls = allToolCalls.slice(-5);
+  summary.lastAssistantMessage = lastAssistant.substring(0, 500);
+  summary.filesModified = Array.from(modifiedFiles);
+  summary.errorsEncountered = errors.slice(-5);
+  return summary;
+}
+function generateAutoHandoff(summary, sessionName) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const dateOnly = timestamp.split("T")[0];
+  const lines = [];
+  const inProgress = summary.lastTodos.filter((t) => t.status === "in_progress");
+  const pending = summary.lastTodos.filter((t) => t.status === "pending");
+  const completed = summary.lastTodos.filter((t) => t.status === "completed");
+  const currentTask = inProgress[0]?.content || pending[0]?.content || "Continue from auto-compact";
+  const goalSummary = completed.length > 0 ? `Completed ${completed.length} task(s) before auto-compact` : "Session auto-compacted";
+  lines.push("---");
+  lines.push(`session: ${sessionName}`);
+  lines.push(`date: ${dateOnly}`);
+  lines.push("status: partial");
+  lines.push("outcome: PARTIAL_PLUS");
+  lines.push("---");
+  lines.push("");
+  lines.push(`goal: ${goalSummary}`);
+  lines.push(`now: ${currentTask}`);
+  lines.push("test: # No test command captured");
+  lines.push("");
+  lines.push("done_this_session:");
+  if (completed.length > 0) {
+    completed.forEach((t) => {
+      lines.push(`  - task: "${t.content.replace(/"/g, '\\"')}"`);
+      lines.push("    files: []");
+    });
+  } else {
+    lines.push('  - task: "Session started"');
+    lines.push("    files: []");
+  }
+  lines.push("");
+  lines.push("blockers:");
+  if (summary.errorsEncountered.length > 0) {
+    summary.errorsEncountered.slice(0, 3).forEach((e) => {
+      const safeError = e.replace(/"/g, '\\"').substring(0, 100);
+      lines.push(`  - "${safeError}"`);
+    });
+  } else {
+    lines.push("  []");
+  }
+  lines.push("");
+  lines.push("questions:");
+  if (pending.length > 0) {
+    pending.slice(0, 3).forEach((t) => {
+      lines.push(`  - "Resume: ${t.content.replace(/"/g, '\\"')}"`);
+    });
+  } else {
+    lines.push("  []");
+  }
+  lines.push("");
+  lines.push("decisions:");
+  lines.push('  - auto_compact: "Context limit reached, auto-compacted"');
+  lines.push("");
+  lines.push("findings:");
+  lines.push(`  - tool_calls: "${summary.recentToolCalls.length} recent tool calls"`);
+  lines.push(`  - files_modified: "${summary.filesModified.length} files changed"`);
+  lines.push("");
+  lines.push("worked:");
+  const successfulTools = summary.recentToolCalls.filter((t) => t.success);
+  if (successfulTools.length > 0) {
+    lines.push(`  - "${successfulTools.map((t) => t.name).join(", ")} completed successfully"`);
+  } else {
+    lines.push("  []");
+  }
+  lines.push("");
+  lines.push("failed:");
+  const failedTools = summary.recentToolCalls.filter((t) => !t.success);
+  if (failedTools.length > 0) {
+    lines.push(`  - "${failedTools.map((t) => t.name).join(", ")} encountered errors"`);
+  } else {
+    lines.push("  []");
+  }
+  lines.push("");
+  lines.push("next:");
+  if (inProgress.length > 0) {
+    lines.push(`  - "Continue: ${inProgress[0].content.replace(/"/g, '\\"')}"`);
+  }
+  if (pending.length > 0) {
+    pending.slice(0, 2).forEach((t) => {
+      lines.push(`  - "${t.content.replace(/"/g, '\\"')}"`);
+    });
+  }
+  if (inProgress.length === 0 && pending.length === 0) {
+    lines.push('  - "Review session state and continue"');
+  }
+  lines.push("");
+  lines.push("files:");
+  lines.push("  created: []");
+  lines.push("  modified:");
+  if (summary.filesModified.length > 0) {
+    summary.filesModified.slice(0, 10).forEach((f) => {
+      lines.push(`    - "${f}"`);
+    });
+  } else {
+    lines.push("    []");
+  }
+  return lines.join("\n");
+}
+var isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log("Usage: npx tsx transcript-parser.ts <transcript-path> [session-name]");
+    process.exit(1);
+  }
+  const transcriptPath = args[0];
+  const sessionName = args[1] || "test-session";
+  console.log(`Parsing transcript: ${transcriptPath}`);
+  const summary = parseTranscript(transcriptPath);
+  console.log("\n--- Summary ---");
+  console.log(JSON.stringify(summary, null, 2));
+  console.log("\n--- Auto-Handoff ---");
+  console.log(generateAutoHandoff(summary, sessionName));
+}
+
+// src/shared/hook-profiler.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/shared/log-rotation.ts
+import { statSync, readFileSync as readFileSync2, writeFileSync, appendFileSync, renameSync, unlinkSync } from "fs";
+function appendWithRotation(filePath, line, maxBytes = 2 * 1024 * 1024, keepLines = 5e3) {
+  appendFileSync(filePath, line);
+  try {
+    const stats = statSync(filePath);
+    if (stats.size > maxBytes) {
+      const tmpPath = filePath + ".rotating";
+      try {
+        renameSync(filePath, tmpPath);
+        const content = readFileSync2(tmpPath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.length > 0);
+        writeFileSync(filePath, lines.slice(-keepLines).join("\n") + "\n");
+        unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+// src/shared/hook-profiler.ts
+var PERF_LOG = join(homedir(), ".claude", "cache", "hook-perf.jsonl");
+var MAX_LOG_SIZE = 1024 * 1024;
+function startTimer() {
+  return process.hrtime.bigint();
+}
+function endTimer(start, hookName, eventType, sessionId = "unknown") {
+  const elapsed = Number(process.hrtime.bigint() - start) / 1e6;
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    hook: hookName,
+    event: eventType,
+    duration_ms: Math.round(elapsed * 100) / 100,
+    session: sessionId.slice(0, 8)
+  };
+  try {
+    const cacheDir = join(homedir(), ".claude", "cache");
+    if (!existsSync2(cacheDir)) mkdirSync(cacheDir, { recursive: true });
+    appendWithRotation(PERF_LOG, JSON.stringify(entry) + "\n", MAX_LOG_SIZE, 3e3);
+  } catch {
+  }
+}
+
+// src/pre-compact-continuity.ts
+async function main() {
+  const _perfStart = startTimer();
+  const input = JSON.parse(await readStdin());
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const ledgerDir = path.join(projectDir, "thoughts", "ledgers");
+  if (!fs2.existsSync(ledgerDir)) {
+    const output = {
+      continue: true,
+      systemMessage: "[PreCompact] No ledger directory found."
+    };
+    endTimer(_perfStart, "pre-compact-continuity", "PreCompact");
+    console.log(JSON.stringify(output));
+    return;
+  }
+  const ledgerFiles = fs2.readdirSync(ledgerDir).filter((f) => f.startsWith("CONTINUITY_CLAUDE-") && f.endsWith(".md"));
+  if (ledgerFiles.length === 0) {
+    const output = {
+      continue: true,
+      systemMessage: "[PreCompact] No ledger found. Create one? /continuity_ledger"
+    };
+    endTimer(_perfStart, "pre-compact-continuity", "PreCompact");
+    console.log(JSON.stringify(output));
+    return;
+  }
+  const mostRecent = ledgerFiles.sort((a, b) => {
+    const statA = fs2.statSync(path.join(ledgerDir, a));
+    const statB = fs2.statSync(path.join(ledgerDir, b));
+    return statB.mtime.getTime() - statA.mtime.getTime();
+  })[0];
+  const ledgerPath = path.join(ledgerDir, mostRecent);
+  if (input.trigger === "auto") {
+    const sessionName = mostRecent.replace("CONTINUITY_CLAUDE-", "").replace(".md", "");
+    let handoffFile = "";
+    if (input.transcript_path && fs2.existsSync(input.transcript_path)) {
+      const summary = parseTranscript(input.transcript_path);
+      const handoffContent = generateAutoHandoff(summary, sessionName);
+      const handoffDir = path.join(projectDir, "thoughts", "shared", "handoffs", sessionName);
+      fs2.mkdirSync(handoffDir, { recursive: true });
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      handoffFile = `auto-handoff-${timestamp}.yaml`;
+      const handoffPath = path.join(handoffDir, handoffFile);
+      fs2.writeFileSync(handoffPath, handoffContent);
+      const briefSummary = generateAutoSummary(projectDir, input.session_id);
+      if (briefSummary) {
+        appendToLedger(ledgerPath, briefSummary);
+      }
+    } else {
+      const briefSummary = generateAutoSummary(projectDir, input.session_id);
+      if (briefSummary) {
+        appendToLedger(ledgerPath, briefSummary);
+      }
+    }
+    const message = handoffFile ? `[PreCompact:auto] Created YAML handoff: thoughts/shared/handoffs/${sessionName}/${handoffFile}` : `[PreCompact:auto] Session summary auto-appended to ${mostRecent}`;
+    const output = {
+      continue: true,
+      systemMessage: message
+    };
+    endTimer(_perfStart, "pre-compact-continuity", "PreCompact");
+    console.log(JSON.stringify(output));
+  } else {
+    const output = {
+      continue: true,
+      systemMessage: `[PreCompact] Consider updating ledger before compacting: /continuity_ledger
+Ledger: ${mostRecent}`
+    };
+    endTimer(_perfStart, "pre-compact-continuity", "PreCompact");
+    console.log(JSON.stringify(output));
+  }
+}
+function extractStrategicContext(sessionId) {
+  const lines = [];
+  const claudeDir = path.join(homedir2(), ".claude");
+  const ledgerPath = path.join(claudeDir, "canavar", "error-ledger.jsonl");
+  if (fs2.existsSync(ledgerPath)) {
+    try {
+      const allErrors = fs2.readFileSync(ledgerPath, "utf-8").split("\n").filter((l) => l.trim());
+      const sessionErrors = allErrors.map((l) => {
+        try {
+          return JSON.parse(l);
+        } catch {
+          return null;
+        }
+      }).filter((e) => e && e.session === sessionId?.slice(0, 8));
+      if (sessionErrors.length > 0) {
+        const patterns = [...new Set(sessionErrors.map((e) => e.error_pattern))];
+        lines.push(`- Basarisiz yaklasimlar: ${patterns.slice(0, 5).join(", ")}`);
+      }
+    } catch {
+    }
+  }
+  const intentPath = path.join(claudeDir, "cache", "current-intent.json");
+  if (fs2.existsSync(intentPath)) {
+    try {
+      const intent = JSON.parse(fs2.readFileSync(intentPath, "utf-8"));
+      if (intent.task_type && intent.task_type !== "conversational") {
+        lines.push(`- Kullanici hedefi: ${intent.task_type} (domain: ${intent.domain?.join(", ") || "genel"})`);
+      }
+    } catch {
+    }
+  }
+  const maturePath = path.join(claudeDir, "mature-instincts.json");
+  if (fs2.existsSync(maturePath)) {
+    try {
+      const instincts = JSON.parse(fs2.readFileSync(maturePath, "utf-8"));
+      const recent = instincts.filter((i) => i.confidence >= 5).slice(0, 3).map((i) => `${i.pattern}(${i.confidence}x)`);
+      if (recent.length > 0) {
+        lines.push(`- Gozlemlenen pattern'lar: ${recent.join(", ")}`);
+      }
+    } catch {
+    }
+  }
+  return lines;
+}
+function generateAutoSummary(projectDir, sessionId) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  const cacheDir = path.join(projectDir, ".claude", "tsc-cache", sessionId || "default");
+  const editedFilesPath = path.join(cacheDir, "edited-files.log");
+  let editedFiles = [];
+  if (fs2.existsSync(editedFilesPath)) {
+    const content = fs2.readFileSync(editedFilesPath, "utf-8");
+    editedFiles = [...new Set(
+      content.split("\n").filter((line) => line.trim()).map((line) => {
+        const parts = line.split(":");
+        return parts[1]?.replace(projectDir + "/", "") || "";
+      }).filter((f) => f)
+    )];
+  }
+  const gitClaudeDir = path.join(projectDir, ".git", "claude", "branches");
+  let buildAttempts = { passed: 0, failed: 0 };
+  if (fs2.existsSync(gitClaudeDir)) {
+    try {
+      const branches = fs2.readdirSync(gitClaudeDir);
+      for (const branch of branches) {
+        const attemptsFile = path.join(gitClaudeDir, branch, "attempts.jsonl");
+        if (fs2.existsSync(attemptsFile)) {
+          const content = fs2.readFileSync(attemptsFile, "utf-8");
+          content.split("\n").filter((l) => l.trim()).forEach((line) => {
+            try {
+              const attempt = JSON.parse(line);
+              if (attempt.type === "build_pass") buildAttempts.passed++;
+              if (attempt.type === "build_fail") buildAttempts.failed++;
+            } catch {
+            }
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const strategicLines = extractStrategicContext(sessionId);
+  if (editedFiles.length === 0 && buildAttempts.passed === 0 && buildAttempts.failed === 0 && strategicLines.length === 0) {
+    return null;
+  }
+  lines.push(`
+## Session Auto-Summary (${timestamp})`);
+  if (editedFiles.length > 0) {
+    lines.push(`- Files changed: ${editedFiles.slice(0, 10).join(", ")}${editedFiles.length > 10 ? ` (+${editedFiles.length - 10} more)` : ""}`);
+  }
+  if (buildAttempts.passed > 0 || buildAttempts.failed > 0) {
+    lines.push(`- Build/test: ${buildAttempts.passed} passed, ${buildAttempts.failed} failed`);
+  }
+  if (strategicLines.length > 0) {
+    lines.push("- Stratejik context:");
+    for (const sl of strategicLines) {
+      lines.push(`  ${sl}`);
+    }
+  }
+  return lines.join("\n");
+}
+function appendToLedger(ledgerPath, summary) {
+  try {
+    let content = fs2.readFileSync(ledgerPath, "utf-8");
+    const stateMatch = content.match(/## State\n/);
+    if (stateMatch) {
+      const nowMatch = content.match(/(\n-\s*Now:)/);
+      if (nowMatch && nowMatch.index) {
+        content = content.slice(0, nowMatch.index) + summary + content.slice(nowMatch.index);
+      } else {
+        const nextSection = content.indexOf("\n## ", content.indexOf("## State") + 1);
+        if (nextSection > 0) {
+          content = content.slice(0, nextSection) + summary + "\n" + content.slice(nextSection);
+        } else {
+          content += summary;
+        }
+      }
+    } else {
+      content += summary;
+    }
+    fs2.writeFileSync(ledgerPath, content);
+  } catch (err) {
+  }
+}
+async function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve(data));
+  });
+}
+main().catch(console.error);