clawstrap 1.3.0 → 1.4.0

package/dist/index.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,6 +30,199 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/watch/dedup.ts
+function tokenize(text) {
+  const words = text.split(/\s+/).map((w) => w.replace(/[^a-z0-9]/gi, "").toLowerCase()).filter(Boolean);
+  return new Set(words);
+}
+function jaccard(a, b) {
+  const setA = tokenize(a);
+  const setB = tokenize(b);
+  if (setA.size === 0 && setB.size === 0) return 1;
+  if (setA.size === 0 || setB.size === 0) return 0;
+  let intersection = 0;
+  for (const token of setA) {
+    if (setB.has(token)) intersection++;
+  }
+  const union = setA.size + setB.size - intersection;
+  return intersection / union;
+}
+function isDuplicate(newEntry, existingEntries, threshold = 0.75) {
+  for (const existing of existingEntries) {
+    if (jaccard(newEntry, existing) >= threshold) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseMemoryEntries(content) {
+  const lines = content.split("\n");
+  const entries = [];
+  let current = [];
+  for (const line of lines) {
+    if (line.startsWith("---")) {
+      if (current.length > 0) {
+        const entry = current.join("\n").trim();
+        if (entry) entries.push(entry);
+        current = [];
+      }
+    } else {
+      current.push(line);
+    }
+  }
+  if (current.length > 0) {
+    const entry = current.join("\n").trim();
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+var init_dedup = __esm({
+  "src/watch/dedup.ts"() {
+    "use strict";
+  }
+});
+
+// src/watch/writers.ts
+var writers_exports = {};
+__export(writers_exports, {
+  appendToFutureConsiderations: () => appendToFutureConsiderations,
+  appendToGotchaLog: () => appendToGotchaLog,
+  appendToMemory: () => appendToMemory,
+  writeConventions: () => writeConventions
+});
+function formatEntry(source, text) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  return `---
+[${source}] ${ts}
+${text}`;
+}
+function appendToMemory(rootDir, entries, source) {
+  const memoryPath = import_node_path15.default.join(rootDir, ".claude", "memory", "MEMORY.md");
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(memoryPath), { recursive: true });
+  let existingContent = "";
+  if (import_node_fs14.default.existsSync(memoryPath)) {
+    existingContent = import_node_fs14.default.readFileSync(memoryPath, "utf-8");
+  }
+  const existingEntries = parseMemoryEntries(existingContent);
+  const toAppend = [];
+  for (const entry of entries) {
+    if (!isDuplicate(entry, existingEntries)) {
+      toAppend.push(formatEntry(source, entry));
+    }
+  }
+  if (toAppend.length > 0) {
+    const appendText = "\n" + toAppend.join("\n") + "\n";
+    import_node_fs14.default.appendFileSync(memoryPath, appendText, "utf-8");
+  }
+}
+function appendToGotchaLog(rootDir, entries) {
+  const logPath = import_node_path15.default.join(rootDir, ".claude", "gotcha-log.md");
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(logPath), { recursive: true });
+  if (!import_node_fs14.default.existsSync(logPath)) {
+    import_node_fs14.default.writeFileSync(
+      logPath,
+      "# Gotcha Log\n\nIncident log \u2014 why rules exist.\n\n",
+      "utf-8"
+    );
+  }
+  const toAppend = entries.map((e) => formatEntry("session", e)).join("\n");
+  import_node_fs14.default.appendFileSync(logPath, "\n" + toAppend + "\n", "utf-8");
+}
+function appendToFutureConsiderations(rootDir, entries) {
+  const fcPath = import_node_path15.default.join(rootDir, ".claude", "future-considerations.md");
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(fcPath), { recursive: true });
+  if (!import_node_fs14.default.existsSync(fcPath)) {
+    import_node_fs14.default.writeFileSync(
+      fcPath,
+      "# Future Considerations\n\nDeferred ideas and potential improvements.\n\n",
+      "utf-8"
+    );
+  }
+  const toAppend = entries.map((e) => formatEntry("session", e)).join("\n");
+  import_node_fs14.default.appendFileSync(fcPath, "\n" + toAppend + "\n", "utf-8");
+}
+function buildAutoBlock(sections) {
+  const lines = [AUTO_START];
+  lines.push("## Naming Conventions");
+  if (sections.naming.length > 0) {
+    for (const item of sections.naming) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No naming conventions detected.");
+  }
+  lines.push("");
+  lines.push("## Import Style");
+  if (sections.imports.length > 0) {
+    for (const item of sections.imports) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No import patterns detected.");
+  }
+  lines.push("");
+  lines.push("## Testing");
+  if (sections.testing.length > 0) {
+    for (const item of sections.testing) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No test files detected.");
+  }
+  lines.push("");
+  lines.push("## Error Handling");
+  if (sections.errorHandling.length > 0) {
+    for (const item of sections.errorHandling) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No error handling patterns detected.");
+  }
+  lines.push("");
+  lines.push("## Comments");
+  if (sections.comments.length > 0) {
+    for (const item of sections.comments) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No comment patterns detected.");
+  }
+  lines.push(AUTO_END);
+  return lines.join("\n");
+}
+function writeConventions(rootDir, sections) {
+  const conventionsPath = import_node_path15.default.join(rootDir, ".claude", "rules", "conventions.md");
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(conventionsPath), { recursive: true });
+  const autoBlock = buildAutoBlock(sections);
+  if (!import_node_fs14.default.existsSync(conventionsPath)) {
+    const content = [
+      "# Conventions",
+      "",
+      "> Auto-generated by `clawstrap analyze`. Do not edit the AUTO block manually.",
+      "",
+      autoBlock,
+      "",
+      "<!-- Add manual conventions below this line -->",
+      ""
+    ].join("\n");
+    import_node_fs14.default.writeFileSync(conventionsPath, content, "utf-8");
+    return;
+  }
+  const existing = import_node_fs14.default.readFileSync(conventionsPath, "utf-8");
+  const startIdx = existing.indexOf(AUTO_START);
+  const endIdx = existing.indexOf(AUTO_END);
+  if (startIdx === -1 || endIdx === -1) {
+    const updated = existing.trimEnd() + "\n\n" + autoBlock + "\n";
+    import_node_fs14.default.writeFileSync(conventionsPath, updated, "utf-8");
+  } else {
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + AUTO_END.length);
+    const updated = before + autoBlock + after;
+    import_node_fs14.default.writeFileSync(conventionsPath, updated, "utf-8");
+  }
+}
+var import_node_fs14, import_node_path15, AUTO_START, AUTO_END;
+var init_writers = __esm({
+  "src/watch/writers.ts"() {
+    "use strict";
+    import_node_fs14 = __toESM(require("fs"), 1);
+    import_node_path15 = __toESM(require("path"), 1);
+    init_dedup();
+    AUTO_START = "<!-- CLAWSTRAP:AUTO -->";
+    AUTO_END = "<!-- CLAWSTRAP:END -->";
+  }
+});
+
 // src/index.ts
 var import_commander = require("commander");
 
@@ -58,6 +258,18 @@ var ClawstrapConfigSchema = import_zod.z.object({
   qualityLevel: import_zod.z.enum(QUALITY_LEVELS),
   sessionHandoff: import_zod.z.boolean(),
   sdd: import_zod.z.boolean().default(false),
+  watch: import_zod.z.object({
+    adapter: import_zod.z.enum(["claude-local", "claude-api", "ollama", "codex-local"]).default("claude-local"),
+    scan: import_zod.z.object({
+      intervalDays: import_zod.z.number().default(7)
+    }).default({}),
+    silent: import_zod.z.boolean().default(false)
+  }).optional(),
+  watchState: import_zod.z.object({
+    lastGitCommit: import_zod.z.string().optional(),
+    lastScanAt: import_zod.z.string().optional(),
+    lastTranscriptAt: import_zod.z.string().optional()
+  }).optional(),
   lastExport: LastExportSchema
 });
 
@@ -239,7 +451,7 @@ var governance_file_md_default = "# {%governanceFile%} \u2014 Master Governance
 var getting_started_md_default = "# Getting Started \u2014 {%workspaceName%}\n> Generated by Clawstrap v{%clawstrapVersion%} on {%generatedDate%}\n\nWelcome to your AI agent workspace. This workspace is configured for\n**{%workloadLabel%}** workflows.\n\n---\n\n## Quick Start\n\n1. **Read `{%governanceFile%}`** \u2014 this is your master governance file. It loads\n   automatically every session and defines the rules your AI assistant follows.\n\n2. **Check `{%systemDir%}/rules/`** \u2014 these rule files also load every session.\n   They contain detailed procedures for context discipline, approval workflows,\n   and quality gates.\n\n3. **Start working** \u2014 open a Claude Code session in this directory. The\n   governance files will load automatically.\n\n---\n\n## What's in This Workspace\n\n```\n{%governanceFile%}                    \u2190 Master governance (always loaded)\nGETTING_STARTED.md               \u2190 You are here\n.clawstrap.json                  \u2190 Your workspace configuration\n\n{%systemDir%}/\n  rules/                         \u2190 Auto-loaded rules (every session)\n  skills/                        \u2190 Skill definitions (loaded when triggered)\n{%#if hasSubagents%}  agents/                        \u2190 Agent definitions\n{%/if%}  gotcha-log.md                  \u2190 Incident log\n  future-considerations.md       \u2190 Deferred ideas\n{%#if sessionHandoff%}  memory/                        \u2190 Persistent memory across sessions\n{%/if%}\nprojects/\n  _template/                     \u2190 Template for new projects\n\ntmp/                             \u2190 Temporary files (gitignored)\nresearch/                        \u2190 Reference material\ncontext/                         \u2190 Session checkpoints\nartifacts/                       \u2190 Durable output\n{%#if sddEnabled%}specs/\n  _template.md                   \u2190 Spec template (copy for each feature)\n{%/if%}```\n\n---\n\n## Key Principles\n\nThis workspace enforces five principles:\n\n1. **If it's not on disk, it didn't happen.** Context windows compress. Sessions\n   end. The only thing that persists is files. Flush work {%flushCadence%}.\n\n2. **Approval-first, always.** Plan work, get approval, then execute. No\n   speculative actions.\n\n3. **Quality is a structural gate.** Quality checks happen during work, not after.\n{%#if hasQualityGates%}   See `{%systemDir%}/rules/quality-gates.md` for the full procedure.{%/if%}\n\n4. **Disagreements reveal ambiguity.** When agents disagree, the rules are\n   ambiguous. Escalate and clarify \u2014 don't suppress.\n\n5. **One decision at a time.** Binary decisions made sequentially compound into\n   reliable outcomes.\n{%#if hasSubagents%}\n\n---\n\n## Working with Multiple Agents\n\nYour workspace is configured for multi-agent workflows. Key rules:\n\n- **Subagents write to `tmp/`** \u2014 they return file paths and one-line summaries,\n  never raw data in conversation.\n- **The main session is an orchestrator** \u2014 it tracks progress, launches agents,\n  and checks output files. It does not hold subagent data in memory.\n- **Agent definitions live in `{%systemDir%}/agents/`** \u2014 each file becomes the\n  system prompt for a subagent. Governance is baked into the definition.\n{%/if%}\n{%#if sessionHandoff%}\n\n---\n\n## Session Handoff\n\nThis workspace uses session handoff checklists. At the end of every session:\n\n1. Save all work to SSOT files\n2. Sync derived files\n3. Check SSOT integrity\n4. Update progress tracker\n5. Write next-session plan\n6. Run QC on session work\n\nThis ensures no context is lost between sessions.\n{%/if%}\n{%#if isResearch%}\n\n---\n\n## Research Tips\n\n- Write findings to disk immediately \u2014 don't accumulate in conversation\n- Cite sources for every claim\n- Separate facts from interpretation\n- Use `research/` for reference material, `artifacts/` for synthesis output\n{%/if%}\n{%#if isContent%}\n\n---\n\n## Content Workflow Tips\n\n- Every piece follows: draft \u2192 review \u2192 approve\n- Track revision feedback in dedicated files\n- Never finalize without explicit approval\n- Use `artifacts/` for final deliverables\n{%/if%}\n{%#if isDataProcessing%}\n\n---\n\n## Data Processing Tips\n\n- Define batch size before starting any processing run\n- Validate schema on every write\n- Checkpoint every 5 batch items\n- Log all transformations for auditability\n{%/if%}\n\n---\n\n{%#if sddEnabled%}\n\n---\n\n## Spec-Driven Development\n\nThis workspace enforces a spec-first workflow. Before any implementation:\n\n1. **Type `/spec`** to start a new spec interactively \u2014 Claude will guide you\n2. Or copy `specs/_template.md` manually, fill it in, and get approval\n3. Only implement after the spec is approved\n\nYour specs live in `specs/`. Each approved spec is the contract between you and\nClaude \u2014 implementation follows the spec, not the conversation.\n\nSee `{%systemDir%}/rules/sdd.md` for the full rules and exemptions.\n{%/if%}\n\n---\n\n*This workspace was generated by [Clawstrap](https://github.com/clawstrap/clawstrap).\nEdit any file to fit your needs \u2014 there's no lock-in.*\n";
 
 // src/templates/gitignore.tmpl
-var gitignore_default = "# Dependencies\nnode_modules/\n\n# Temporary files (subagent output, session data)\ntmp/\n\n# Secrets\n.env\n.env.*\ncredentials.json\n*.pem\n*.key\n\n# OS\n.DS_Store\nThumbs.db\n\n# Editor\n*.swp\n*.swo\n*~\n";
+var gitignore_default = "# Dependencies\nnode_modules/\n\n# Temporary files (subagent output, session data)\ntmp/\n\n# Secrets\n.env\n.env.*\ncredentials.json\n*.pem\n*.key\n\n# OS\n.DS_Store\nThumbs.db\n\n# Editor\n*.swp\n*.swo\n*~\n.clawstrap.watch.pid\ntmp/sessions/\n";
 
 // src/templates/rules/context-discipline.md.tmpl
 var context_discipline_md_default = "# Rule: Context Discipline\n> **Scope**: All sessions | **Generated**: {%generatedDate%}\n\n## Flush Cadence\n\nFlush working state to file {%flushCadence%}:\n- Write current state to a context checkpoint file\n- Include: what's done, what's next, accumulated results\n- Path: `context/checkpoint-{date}-{task}.md`\n{%#if hasSubagents%}\n\n## Subagent Output Rules\n\nSubagents MUST:\n1. Write all output to `tmp/{task}/{name}.json` (or `.md`)\n2. Return a one-line receipt: `\"Done. N items. File: {path}. Summary: {1 line}.\"`\n3. NOT dump raw results into the conversation\n\nMain session MUST:\n- Only read the subagent file if needed for the NEXT step\n- Never hold subagent output in conversation memory\n\n## Thin Orchestrator Principle\n\nDuring batch work, the main session is an orchestrator only:\n\n**DO**:\n- Track queue / done / next\n- Launch agents with correct prompts\n- Check output files for completeness\n- Update SSOT data files\n- Run QC gates\n\n**DO NOT**:\n- Read raw extraction data into main context\n- Classify results (agents do that)\n- Hold full subagent output in conversation\n{%/if%}\n\n## Before Batch Work\n\nAlways write an execution plan to `tmp/{task}/plan.md` before starting.\nThis file must survive context loss and be readable by any future session.\n\n## On User Correction\n\n1. FIRST write the correction to its durable home (memory/rule/skill file)\n2. THEN apply the correction to current work\n\nThis ensures the learning persists even if the session ends unexpectedly.\n";
@@ -771,8 +983,43 @@ Error: project "${name}" already exists at projects/${name}/
 }
 
 // src/status.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+
+// src/watch/pid.ts
 var import_node_fs7 = __toESM(require("fs"), 1);
 var import_node_path8 = __toESM(require("path"), 1);
+var PID_FILE = ".clawstrap.watch.pid";
+function pidPath(rootDir) {
+  return import_node_path8.default.join(rootDir, PID_FILE);
+}
+function writePid(rootDir, pid) {
+  import_node_fs7.default.writeFileSync(pidPath(rootDir), String(pid), "utf-8");
+}
+function readPid(rootDir) {
+  const p = pidPath(rootDir);
+  if (!import_node_fs7.default.existsSync(p)) return null;
+  const raw = import_node_fs7.default.readFileSync(p, "utf-8").trim();
+  const pid = parseInt(raw, 10);
+  return isNaN(pid) ? null : pid;
+}
+function clearPid(rootDir) {
+  const p = pidPath(rootDir);
+  if (import_node_fs7.default.existsSync(p)) import_node_fs7.default.unlinkSync(p);
+}
+function isDaemonRunning(rootDir) {
+  const pid = readPid(rootDir);
+  if (pid === null) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    clearPid(rootDir);
+    return false;
+  }
+}
+
+// src/status.ts
 var WORKLOAD_LABELS3 = {
   research: "Research & Analysis",
   content: "Content & Writing",
@@ -780,22 +1027,22 @@ var WORKLOAD_LABELS3 = {
   custom: "General Purpose"
 };
 function countEntries(dir, exclude = []) {
-  if (!import_node_fs7.default.existsSync(dir)) return 0;
-  return import_node_fs7.default.readdirSync(dir, { withFileTypes: true }).filter((e) => !exclude.includes(e.name) && !e.name.startsWith(".")).length;
+  if (!import_node_fs8.default.existsSync(dir)) return 0;
+  return import_node_fs8.default.readdirSync(dir, { withFileTypes: true }).filter((e) => !exclude.includes(e.name) && !e.name.startsWith(".")).length;
 }
 function countSkills(skillsDir) {
-  if (!import_node_fs7.default.existsSync(skillsDir)) return 0;
-  return import_node_fs7.default.readdirSync(skillsDir, { withFileTypes: true }).filter(
-    (e) => e.isDirectory() && import_node_fs7.default.existsSync(import_node_path8.default.join(skillsDir, e.name, "SKILL.md"))
+  if (!import_node_fs8.default.existsSync(skillsDir)) return 0;
+  return import_node_fs8.default.readdirSync(skillsDir, { withFileTypes: true }).filter(
+    (e) => e.isDirectory() && import_node_fs8.default.existsSync(import_node_path9.default.join(skillsDir, e.name, "SKILL.md"))
   ).length;
 }
 async function showStatus() {
   const { config, vars, rootDir } = loadWorkspace();
   const systemDir = String(vars.systemDir);
-  const agentsDir = import_node_path8.default.join(rootDir, systemDir, "agents");
-  const skillsDir = import_node_path8.default.join(rootDir, systemDir, "skills");
-  const rulesDir = import_node_path8.default.join(rootDir, systemDir, "rules");
-  const projectsDir = import_node_path8.default.join(rootDir, "projects");
+  const agentsDir = import_node_path9.default.join(rootDir, systemDir, "agents");
+  const skillsDir = import_node_path9.default.join(rootDir, systemDir, "skills");
+  const rulesDir = import_node_path9.default.join(rootDir, systemDir, "rules");
+  const projectsDir = import_node_path9.default.join(rootDir, "projects");
   const agentCount = countEntries(agentsDir, ["_template.md"]);
   const skillCount = countSkills(skillsDir);
   const projectCount = countEntries(projectsDir, ["_template"]);
@@ -829,32 +1076,48 @@ Last Export:`);
     console.log(`  Date:      ${exportDate}`);
     console.log(`  Output:    ${config.lastExport.outputDir}`);
   }
+  const watchRunning = isDaemonRunning(rootDir);
+  console.log(`
+Watch:`);
+  console.log(`  Status:    ${watchRunning ? "running" : "stopped"}`);
+  if (config.watch) {
+    console.log(`  Adapter:   ${config.watch.adapter}`);
+  }
+  if (config.watchState?.lastGitCommit) {
+    console.log(`  Last git:  ${config.watchState.lastGitCommit.slice(0, 8)}`);
+  }
+  if (config.watchState?.lastScanAt) {
+    console.log(`  Last scan: ${config.watchState.lastScanAt.split("T")[0]}`);
+  }
+  if (config.watchState?.lastTranscriptAt) {
+    console.log(`  Last transcript: ${config.watchState.lastTranscriptAt.replace("T", " ").slice(0, 16)}`);
+  }
   console.log();
 }
 
 // src/export-paperclip.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 var import_prompts7 = require("@inquirer/prompts");
 
 // src/export-paperclip/translate-agents.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 function slugToName(slug) {
   return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
 function translateAgents(rootDir, systemDir, workspaceName, skillSlugs) {
-  const agentsDir = import_node_path9.default.join(rootDir, systemDir, "agents");
+  const agentsDir = import_node_path10.default.join(rootDir, systemDir, "agents");
   const agents = [];
   const workerNames = [];
   const workerAgents = [];
-  if (import_node_fs8.default.existsSync(agentsDir)) {
-    for (const entry of import_node_fs8.default.readdirSync(agentsDir)) {
+  if (import_node_fs9.default.existsSync(agentsDir)) {
+    for (const entry of import_node_fs9.default.readdirSync(agentsDir)) {
       if (entry === "primary-agent.md" || entry === "_template.md" || entry.startsWith(".") || !entry.endsWith(".md")) {
         continue;
       }
       const slug = entry.replace(/\.md$/, "");
-      const rawBody = import_node_fs8.default.readFileSync(import_node_path9.default.join(agentsDir, entry), "utf-8");
+      const rawBody = import_node_fs9.default.readFileSync(import_node_path10.default.join(agentsDir, entry), "utf-8");
       const roleMatch = rawBody.match(/^>\s*\*\*Purpose\*\*:\s*(.+)/m);
       const description = roleMatch ? roleMatch[1].trim() : "";
       const name = slugToName(slug);
@@ -964,8 +1227,8 @@ When your work is complete, hand off to the **CEO** for review routing. If a rev
 }
 
 // src/export-paperclip/translate-governance.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 var GOVERNANCE_TIERS = {
   solo: {
     tier: "light",
@@ -999,39 +1262,39 @@ function getGovernanceConfig(qualityLevel) {
 }
 
 // src/export-paperclip/translate-skills.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 function translateSkills(rootDir, systemDir) {
-  const skillsDir = import_node_path11.default.join(rootDir, systemDir, "skills");
+  const skillsDir = import_node_path12.default.join(rootDir, systemDir, "skills");
   const skills = [];
-  if (!import_node_fs10.default.existsSync(skillsDir)) return skills;
-  for (const entry of import_node_fs10.default.readdirSync(skillsDir, { withFileTypes: true })) {
+  if (!import_node_fs11.default.existsSync(skillsDir)) return skills;
+  for (const entry of import_node_fs11.default.readdirSync(skillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillMdPath = import_node_path11.default.join(skillsDir, entry.name, "SKILL.md");
-    if (!import_node_fs10.default.existsSync(skillMdPath)) continue;
+    const skillMdPath = import_node_path12.default.join(skillsDir, entry.name, "SKILL.md");
+    if (!import_node_fs11.default.existsSync(skillMdPath)) continue;
     skills.push({
       name: entry.name,
       sourcePath: `${systemDir}/skills/${entry.name}/SKILL.md`,
-      content: import_node_fs10.default.readFileSync(skillMdPath, "utf-8")
+      content: import_node_fs11.default.readFileSync(skillMdPath, "utf-8")
     });
   }
   return skills;
 }
 
 // src/export-paperclip/translate-goals.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 function translateGoals(rootDir) {
-  const projectsDir = import_node_path12.default.join(rootDir, "projects");
+  const projectsDir = import_node_path13.default.join(rootDir, "projects");
   const goals = [];
-  if (!import_node_fs11.default.existsSync(projectsDir)) return goals;
-  for (const entry of import_node_fs11.default.readdirSync(projectsDir, { withFileTypes: true })) {
+  if (!import_node_fs12.default.existsSync(projectsDir)) return goals;
+  for (const entry of import_node_fs12.default.readdirSync(projectsDir, { withFileTypes: true })) {
     if (!entry.isDirectory() || entry.name === "_template" || entry.name.startsWith(".")) {
       continue;
     }
-    const readmePath = import_node_path12.default.join(projectsDir, entry.name, "README.md");
-    if (!import_node_fs11.default.existsSync(readmePath)) continue;
-    const content = import_node_fs11.default.readFileSync(readmePath, "utf-8");
+    const readmePath = import_node_path13.default.join(projectsDir, entry.name, "README.md");
+    if (!import_node_fs12.default.existsSync(readmePath)) continue;
+    const content = import_node_fs12.default.readFileSync(readmePath, "utf-8");
     const descMatch = content.match(
       /## What This Project Is\s*\n+([\s\S]*?)(?=\n---|\n##|$)/
     );
@@ -1059,7 +1322,7 @@ async function exportPaperclip(options) {
     default: `Governed AI workspace for ${String(vars.workloadLabel).toLowerCase()}`
   });
   const companySlug = toSlug(companyName);
-  const outDir = import_node_path13.default.resolve(
+  const outDir = import_node_path14.default.resolve(
     options.out ?? `${config.workspaceName}-paperclip`
   );
   const skills = translateSkills(rootDir, systemDir);
@@ -1089,7 +1352,7 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
     console.log("\nValidation passed. Run without --validate to export.\n");
     return;
   }
-  if (import_node_fs12.default.existsSync(outDir)) {
+  if (import_node_fs13.default.existsSync(outDir)) {
     const proceed = await (0, import_prompts7.confirm)({
       message: `Output directory already exists at ${outDir}. Overwrite?`,
       default: false
@@ -1098,10 +1361,10 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
       console.log("Aborted.\n");
       return;
     }
-    import_node_fs12.default.rmSync(outDir, { recursive: true, force: true });
+    import_node_fs13.default.rmSync(outDir, { recursive: true, force: true });
   }
   console.log("\nExporting to Paperclip format (agentcompanies/v1)...\n");
-  import_node_fs12.default.mkdirSync(outDir, { recursive: true });
+  import_node_fs13.default.mkdirSync(outDir, { recursive: true });
   const goalsYaml = goals.length > 0 ? goals.map((g) => `  - ${g.description.split("\n")[0]}`).join("\n") : `  - ${mission}`;
   const pipelineLines = agents.map((a, i) => {
     return `${i + 1}. **${a.name}** ${a.title.toLowerCase()}`;
@@ -1131,17 +1394,17 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
     `Generated with [Clawstrap](https://github.com/peppinho89/clawstrap) v${CLI_VERSION}`,
     ""
   ].join("\n");
-  import_node_fs12.default.writeFileSync(import_node_path13.default.join(outDir, "COMPANY.md"), companyMd, "utf-8");
+  import_node_fs13.default.writeFileSync(import_node_path14.default.join(outDir, "COMPANY.md"), companyMd, "utf-8");
   console.log("  \u2713 COMPANY.md");
-  import_node_fs12.default.writeFileSync(
-    import_node_path13.default.join(outDir, ".paperclip.yaml"),
+  import_node_fs13.default.writeFileSync(
+    import_node_path14.default.join(outDir, ".paperclip.yaml"),
     "schema: paperclip/v1\n",
     "utf-8"
   );
   console.log("  \u2713 .paperclip.yaml");
   for (const agent of agents) {
-    const agentDir = import_node_path13.default.join(outDir, "agents", agent.slug);
-    import_node_fs12.default.mkdirSync(agentDir, { recursive: true });
+    const agentDir = import_node_path14.default.join(outDir, "agents", agent.slug);
+    import_node_fs13.default.mkdirSync(agentDir, { recursive: true });
     const frontmatterLines = [
       "---",
       `name: ${agent.name}`,
@@ -1156,12 +1419,12 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
     }
     frontmatterLines.push("---");
     const agentMd = frontmatterLines.join("\n") + "\n\n" + agent.body + "\n";
-    import_node_fs12.default.writeFileSync(import_node_path13.default.join(agentDir, "AGENTS.md"), agentMd, "utf-8");
+    import_node_fs13.default.writeFileSync(import_node_path14.default.join(agentDir, "AGENTS.md"), agentMd, "utf-8");
     console.log(`  \u2713 agents/${agent.slug}/AGENTS.md`);
   }
   if (nonCeoAgents.length > 0) {
-    const teamDir = import_node_path13.default.join(outDir, "teams", "engineering");
-    import_node_fs12.default.mkdirSync(teamDir, { recursive: true });
+    const teamDir = import_node_path14.default.join(outDir, "teams", "engineering");
+    import_node_fs13.default.mkdirSync(teamDir, { recursive: true });
     const includesList = nonCeoAgents.map((a) => `  - ../../agents/${a.slug}/AGENTS.md`).join("\n");
     const teamMd = [
       "---",
@@ -1178,13 +1441,13 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
       `The engineering team at ${companyName}. Led by the CEO, who scopes and delegates work to specialists.`,
       ""
     ].join("\n");
-    import_node_fs12.default.writeFileSync(import_node_path13.default.join(teamDir, "TEAM.md"), teamMd, "utf-8");
+    import_node_fs13.default.writeFileSync(import_node_path14.default.join(teamDir, "TEAM.md"), teamMd, "utf-8");
     console.log("  \u2713 teams/engineering/TEAM.md");
   }
   for (const skill of skills) {
-    const skillDir = import_node_path13.default.join(outDir, "skills", skill.name);
-    import_node_fs12.default.mkdirSync(skillDir, { recursive: true });
-    import_node_fs12.default.writeFileSync(import_node_path13.default.join(skillDir, "SKILL.md"), skill.content, "utf-8");
+    const skillDir = import_node_path14.default.join(outDir, "skills", skill.name);
+    import_node_fs13.default.mkdirSync(skillDir, { recursive: true });
+    import_node_fs13.default.writeFileSync(import_node_path14.default.join(skillDir, "SKILL.md"), skill.content, "utf-8");
     console.log(`  \u2713 skills/${skill.name}/SKILL.md`);
   }
   const importScript = [
@@ -1200,26 +1463,26 @@ ${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
     'echo "Done. Open your Paperclip dashboard to review."',
     ""
   ].join("\n");
-  const importPath = import_node_path13.default.join(outDir, "import.sh");
-  import_node_fs12.default.writeFileSync(importPath, importScript, "utf-8");
-  import_node_fs12.default.chmodSync(importPath, 493);
+  const importPath = import_node_path14.default.join(outDir, "import.sh");
+  import_node_fs13.default.writeFileSync(importPath, importScript, "utf-8");
+  import_node_fs13.default.chmodSync(importPath, 493);
   console.log("  \u2713 import.sh");
   const updatedConfig = {
     ...config,
     lastExport: {
       format: "paperclip",
       exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      outputDir: import_node_path13.default.relative(rootDir, outDir) || outDir
+      outputDir: import_node_path14.default.relative(rootDir, outDir) || outDir
     }
   };
-  import_node_fs12.default.writeFileSync(
-    import_node_path13.default.join(rootDir, ".clawstrap.json"),
+  import_node_fs13.default.writeFileSync(
+    import_node_path14.default.join(rootDir, ".clawstrap.json"),
     JSON.stringify(updatedConfig, null, 2) + "\n",
     "utf-8"
   );
   console.log(
     `
-Exported to ${import_node_path13.default.relative(process.cwd(), outDir) || outDir}`
+Exported to ${import_node_path14.default.relative(process.cwd(), outDir) || outDir}`
   );
   console.log(
     `${agents.length} agent(s), ${skills.length} skill(s), ${goals.length} goal(s)`
@@ -1228,9 +1491,737 @@ Exported to ${import_node_path13.default.relative(process.cwd(), outDir) || outD
 `);
 }
 
+// src/watch.ts
+var import_node_path20 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+var import_node_fs19 = __toESM(require("fs"), 1);
+
+// src/watch/git.ts
+var import_node_child_process = require("child_process");
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
+init_writers();
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "fix",
+  "add",
+  "update",
+  "remove",
+  "feat",
+  "chore",
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "is",
+  "was",
+  "be",
+  "it",
+  "as",
+  "with",
+  "by",
+  "this",
+  "that"
+]);
+function parseGitLog(output) {
+  const entries = [];
+  const lines = output.split("\n");
+  let current = null;
+  for (const line of lines) {
+    if (line.includes("|||")) {
+      if (current) entries.push(current);
+      const parts = line.split("|||");
+      current = {
+        sha: parts[0]?.trim() ?? "",
+        subject: parts[1]?.trim() ?? "",
+        author: parts[2]?.trim() ?? "",
+        date: parts[3]?.trim() ?? "",
+        files: []
+      };
+    } else if (line.trim() && current) {
+      current.files.push(line.trim());
+    }
+  }
+  if (current) entries.push(current);
+  return entries.filter((e) => e.sha.length > 0);
+}
+function getTopDirs(entries) {
+  const dirCount = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const seenDirs = /* @__PURE__ */ new Set();
+    for (const file of entry.files) {
+      const dir = import_node_path16.default.dirname(file);
+      if (dir !== "." && !seenDirs.has(dir)) {
+        seenDirs.add(dir);
+        dirCount.set(dir, (dirCount.get(dir) ?? 0) + 1);
+      }
+    }
+  }
+  return Array.from(dirCount.entries()).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([dir]) => dir);
+}
+function getCoChangingFiles(entries, minCommits = 3) {
+  const pairCount = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const files = entry.files.slice().sort();
+    for (let i = 0; i < files.length; i++) {
+      for (let j = i + 1; j < files.length; j++) {
+        const key = `${files[i]}|||${files[j]}`;
+        pairCount.set(key, (pairCount.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  return Array.from(pairCount.entries()).filter(([, count]) => count >= minCommits).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([key]) => key.split("|||"));
+}
+function getRecurringWords(entries) {
+  const wordCount = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const words = entry.subject.toLowerCase().split(/\s+/).map((w) => w.replace(/[^a-z0-9]/g, "")).filter((w) => w.length > 2 && !STOPWORDS.has(w));
+    for (const word of new Set(words)) {
+      wordCount.set(word, (wordCount.get(word) ?? 0) + 1);
+    }
+  }
+  return Array.from(wordCount.entries()).filter(([, count]) => count >= 2).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([word]) => word);
+}
+async function runGitObserver(rootDir, sinceCommit) {
+  if (!import_node_fs15.default.existsSync(import_node_path16.default.join(rootDir, ".git"))) {
+    return null;
+  }
+  let headSha;
+  try {
+    headSha = (0, import_node_child_process.execSync)(`git -C "${rootDir}" rev-parse HEAD`, {
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    return null;
+  }
+  if (!headSha) return null;
+  if (sinceCommit && sinceCommit === headSha) {
+    return { lastCommit: headSha, entriesWritten: 0 };
+  }
+  let logOutput;
+  try {
+    const rangeArg = sinceCommit ? `${sinceCommit}..HEAD` : "";
+    const cmd = `git -C "${rootDir}" log ${rangeArg} --pretty=format:"%H|||%s|||%ae|||%ad" --date=short --name-only`;
+    logOutput = (0, import_node_child_process.execSync)(cmd, { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+  if (!logOutput) {
+    return { lastCommit: headSha, entriesWritten: 0 };
+  }
+  const entries = parseGitLog(logOutput);
+  if (entries.length === 0) {
+    return { lastCommit: headSha, entriesWritten: 0 };
+  }
+  const memoryEntries = [];
+  const coChangingPairs = getCoChangingFiles(entries, 3);
+  if (coChangingPairs.length > 0) {
+    const pairs = coChangingPairs.map(([a, b]) => `${a} <-> ${b}`).join(", ");
+    memoryEntries.push(`Co-changing file pairs (frequently modified together): ${pairs}`);
+  }
+  const topDirs = getTopDirs(entries);
+  if (topDirs.length > 0) {
+    memoryEntries.push(`Top high-churn directories (most commits): ${topDirs.join(", ")}`);
+  }
+  const recurringWords = getRecurringWords(entries);
+  if (recurringWords.length > 0) {
+    memoryEntries.push(`Recurring themes in recent commits: ${recurringWords.join(", ")}`);
+  }
+  const dateRange = entries.length > 0 ? `from ${entries[entries.length - 1]?.date ?? "?"} to ${entries[0]?.date ?? "?"}` : "";
+  memoryEntries.push(
+    `Git history analyzed: ${entries.length} commit(s) ${dateRange}. Authors: ${[...new Set(entries.map((e) => e.author))].join(", ")}`
+  );
+  if (memoryEntries.length > 0) {
+    appendToMemory(rootDir, memoryEntries, "git");
+  }
+  return { lastCommit: headSha, entriesWritten: memoryEntries.length };
+}
+
+// src/watch/scan.ts
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "tmp", "dist", ".claude"]);
+var CODE_EXTS = /* @__PURE__ */ new Set([".ts", ".js", ".tsx", ".jsx"]);
+function walkDir(dir, maxDepth = 10, depth = 0) {
+  if (depth > maxDepth) return [];
+  let results = [];
+  let entries;
+  try {
+    entries = import_node_fs16.default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    const fullPath = import_node_path17.default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results = results.concat(walkDir(fullPath, maxDepth, depth + 1));
+    } else if (entry.isFile()) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function detectNamingCase(name) {
+  if (/^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(name)) return "kebab-case";
+  if (/^[A-Z][A-Z0-9_]*$/.test(name)) return "other";
+  if (/^[A-Z][a-zA-Z0-9]+$/.test(name)) return "PascalCase";
+  if (/^[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*$/.test(name)) return "camelCase";
+  if (/^[a-z][a-z0-9]*(_[a-z0-9]+)+$/.test(name)) return "snake_case";
+  return "other";
+}
+function analyzeNaming(files) {
+  const counts = {
+    "kebab-case": 0,
+    camelCase: 0,
+    snake_case: 0,
+    PascalCase: 0,
+    other: 0
+  };
+  const examples = {
+    "kebab-case": [],
+    camelCase: [],
+    snake_case: [],
+    PascalCase: [],
+    other: []
+  };
+  for (const file of files) {
+    const base = import_node_path17.default.basename(file, import_node_path17.default.extname(file));
+    const style2 = detectNamingCase(base);
+    counts[style2]++;
+    if (examples[style2].length < 3) examples[style2].push(base);
+  }
+  const dominant = Object.entries(counts).sort((a, b) => b[1] - a[1]).filter(([key]) => key !== "other")[0];
+  if (!dominant || dominant[1] === 0) {
+    return ["No dominant file naming convention detected."];
+  }
+  const [style, count] = dominant;
+  const exampleList = examples[style].slice(0, 3).join(", ");
+  const result = [`Dominant file naming: ${style} (${count} files). Examples: ${exampleList}`];
+  const total = Object.values(counts).reduce((a, b) => a + b, 0) - counts.other;
+  if (total > 0) {
+    const pct = Math.round(count / total * 100);
+    result.push(`${style} used in ${pct}% of named files.`);
+  }
+  return result;
+}
+function analyzeImports(files) {
+  const sample = files.filter((f) => CODE_EXTS.has(import_node_path17.default.extname(f))).slice(0, 20);
+  let relativeCount = 0;
+  let absoluteCount = 0;
+  let barrelCount = 0;
+  for (const file of sample) {
+    let content;
+    try {
+      content = import_node_fs16.default.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const importLines = content.split("\n").filter((l) => /^import\s/.test(l));
+    for (const line of importLines) {
+      if (/from\s+['"]\.\.?\//.test(line)) relativeCount++;
+      else if (/from\s+['"]/.test(line)) absoluteCount++;
+    }
+    const base = import_node_path17.default.basename(file, import_node_path17.default.extname(file));
+    if (base === "index") barrelCount++;
+  }
+  const results = [];
+  const total = relativeCount + absoluteCount;
+  if (total > 0) {
+    const relPct = Math.round(relativeCount / total * 100);
+    results.push(
+      `Import style: ${relPct}% relative (./), ${100 - relPct}% absolute/alias. Analyzed ${sample.length} files.`
+    );
+  } else {
+    results.push("No import statements found in sampled files.");
+  }
+  if (barrelCount > 0) {
+    results.push(`Barrel exports detected: ${barrelCount} index file(s) found.`);
+  }
+  return results;
+}
+function analyzeTesting(files) {
+  const testPatterns = [];
+  let hasTestExt = false;
+  let hasSpecExt = false;
+  let hasTestsDir = false;
+  for (const file of files) {
+    const base = import_node_path17.default.basename(file);
+    if (/\.test\.(ts|js|tsx|jsx)$/.test(base)) hasTestExt = true;
+    if (/\.spec\.(ts|js|tsx|jsx)$/.test(base)) hasSpecExt = true;
+    if (file.includes("/__tests__/") || file.includes("\\__tests__\\")) hasTestsDir = true;
+  }
+  if (hasTestExt) testPatterns.push("*.test.ts/js");
+  if (hasSpecExt) testPatterns.push("*.spec.ts/js");
+  if (hasTestsDir) testPatterns.push("__tests__/ directories");
+  if (testPatterns.length === 0) {
+    return ["No test files detected."];
+  }
+  return [`Test patterns found: ${testPatterns.join(", ")}`];
+}
+function analyzeErrorHandling(files) {
+  const sample = files.filter((f) => CODE_EXTS.has(import_node_path17.default.extname(f))).slice(0, 20);
+  let tryCatchCount = 0;
+  let resultTypeCount = 0;
+  for (const file of sample) {
+    let content;
+    try {
+      content = import_node_fs16.default.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const tryCatches = (content.match(/\btry\s*\{/g) ?? []).length;
+    const resultTypes = (content.match(/Result<|Either</g) ?? []).length;
+    tryCatchCount += tryCatches;
+    resultTypeCount += resultTypes;
+  }
+  const results = [];
+  if (tryCatchCount > 0 && resultTypeCount === 0) {
+    results.push(`Error handling: try/catch dominant (${tryCatchCount} occurrences in ${sample.length} files).`);
+  } else if (resultTypeCount > 0 && tryCatchCount === 0) {
+    results.push(`Error handling: Result/Either type pattern dominant (${resultTypeCount} occurrences).`);
+  } else if (tryCatchCount > 0 && resultTypeCount > 0) {
+    const dominant = tryCatchCount >= resultTypeCount ? "try/catch" : "Result/Either";
+    results.push(
+      `Error handling: mixed \u2014 ${tryCatchCount} try/catch and ${resultTypeCount} Result/Either. Dominant: ${dominant}.`
+    );
+  } else {
+    results.push(`No explicit error handling patterns detected in ${sample.length} sampled files.`);
+  }
+  return results;
+}
+function analyzeComments(files) {
+  const sample = files.filter((f) => CODE_EXTS.has(import_node_path17.default.extname(f))).slice(0, 20);
+  let jsdocCount = 0;
+  let inlineCount = 0;
+  let totalLines = 0;
+  for (const file of sample) {
+    let content;
+    try {
+      content = import_node_fs16.default.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split("\n");
+    totalLines += lines.length;
+    jsdocCount += (content.match(/\/\*\*/g) ?? []).length;
+    inlineCount += lines.filter((l) => /^\s*\/\//.test(l)).length;
+  }
+  const commentDensity = totalLines > 0 ? (jsdocCount + inlineCount) / totalLines : 0;
+  let density;
+  if (commentDensity > 0.15) density = "heavy";
+  else if (commentDensity > 0.05) density = "moderate";
+  else density = "minimal";
+  return [
+    `Comment density: ${density} (${jsdocCount} JSDoc blocks, ${inlineCount} inline comments across ${sample.length} files).`
+  ];
+}
+async function runScan(rootDir) {
+  const allFiles = walkDir(rootDir);
+  return {
+    naming: analyzeNaming(allFiles),
+    imports: analyzeImports(allFiles),
+    testing: analyzeTesting(allFiles),
+    errorHandling: analyzeErrorHandling(allFiles),
+    comments: analyzeComments(allFiles)
+  };
+}
+
+// src/watch.ts
+init_writers();
+
+// src/watch/daemon.ts
+var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
+init_writers();
+
+// src/watch/transcripts.ts
+var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
+async function processTranscript(filePath, adapter) {
+  let content;
+  try {
+    content = import_node_fs17.default.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const prompt = `Extract structured information from this session summary. Return ONLY valid JSON with no markdown or explanation.
+
+Session content:
+${content}
+
+Return JSON with exactly these keys:
+{
+  "decisions": ["what approach was chosen and why"],
+  "corrections": ["what the agent got wrong and how it was fixed"],
+  "deferredIdeas": ["ideas mentioned but not acted on"],
+  "openThreads": ["unresolved questions or next steps"]
+}
+Each item must be a concise one-sentence string. Arrays may be empty.`;
+  let response;
+  try {
+    response = await adapter.complete(prompt);
+  } catch {
+    return null;
+  }
+  try {
+    const cleaned = response.replace(/^```(?:json)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const obj = parsed;
+    const toArray = (v) => {
+      if (!Array.isArray(v)) return [];
+      return v.filter((item) => typeof item === "string");
+    };
+    return {
+      decisions: toArray(obj["decisions"]),
+      corrections: toArray(obj["corrections"]),
+      deferredIdeas: toArray(obj["deferredIdeas"]),
+      openThreads: toArray(obj["openThreads"])
+    };
+  } catch {
+    return null;
+  }
+}
+function watchTranscriptDir(rootDir, onNewFile) {
+  const sessionsDir = import_node_path18.default.join(rootDir, "tmp", "sessions");
+  import_node_fs17.default.mkdirSync(sessionsDir, { recursive: true });
+  const watcher = import_node_fs17.default.watch(sessionsDir, (event, filename) => {
+    if (event !== "rename" || !filename) return;
+    if (!filename.endsWith(".md")) return;
+    const filePath = import_node_path18.default.join(sessionsDir, filename);
+    if (!import_node_fs17.default.existsSync(filePath)) return;
+    onNewFile(filePath).catch(() => {
+    });
+  });
+  return () => {
+    watcher.close();
+  };
+}
+
+// src/watch/adapters/claude-local.ts
+var import_node_child_process2 = require("child_process");
+var ClaudeLocalAdapter = class {
+  async complete(prompt) {
+    const escaped = prompt.replace(/'/g, "'\\''");
+    try {
+      const result = (0, import_node_child_process2.execSync)(`claude -p '${escaped}'`, {
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return result.trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ENOENT")) {
+        throw new Error("Claude Code CLI not found. Install it or use a different adapter.");
+      }
+      throw err;
+    }
+  }
+};
+
+// src/watch/adapters/claude-api.ts
+var API_URL = "https://api.anthropic.com/v1/messages";
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+var ClaudeApiAdapter = class {
+  apiKey;
+  model;
+  constructor(apiKey, model) {
+    this.apiKey = apiKey ?? process.env.ANTHROPIC_API_KEY ?? "";
+    this.model = model ?? DEFAULT_MODEL;
+    if (!this.apiKey) {
+      throw new Error("ANTHROPIC_API_KEY not set. Set it or use a different adapter.");
+    }
+  }
+  async complete(prompt) {
+    const response = await fetch(API_URL, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 1024,
+        messages: [{ role: "user", content: prompt }]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const text = data.content.find((c) => c.type === "text")?.text ?? "";
+    return text.trim();
+  }
+};
+
+// src/watch/adapters/ollama.ts
+var DEFAULT_OLLAMA_URL = "http://localhost:11434/api/generate";
+var DEFAULT_MODEL2 = "llama3.2";
+var OllamaAdapter = class {
+  model;
+  url;
+  constructor(model, url) {
+    this.model = model ?? DEFAULT_MODEL2;
+    this.url = url ?? DEFAULT_OLLAMA_URL;
+  }
+  async complete(prompt) {
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        prompt,
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama error: ${response.status}. Is Ollama running?`);
+    }
+    const data = await response.json();
+    return data.response.trim();
+  }
+};
+
+// src/watch/adapters/codex-local.ts
+var import_node_child_process3 = require("child_process");
+var CodexLocalAdapter = class {
+  async complete(prompt) {
+    const escaped = prompt.replace(/'/g, "'\\''");
+    try {
+      const result = (0, import_node_child_process3.execSync)(`codex '${escaped}'`, {
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return result.trim();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("ENOENT")) {
+        throw new Error("Codex CLI not found. Install it or use a different adapter.");
+      }
+      throw err;
+    }
+  }
+};
+
+// src/watch/adapters/index.ts
+function createAdapter(config) {
+  const type = config.watch?.adapter ?? "claude-local";
+  switch (type) {
+    case "claude-local":
+      return new ClaudeLocalAdapter();
+    case "claude-api":
+      return new ClaudeApiAdapter();
+    case "ollama":
+      return new OllamaAdapter();
+    case "codex-local":
+      return new CodexLocalAdapter();
+    default:
+      return new ClaudeLocalAdapter();
+  }
+}
+
+// src/watch/daemon.ts
+async function runDaemon(rootDir, config) {
+  const silent = config.watch?.silent ?? false;
+  const log = silent ? () => {
+  } : (msg) => process.stdout.write(msg + "\n");
+  const cleanup = [];
+  const shutdown = () => {
+    cleanup.forEach((fn) => fn());
+    clearPid(rootDir);
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+  log("[clawstrap watch] daemon started");
+  const sinceCommit = config.watchState?.lastGitCommit ?? null;
+  const gitResult = await runGitObserver(rootDir, sinceCommit);
+  if (gitResult) {
+    updateWatchState(rootDir, { lastGitCommit: gitResult.lastCommit });
+    log(`[clawstrap watch] git: ${gitResult.entriesWritten} entries written`);
+  }
+  const adapter = createAdapter(config);
+  const stopTranscripts = watchTranscriptDir(rootDir, async (filePath) => {
+    log(`[clawstrap watch] transcript: processing ${import_node_path19.default.basename(filePath)}`);
+    const result = await processTranscript(filePath, adapter);
+    if (result) {
+      const { appendToMemory: appendToMemory2, appendToGotchaLog: appendToGotchaLog2, appendToFutureConsiderations: appendToFutureConsiderations2 } = await Promise.resolve().then(() => (init_writers(), writers_exports));
+      if (result.decisions.length) appendToMemory2(rootDir, result.decisions, "session");
+      if (result.corrections.length) appendToGotchaLog2(rootDir, result.corrections);
+      if (result.deferredIdeas.length) appendToFutureConsiderations2(rootDir, result.deferredIdeas);
+      updateWatchState(rootDir, { lastTranscriptAt: (/* @__PURE__ */ new Date()).toISOString() });
+      log(
+        `[clawstrap watch] transcript: decisions=${result.decisions.length} corrections=${result.corrections.length}`
+      );
+    }
+  });
+  cleanup.push(stopTranscripts);
+  const intervalDays = config.watch?.scan?.intervalDays ?? 7;
+  const lastScan = config.watchState?.lastScanAt ? new Date(config.watchState.lastScanAt) : null;
+  const msSinceLastScan = lastScan ? Date.now() - lastScan.getTime() : Infinity;
+  const scanIntervalMs = intervalDays * 24 * 60 * 60 * 1e3;
+  const doScan = async () => {
+    log("[clawstrap watch] scan: running convention scan...");
+    const sections = await runScan(rootDir);
+    writeConventions(rootDir, sections);
+    updateWatchState(rootDir, { lastScanAt: (/* @__PURE__ */ new Date()).toISOString() });
+    log("[clawstrap watch] scan: conventions.md updated");
+  };
+  if (msSinceLastScan >= scanIntervalMs) {
+    await doScan();
+  }
+  const scanTimer = setInterval(doScan, scanIntervalMs);
+  cleanup.push(() => clearInterval(scanTimer));
+  log("[clawstrap watch] watching for changes...");
+  await new Promise(() => {
+  });
+}
+function updateWatchState(rootDir, updates) {
+  const configPath = import_node_path19.default.join(rootDir, ".clawstrap.json");
+  try {
+    const raw = JSON.parse(import_node_fs18.default.readFileSync(configPath, "utf-8"));
+    raw["watchState"] = { ...raw["watchState"] ?? {}, ...updates };
+    import_node_fs18.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+
+// src/watch.ts
+async function watch(options) {
+  const { config, rootDir } = loadWorkspace();
+  if (options._daemon) {
+    await runDaemon(rootDir, config);
+    return;
+  }
+  if (options.stop) {
+    const pid = readPid(rootDir);
+    if (!pid || !isDaemonRunning(rootDir)) {
+      console.log("\nNo daemon running.\n");
+      return;
+    }
+    process.kill(pid, "SIGTERM");
+    clearPid(rootDir);
+    console.log(`
+Daemon stopped (pid ${pid}).
+`);
+    return;
+  }
+  if (options.once) {
+    console.log("\nRunning all observers once...\n");
+    const gitResult = await runGitObserver(rootDir, config.watchState?.lastGitCommit ?? null);
+    if (gitResult) {
+      persistWatchState(rootDir, { lastGitCommit: gitResult.lastCommit });
+      console.log(`  \u2713 git: ${gitResult.entriesWritten} entries`);
+    }
+    const sections = await runScan(rootDir);
+    writeConventions(rootDir, sections);
+    persistWatchState(rootDir, { lastScanAt: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log("  \u2713 scan: conventions.md updated");
+    console.log("\nDone.\n");
+    return;
+  }
+  if (isDaemonRunning(rootDir)) {
+    const pid = readPid(rootDir);
+    console.log(`
+Daemon already running (pid ${pid}). Use --stop to stop it.
+`);
+    return;
+  }
+  injectWatchHook(rootDir, config);
+  const self = process.argv[1];
+  const child = (0, import_node_child_process4.spawn)(process.execPath, [self, "watch", "--_daemon"], {
+    detached: true,
+    stdio: "ignore",
+    cwd: rootDir
+  });
+  child.unref();
+  if (child.pid) {
+    writePid(rootDir, child.pid);
+    if (!options.silent) {
+      console.log(`
+Daemon started (pid ${child.pid}).`);
+      console.log(`Run 'clawstrap watch --stop' to stop it.
+`);
+    }
+  } else {
+    console.error("\nFailed to start daemon.\n");
+    process.exit(1);
+  }
+}
+function persistWatchState(rootDir, updates) {
+  const configPath = import_node_path20.default.join(rootDir, ".clawstrap.json");
+  try {
+    const raw = JSON.parse(import_node_fs19.default.readFileSync(configPath, "utf-8"));
+    raw.watchState = { ...raw.watchState ?? {}, ...updates };
+    import_node_fs19.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function injectWatchHook(rootDir, config) {
+  const governanceFile = import_node_path20.default.join(rootDir, "CLAUDE.md");
+  if (!import_node_fs19.default.existsSync(governanceFile)) return;
+  const content = import_node_fs19.default.readFileSync(governanceFile, "utf-8");
+  if (content.includes("<!-- CLAWSTRAP:WATCH -->")) return;
+  const _config = config;
+  void _config;
+  const hook = `
+<!-- CLAWSTRAP:WATCH -->
+## Session Watch Hook
+
+\`clawstrap watch\` is active. At every session end, write a session summary to
+\`tmp/sessions/YYYY-MM-DD-HHmm.md\` using this format:
+
+\`\`\`
+## Decisions
+- [what approach was chosen and why]
+
+## Corrections
+- [what the agent got wrong and how it was fixed]
+
+## Deferred Ideas
+- [mentioned but not acted on]
+
+## Open Threads
+- [unresolved questions or next steps]
+\`\`\`
+
+The watch daemon picks this up automatically and updates MEMORY.md and gotcha-log.md.
+`;
+  import_node_fs19.default.appendFileSync(governanceFile, hook, "utf-8");
+}
+
+// src/analyze.ts
+var import_node_fs20 = __toESM(require("fs"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
+init_writers();
+async function analyze() {
+  const { rootDir } = loadWorkspace();
+  console.log("\nScanning codebase conventions...\n");
+  const sections = await runScan(rootDir);
+  writeConventions(rootDir, sections);
+  const configPath = import_node_path21.default.join(rootDir, ".clawstrap.json");
+  try {
+    const raw = JSON.parse(import_node_fs20.default.readFileSync(configPath, "utf-8"));
+    raw["watchState"] = { ...raw["watchState"] ?? {}, lastScanAt: (/* @__PURE__ */ new Date()).toISOString() };
+    import_node_fs20.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+  console.log("  \u2713 .claude/rules/conventions.md updated\n");
+}
+
 // src/index.ts
 var program = new import_commander.Command();
-program.name("clawstrap").description("Scaffold a production-ready AI agent workspace").version("1.3.0");
+program.name("clawstrap").description("Scaffold a production-ready AI agent workspace").version("1.4.0");
 program.command("init").description("Create a new AI workspace in the current directory").argument("[directory]", "Target directory", ".").option("-y, --yes", "Use defaults, skip prompts").option("--sdd", "Enable Spec-Driven Development mode").action(async (directory, options) => {
   await init(directory, options);
 });
@@ -1258,4 +2249,10 @@ Unknown format: ${options.format}. Supported: paperclip
   }
   await exportPaperclip(options);
 });
+program.command("watch").description("Start adaptive memory daemon for this workspace").option("--stop", "Stop the running daemon").option("--silent", "Run without output").option("--once", "Run all observers once and exit (no persistent daemon)").option("--_daemon", void 0).action(async (options) => {
+  await watch(options);
+});
+program.command("analyze").description("Run codebase convention scan immediately").action(async () => {
+  await analyze();
+});
 program.parse();