clawstrap 1.4.1 → 1.5.0

package/dist/index.cjs

@@ -88,6 +88,7 @@ __export(writers_exports, {
   appendToFutureConsiderations: () => appendToFutureConsiderations,
   appendToGotchaLog: () => appendToGotchaLog,
   appendToMemory: () => appendToMemory,
+  appendToOpenThreads: () => appendToOpenThreads,
   writeConventions: () => writeConventions
 });
 function formatEntry(source, text) {
@@ -114,6 +115,7 @@ function appendToMemory(rootDir, entries, source) {
     const appendText = "\n" + toAppend.join("\n") + "\n";
     import_node_fs14.default.appendFileSync(memoryPath, appendText, "utf-8");
   }
+  return toAppend.length;
 }
 function appendToGotchaLog(rootDir, entries) {
   const logPath = import_node_path15.default.join(rootDir, ".claude", "gotcha-log.md");
@@ -141,6 +143,19 @@ function appendToFutureConsiderations(rootDir, entries) {
   const toAppend = entries.map((e) => formatEntry("session", e)).join("\n");
   import_node_fs14.default.appendFileSync(fcPath, "\n" + toAppend + "\n", "utf-8");
 }
+function appendToOpenThreads(rootDir, entries) {
+  const otPath = import_node_path15.default.join(rootDir, ".claude", "memory", "open-threads.md");
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(otPath), { recursive: true });
+  if (!import_node_fs14.default.existsSync(otPath)) {
+    import_node_fs14.default.writeFileSync(
+      otPath,
+      "# Open Threads\n\nUnresolved questions and next steps.\n\n",
+      "utf-8"
+    );
+  }
+  const toAppend = entries.map((e) => formatEntry("session", e)).join("\n");
+  import_node_fs14.default.appendFileSync(otPath, "\n" + toAppend + "\n", "utf-8");
+}
 function buildAutoBlock(sections) {
   const lines = [AUTO_START];
   lines.push("## Naming Conventions");
@@ -177,6 +192,11 @@ function buildAutoBlock(sections) {
   } else {
     lines.push("- No comment patterns detected.");
   }
+  if (sections.architecture && sections.architecture.length > 0) {
+    lines.push("");
+    lines.push("## Architecture & Design Patterns");
+    for (const item of sections.architecture) lines.push(`- ${item}`);
+  }
   lines.push(AUTO_END);
   return lines.join("\n");
 }
@@ -263,12 +283,20 @@ var ClawstrapConfigSchema = import_zod.z.object({
     scan: import_zod.z.object({
       intervalDays: import_zod.z.number().default(7)
     }).default({}),
+    git: import_zod.z.object({
+      pollIntervalMinutes: import_zod.z.number().default(5)
+    }).default({}),
+    synthesis: import_zod.z.object({
+      enabled: import_zod.z.boolean().default(false),
+      triggerEveryN: import_zod.z.number().default(10)
+    }).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()
+    lastTranscriptAt: import_zod.z.string().optional(),
+    entriesSinceLastSynthesis: import_zod.z.coerce.number().optional()
   }).optional(),
   lastExport: LastExportSchema
 });
@@ -777,7 +805,7 @@ async function init(directory, options) {
     import_node_fs2.default.mkdirSync(targetDir, { recursive: true });
   }
   const config = ClawstrapConfigSchema.parse({
-    version: "1.4.1",
+    version: "1.4.2",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workspaceName: answers.workspaceName,
     targetDirectory: directory,
@@ -1499,9 +1527,8 @@ Exported to ${import_node_path14.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);
+var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs21 = __toESM(require("fs"), 1);
 
 // src/watch/git.ts
 var import_node_child_process = require("child_process");
@@ -1844,17 +1871,220 @@ async function runScan(rootDir) {
 init_writers();
 
 // src/watch/daemon.ts
-var import_node_fs18 = __toESM(require("fs"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs20 = __toESM(require("fs"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 init_writers();
 
-// src/watch/transcripts.ts
+// src/watch/synthesize.ts
 var import_node_fs17 = __toESM(require("fs"), 1);
 var import_node_path18 = __toESM(require("path"), 1);
+init_dedup();
+var SYNTH_START = "<!-- CLAWSTRAP:SYNTHESIS:START -->";
+var SYNTH_END = "<!-- CLAWSTRAP:SYNTHESIS:END -->";
+var MAX_ENTRIES_TO_SEND = 20;
+function extractExistingSummary(content) {
+  const startIdx = content.indexOf(SYNTH_START);
+  const endIdx = content.indexOf(SYNTH_END);
+  if (startIdx === -1 || endIdx === -1) return null;
+  const block = content.slice(startIdx + SYNTH_START.length, endIdx).trim();
+  const lines = block.split("\n");
+  let start = 0;
+  if (/^##\s+Living Summary/.test(lines[start] ?? "")) start++;
+  if (/^>\s+Updated:/.test(lines[start] ?? "")) start++;
+  return lines.slice(start).join("\n").trim() || null;
+}
+function buildSynthBlock(summary) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  return [
+    SYNTH_START,
+    "## Living Summary",
+    `> Updated: ${ts}`,
+    "",
+    summary,
+    SYNTH_END
+  ].join("\n");
+}
+function writeSynthBlock(memoryPath, summary) {
+  const content = import_node_fs17.default.existsSync(memoryPath) ? import_node_fs17.default.readFileSync(memoryPath, "utf-8") : "";
+  const block = buildSynthBlock(summary);
+  const startIdx = content.indexOf(SYNTH_START);
+  const endIdx = content.indexOf(SYNTH_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + SYNTH_END.length);
+    import_node_fs17.default.writeFileSync(memoryPath, before + block + after, "utf-8");
+    return;
+  }
+  const headingMatch = /^#[^\n]*\n?/m.exec(content);
+  if (headingMatch) {
+    const insertAt = headingMatch.index + headingMatch[0].length;
+    const updated = content.slice(0, insertAt) + "\n" + block + "\n" + content.slice(insertAt);
+    import_node_fs17.default.writeFileSync(memoryPath, updated, "utf-8");
+  } else {
+    import_node_fs17.default.writeFileSync(memoryPath, block + "\n\n" + content, "utf-8");
+  }
+}
+async function synthesizeMemory(rootDir, adapter) {
+  const memoryPath = import_node_path18.default.join(rootDir, ".claude", "memory", "MEMORY.md");
+  if (!import_node_fs17.default.existsSync(memoryPath)) return null;
+  const content = import_node_fs17.default.readFileSync(memoryPath, "utf-8");
+  const contentWithoutSynthBlock = content.replace(
+    /<!-- CLAWSTRAP:SYNTHESIS:START -->[\s\S]*?<!-- CLAWSTRAP:SYNTHESIS:END -->/,
+    ""
+  );
+  const allEntries = parseMemoryEntries(contentWithoutSynthBlock);
+  if (allEntries.length === 0) return null;
+  const recentEntries = allEntries.slice(-MAX_ENTRIES_TO_SEND);
+  const existingSummary = extractExistingSummary(content);
+  let prompt;
+  if (existingSummary) {
+    prompt = `You are maintaining a living summary of an AI agent workspace.
+
+Current summary:
+${existingSummary}
+
+Recent new memory entries:
+${recentEntries.join("\n---\n")}
+
+Update the summary to incorporate the new information. Write 3\u20135 sentences of persistent truths about how this workspace operates. Output only the updated paragraph \u2014 no heading, no markdown, no explanation.`;
+  } else {
+    prompt = `You are summarising an AI agent workspace from its memory log.
+
+Recent memory entries:
+${recentEntries.join("\n---\n")}
+
+Write a concise 3\u20135 sentence summary of the persistent truths about how this workspace operates. Output only the paragraph \u2014 no heading, no markdown, no explanation.`;
+  }
+  let response;
+  try {
+    response = await adapter.complete(prompt);
+  } catch {
+    return null;
+  }
+  const summary = response.replace(/^```(?:markdown)?\s*/m, "").replace(/\s*```\s*$/m, "").trim();
+  if (!summary) return null;
+  try {
+    writeSynthBlock(memoryPath, summary);
+  } catch {
+    return null;
+  }
+  return summary;
+}
+
+// src/watch/infer.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
+var CODE_EXTS2 = /* @__PURE__ */ new Set([".ts", ".js", ".tsx", ".jsx"]);
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([".git", "node_modules", "tmp", "dist", ".claude"]);
+var MAX_FILES = 10;
+var MAX_LINES_PER_FILE = 150;
+var MIN_FILES = 3;
+function walkCodeFiles(rootDir) {
+  const results = [];
+  function walk(dir, depth = 0) {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = import_node_fs18.default.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (SKIP_DIRS2.has(entry.name)) continue;
+      const fullPath = import_node_path19.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      } else if (entry.isFile() && CODE_EXTS2.has(import_node_path19.default.extname(entry.name))) {
+        if (!/\.(test|spec)\.(ts|js|tsx|jsx)$/.test(entry.name)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  }
+  walk(rootDir);
+  return results;
+}
+function getRecentlyChangedFiles(rootDir) {
+  try {
+    const output = (0, import_node_child_process2.execSync)(
+      `git -C "${rootDir}" log --format='' --name-only -n 100`,
+      { encoding: "utf-8" }
+    ).trim();
+    if (!output) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const files = [];
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      const ext = import_node_path19.default.extname(trimmed);
+      if (!CODE_EXTS2.has(ext)) continue;
+      if (/\.(test|spec)\.(ts|js|tsx|jsx)$/.test(trimmed)) continue;
+      const abs = import_node_path19.default.join(rootDir, trimmed);
+      if (import_node_fs18.default.existsSync(abs)) files.push(abs);
+    }
+    return files;
+  } catch {
+    return [];
+  }
+}
+function readTruncated(filePath, rootDir) {
+  let content;
+  try {
+    content = import_node_fs18.default.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+  const lines = content.split("\n");
+  const relPath = import_node_path19.default.relative(rootDir, filePath);
+  const truncated = lines.length > MAX_LINES_PER_FILE ? lines.slice(0, MAX_LINES_PER_FILE).join("\n") + "\n// ... truncated" : lines.join("\n");
+  return `=== ${relPath} ===
+${truncated}`;
+}
+async function inferArchitecturePatterns(rootDir, syntacticSections, adapter) {
+  let candidates = getRecentlyChangedFiles(rootDir);
+  if (candidates.length < MIN_FILES) {
+    candidates = walkCodeFiles(rootDir);
+  }
+  if (candidates.length < MIN_FILES) return [];
+  const sampled = candidates.slice(0, MAX_FILES);
+  const fileSamples = sampled.map((f) => readTruncated(f, rootDir)).filter(Boolean).join("\n\n");
+  if (!fileSamples) return [];
+  const syntacticSummary = [
+    `Naming: ${syntacticSections.naming.join("; ")}`,
+    `Imports: ${syntacticSections.imports.join("; ")}`,
+    `Error handling: ${syntacticSections.errorHandling.join("; ")}`
+  ].join("\n");
+  const prompt = `You are analysing a software project to infer its architectural and design conventions.
+
+Syntactic analysis already found:
+${syntacticSummary}
+
+Source file samples:
+${fileSamples}
+
+Based on the code, identify 3\u20138 architectural or design patterns as imperative rules.
+Rules must be specific to this codebase, not generic best practices.
+Format: one rule per line, starting with "Always", "Never", or "When".
+Output only the rules \u2014 no explanation, no numbering, no markdown.`;
+  let response;
+  try {
+    response = await adapter.complete(prompt);
+  } catch {
+    return [];
+  }
+  const rules = response.replace(/^```(?:markdown)?\s*/m, "").replace(/\s*```\s*$/m, "").split("\n").map((line) => line.replace(/^\s*[-*\d.]+\s*/, "").trim()).filter((line) => /^(Always|Never|When)\b/i.test(line));
+  return rules;
+}
+
+// src/watch/transcripts.ts
+var import_node_fs19 = __toESM(require("fs"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 async function processTranscript(filePath, adapter) {
   let content;
   try {
-    content = import_node_fs17.default.readFileSync(filePath, "utf-8");
+    content = import_node_fs19.default.readFileSync(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -1897,13 +2127,13 @@ Each item must be a concise one-sentence string. Arrays may be empty.`;
   }
 }
 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) => {
+  const sessionsDir = import_node_path20.default.join(rootDir, "tmp", "sessions");
+  import_node_fs19.default.mkdirSync(sessionsDir, { recursive: true });
+  const watcher = import_node_fs19.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;
+    const filePath = import_node_path20.default.join(sessionsDir, filename);
+    if (!import_node_fs19.default.existsSync(filePath)) return;
     onNewFile(filePath).catch(() => {
     });
   });
@@ -1913,12 +2143,12 @@ function watchTranscriptDir(rootDir, onNewFile) {
 }
 
 // src/watch/adapters/claude-local.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = 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}'`, {
+      const result = (0, import_node_child_process3.execSync)(`claude -p '${escaped}'`, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -1999,12 +2229,12 @@ var OllamaAdapter = class {
 };
 
 // src/watch/adapters/codex-local.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = 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}'`, {
+      const result = (0, import_node_child_process4.execSync)(`codex '${escaped}'`, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -2038,78 +2268,320 @@ function createAdapter(config) {
 }
 
 // src/watch/daemon.ts
-async function runDaemon(rootDir, config) {
-  const silent = config.watch?.silent ?? false;
-  const log = silent ? () => {
-  } : (msg) => process.stdout.write(msg + "\n");
+async function runDaemon(rootDir, config, ui) {
   const cleanup = [];
   const shutdown = () => {
     cleanup.forEach((fn) => fn());
+    ui.clear();
     clearPid(rootDir);
     process.exit(0);
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  log("[clawstrap watch] daemon started");
+  ui.daemonStarted();
   const sinceCommit = config.watchState?.lastGitCommit ?? null;
+  ui.gitStart();
   const gitResult = await runGitObserver(rootDir, sinceCommit);
+  ui.gitDone(gitResult ? { entriesWritten: gitResult.entriesWritten, lastCommit: gitResult.lastCommit } : null);
+  let lastGitCommit = gitResult?.lastCommit ?? sinceCommit;
   if (gitResult) {
     updateWatchState(rootDir, { lastGitCommit: gitResult.lastCommit });
-    log(`[clawstrap watch] git: ${gitResult.entriesWritten} entries written`);
   }
   const adapter = createAdapter(config);
+  let entriesSinceLastSynthesis = config.watchState?.entriesSinceLastSynthesis ?? 0;
+  const synthEnabled = config.watch?.synthesis?.enabled ?? false;
+  const triggerEveryN = config.watch?.synthesis?.triggerEveryN ?? 10;
+  const maybeSynthesize = async () => {
+    if (!synthEnabled || entriesSinceLastSynthesis < triggerEveryN) return;
+    ui.synthStart();
+    const summary = await synthesizeMemory(rootDir, adapter);
+    ui.synthDone(summary);
+    entriesSinceLastSynthesis = 0;
+    updateWatchState(rootDir, { entriesSinceLastSynthesis: "0" });
+  };
   const stopTranscripts = watchTranscriptDir(rootDir, async (filePath) => {
-    log(`[clawstrap watch] transcript: processing ${import_node_path19.default.basename(filePath)}`);
+    ui.transcriptStart(import_node_path21.default.basename(filePath));
+    ui.llmCallStart();
     const result = await processTranscript(filePath, adapter);
+    ui.llmCallDone(result ? { decisions: result.decisions.length, corrections: result.corrections.length, openThreads: result.openThreads.length } : null);
     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");
+      const { appendToMemory: appendToMemory2, appendToGotchaLog: appendToGotchaLog2, appendToFutureConsiderations: appendToFutureConsiderations2, appendToOpenThreads: appendToOpenThreads2 } = await Promise.resolve().then(() => (init_writers(), writers_exports));
+      let written = 0;
+      if (result.decisions.length) written += 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}`
-      );
+      if (result.openThreads.length) appendToOpenThreads2(rootDir, result.openThreads);
+      entriesSinceLastSynthesis += written;
+      updateWatchState(rootDir, {
+        lastTranscriptAt: (/* @__PURE__ */ new Date()).toISOString(),
+        entriesSinceLastSynthesis: String(entriesSinceLastSynthesis)
+      });
+      ui.transcriptWriteDone();
+      await maybeSynthesize();
     }
   });
   cleanup.push(stopTranscripts);
+  let gitRunning = false;
+  const pollIntervalMinutes = config.watch?.git?.pollIntervalMinutes ?? 5;
+  const gitPollTimer = setInterval(async () => {
+    if (gitRunning) return;
+    gitRunning = true;
+    try {
+      const result = await runGitObserver(rootDir, lastGitCommit);
+      if (result && result.entriesWritten > 0) {
+        ui.gitPollDone({ entriesWritten: result.entriesWritten, lastCommit: result.lastCommit });
+      }
+      if (result) {
+        lastGitCommit = result.lastCommit;
+        updateWatchState(rootDir, { lastGitCommit: result.lastCommit });
+      }
+    } finally {
+      gitRunning = false;
+    }
+  }, pollIntervalMinutes * 60 * 1e3);
+  cleanup.push(() => clearInterval(gitPollTimer));
   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...");
+    ui.scanStart(lastScan);
+    ui.scanFilesStart();
     const sections = await runScan(rootDir);
+    ui.scanFilesDone();
+    if (config.watch?.adapter) {
+      ui.inferStart();
+      const rules = await inferArchitecturePatterns(rootDir, sections, adapter);
+      ui.inferDone(rules.length > 0 ? rules.length : null);
+      if (rules.length > 0) sections.architecture = rules;
+    }
     writeConventions(rootDir, sections);
     updateWatchState(rootDir, { lastScanAt: (/* @__PURE__ */ new Date()).toISOString() });
-    log("[clawstrap watch] scan: conventions.md updated");
+    ui.scanDone(sections.naming[0] ?? "");
   };
   if (msSinceLastScan >= scanIntervalMs) {
     await doScan();
   }
   const scanTimer = setInterval(doScan, scanIntervalMs);
   cleanup.push(() => clearInterval(scanTimer));
-  log("[clawstrap watch] watching for changes...");
+  ui.showIdle(import_node_path21.default.join(rootDir, "tmp", "sessions"));
   await new Promise(() => {
   });
 }
 function updateWatchState(rootDir, updates) {
-  const configPath = import_node_path19.default.join(rootDir, ".clawstrap.json");
+  const configPath = import_node_path21.default.join(rootDir, ".clawstrap.json");
   try {
-    const raw = JSON.parse(import_node_fs18.default.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(import_node_fs20.default.readFileSync(configPath, "utf-8"));
     raw["watchState"] = { ...raw["watchState"] ?? {}, ...updates };
-    import_node_fs18.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    import_node_fs20.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
   } catch {
   }
 }
 
+// src/watch/ui.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var import_ora = __toESM(require("ora"), 1);
+function formatAgo(date) {
+  if (!date) return "never";
+  const diffMs = Date.now() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  if (diffMins < 60) return `${diffMins} minute${diffMins === 1 ? "" : "s"} ago`;
+  const diffHours = Math.floor(diffMins / 60);
+  if (diffHours < 24) return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+}
+var T = {
+  branch: import_picocolors.default.gray("\u251C\u2500"),
+  last: import_picocolors.default.gray("\u2514\u2500"),
+  check: import_picocolors.default.green("\u2713")
+};
+function header(label) {
+  process.stdout.write(`
+${import_picocolors.default.cyan("\u25C6")}  ${import_picocolors.default.bold(label)}
+`);
+}
+function row(connector, label, value) {
+  const val = value !== void 0 ? `  ${import_picocolors.default.bold(value)}` : "";
+  process.stdout.write(`${connector} ${label}${val}
+`);
+}
+var SilentUI = class {
+  daemonStarted() {
+  }
+  gitStart() {
+  }
+  gitDone(_result) {
+  }
+  gitPollDone(_result) {
+  }
+  transcriptStart(_filename) {
+  }
+  llmCallStart() {
+  }
+  llmCallDone(_counts) {
+  }
+  transcriptWriteDone() {
+  }
+  scanStart(_lastRunAt) {
+  }
+  scanFilesStart() {
+  }
+  scanFilesDone() {
+  }
+  scanDone(_namingStyle) {
+  }
+  synthStart() {
+  }
+  synthDone(_summary) {
+  }
+  inferStart() {
+  }
+  inferDone(_rulesCount) {
+  }
+  showIdle(_watchDir) {
+  }
+  clear() {
+  }
+};
+var RichUI = class {
+  spinner = null;
+  daemonStarted() {
+    process.stdout.write(`
+${import_picocolors.default.cyan("clawstrap watch")} ${import_picocolors.default.dim("daemon started")}
+`);
+  }
+  // Git observer ──────────────────────────────────────────────────────────────
+  gitStart() {
+    header("Git observer");
+  }
+  gitDone(result) {
+    if (!result) {
+      row(T.last, import_picocolors.default.dim("No new commits found."));
+      return;
+    }
+    row(T.branch, "Last processed commit", result.lastCommit.slice(0, 7));
+    row(T.branch, "Entries written", String(result.entriesWritten));
+    row(T.last, `Writing to MEMORY.md...  ${T.check} done`);
+  }
+  gitPollDone(result) {
+    const time = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 5);
+    process.stdout.write(
+      `
+${import_picocolors.default.cyan("\u25C6")}  ${import_picocolors.default.bold("Git:")}  +${result.entriesWritten} entr${result.entriesWritten === 1 ? "y" : "ies"} written  ${import_picocolors.default.dim(result.lastCommit.slice(0, 7))}  ${import_picocolors.default.dim(time)}
+`
+    );
+  }
+  // Transcript ────────────────────────────────────────────────────────────────
+  transcriptStart(filename) {
+    header(`New session summary detected  ${import_picocolors.default.cyan(filename)}`);
+  }
+  llmCallStart() {
+    this.spinner = (0, import_ora.default)({
+      text: `${T.branch} Sending to LLM adapter...`,
+      prefixText: ""
+    }).start();
+  }
+  llmCallDone(counts) {
+    if (this.spinner) {
+      if (counts) {
+        this.spinner.succeed(`${T.branch} Sending to LLM adapter...  ${T.check}`);
+      } else {
+        this.spinner.fail(`${T.branch} Sending to LLM adapter...  failed`);
+      }
+      this.spinner = null;
+    }
+    if (counts) {
+      row(T.branch, "Decisions found    ", String(counts.decisions));
+      row(T.branch, "Corrections found  ", String(counts.corrections));
+      row(T.branch, "Open threads found ", String(counts.openThreads));
+    }
+  }
+  transcriptWriteDone() {
+    row(T.last, `Writing to memory files...  ${T.check} done`);
+  }
+  // Convention scan ───────────────────────────────────────────────────────────
+  scanStart(lastRunAt) {
+    header(`Convention scan  ${import_picocolors.default.dim(`(last run: ${formatAgo(lastRunAt)})`)}`);
+  }
+  scanFilesStart() {
+    this.spinner = (0, import_ora.default)({
+      text: `${T.branch} Scanning files...`,
+      prefixText: ""
+    }).start();
+  }
+  scanFilesDone() {
+    if (this.spinner) {
+      this.spinner.succeed(`${T.branch} Scanning files...  done`);
+      this.spinner = null;
+    }
+  }
+  scanDone(namingStyle) {
+    if (namingStyle) {
+      row(T.branch, "Naming convention  ", namingStyle);
+    }
+    row(T.last, `Writing conventions.md...  ${T.check} done`);
+  }
+  // Memory synthesis ──────────────────────────────────────────────────────────
+  synthStart() {
+    this.spinner?.stop();
+    this.spinner = (0, import_ora.default)({
+      text: `${T.branch} Synthesising memory...`,
+      prefixText: ""
+    }).start();
+  }
+  synthDone(summary) {
+    if (this.spinner) {
+      if (summary) {
+        const preview = summary.length > 60 ? summary.slice(0, 60) + "\u2026" : summary;
+        this.spinner.succeed(`${T.branch} Living summary updated  ${import_picocolors.default.dim(preview)}`);
+      } else {
+        this.spinner.fail(`${T.branch} Memory synthesis failed`);
+      }
+      this.spinner = null;
+    }
+  }
+  // Architecture inference ────────────────────────────────────────────────────
+  inferStart() {
+    this.spinner?.stop();
+    this.spinner = (0, import_ora.default)({
+      text: `${T.branch} Inferring architecture patterns...`,
+      prefixText: ""
+    }).start();
+  }
+  inferDone(rulesCount) {
+    if (this.spinner) {
+      if (rulesCount !== null && rulesCount > 0) {
+        this.spinner.succeed(`${T.branch} Architecture patterns inferred  ${import_picocolors.default.bold(String(rulesCount))} rules`);
+      } else {
+        this.spinner.fail(`${T.branch} Architecture inference failed`);
+      }
+      this.spinner = null;
+    }
+  }
+  // Idle ──────────────────────────────────────────────────────────────────────
+  showIdle(watchDir) {
+    process.stdout.write(`
+${import_picocolors.default.dim("\u25C7")}  ${import_picocolors.default.dim("Watching for changes...")}
+`);
+    row(T.last, import_picocolors.default.dim("Transcripts"), import_picocolors.default.dim(watchDir + "  (listening)"));
+    process.stdout.write("\n");
+  }
+  // Cleanup ───────────────────────────────────────────────────────────────────
+  clear() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+};
+function createUI(silent) {
+  return silent ? new SilentUI() : new RichUI();
+}
+
 // 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)) {
@@ -2123,61 +2595,56 @@ Daemon stopped (pid ${pid}).
 `);
     return;
   }
+  const silent = options.silent ?? config.watch?.silent ?? false;
+  const ui = createUI(silent);
   if (options.once) {
-    console.log("\nRunning all observers once...\n");
+    ui.gitStart();
     const gitResult = await runGitObserver(rootDir, config.watchState?.lastGitCommit ?? null);
+    ui.gitDone(gitResult ? { entriesWritten: gitResult.entriesWritten, lastCommit: gitResult.lastCommit } : null);
     if (gitResult) {
       persistWatchState(rootDir, { lastGitCommit: gitResult.lastCommit });
-      console.log(`  \u2713 git: ${gitResult.entriesWritten} entries`);
     }
+    const lastScanAt = config.watchState?.lastScanAt ? new Date(config.watchState.lastScanAt) : null;
+    ui.scanStart(lastScanAt);
+    ui.scanFilesStart();
     const sections = await runScan(rootDir);
+    ui.scanFilesDone();
+    if (config.watch?.adapter) {
+      const adapter = createAdapter(config);
+      ui.inferStart();
+      const rules = await inferArchitecturePatterns(rootDir, sections, adapter);
+      ui.inferDone(rules.length > 0 ? rules.length : null);
+      if (rules.length > 0) sections.architecture = rules;
+    }
     writeConventions(rootDir, sections);
     persistWatchState(rootDir, { lastScanAt: (/* @__PURE__ */ new Date()).toISOString() });
-    console.log("  \u2713 scan: conventions.md updated");
-    console.log("\nDone.\n");
+    ui.scanDone(sections.naming[0] ?? "");
     return;
   }
   if (isDaemonRunning(rootDir)) {
     const pid = readPid(rootDir);
     console.log(`
-Daemon already running (pid ${pid}). Use --stop to stop it.
+Watch is 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);
-  }
+  writePid(rootDir, process.pid);
+  await runDaemon(rootDir, config, ui);
 }
 function persistWatchState(rootDir, updates) {
-  const configPath = import_node_path20.default.join(rootDir, ".clawstrap.json");
+  const configPath = import_node_path22.default.join(rootDir, ".clawstrap.json");
   try {
-    const raw = JSON.parse(import_node_fs19.default.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(import_node_fs21.default.readFileSync(configPath, "utf-8"));
     raw.watchState = { ...raw.watchState ?? {}, ...updates };
-    import_node_fs19.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    import_node_fs21.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");
+  const governanceFile = import_node_path22.default.join(rootDir, "CLAUDE.md");
+  if (!import_node_fs21.default.existsSync(governanceFile)) return;
+  const content = import_node_fs21.default.readFileSync(governanceFile, "utf-8");
   if (content.includes("<!-- CLAWSTRAP:WATCH -->")) return;
   const _config = config;
   void _config;
@@ -2204,23 +2671,23 @@ function injectWatchHook(rootDir, config) {
 
 The watch daemon picks this up automatically and updates MEMORY.md and gotcha-log.md.
 `;
-  import_node_fs19.default.appendFileSync(governanceFile, hook, "utf-8");
+  import_node_fs21.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);
+var import_node_fs22 = __toESM(require("fs"), 1);
+var import_node_path23 = __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");
+  const configPath = import_node_path23.default.join(rootDir, ".clawstrap.json");
   try {
-    const raw = JSON.parse(import_node_fs20.default.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(import_node_fs22.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");
+    import_node_fs22.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
   } catch {
   }
   console.log("  \u2713 .claude/rules/conventions.md updated\n");
@@ -2228,7 +2695,7 @@ async function analyze() {
 
 // src/index.ts
 var program = new import_commander.Command();
-program.name("clawstrap").description("Scaffold a production-ready AI agent workspace").version("1.4.1");
+program.name("clawstrap").description("Scaffold a production-ready AI agent workspace").version("1.4.2");
 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);
 });
@@ -2256,7 +2723,7 @@ 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) => {
+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)").action(async (options) => {
   await watch(options);
 });
 program.command("analyze").description("Run codebase convention scan immediately").action(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawstrap",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Scaffold a production-ready AI agent workspace in under 2 minutes",
   "type": "module",
   "bin": {
@@ -46,6 +46,8 @@
   "dependencies": {
     "@inquirer/prompts": "^7.0.0",
     "commander": "^13.0.0",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1",
     "zod": "^3.24.0"
   },
   "devDependencies": {