create-forge-team 0.2.0

package/dist/chunk-GOZ3OAFK.js

@@ -0,0 +1,805 @@
+import {
+  callOpenRouter,
+  isMemoryAgentConfigured
+} from "./chunk-N62P5WWV.js";
+
+// src/memory/index.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/memory/prompts.ts
+function buildExtractionPrompt(transcript, agentSlug, existingIndex) {
+  const agentKnowledge = existingIndex?.agents?.[agentSlug];
+  const existingItems = agentKnowledge?.knowledgeItems || [];
+  const existingDocsSection = existingItems.length > 0 ? `
+## Existing Knowledge Entries for This Agent
+These are documents that already exist. If this session contains updates to any of these topics, include them in "upsert_targets" instead of creating duplicates.
+
+${existingItems.map((item) => `- ${item.filePath}: ${item.title} (${item.summary})`).join("\n")}` : "";
+  return `You are a knowledge extraction assistant. Analyze the following session transcript and extract structured information.
+
+## Agent
+Slug: ${agentSlug}
+${existingDocsSection}
+
+## Session Transcript
+${transcript}
+
+## Instructions
+Extract the following from the transcript. Output ONLY valid JSON, no markdown fences, no explanation.
+
+{
+  "session_summary": "2-3 sentence overview of what happened in this session",
+  "headline": "One-line headline suitable for a cross-agent activity feed (e.g., 'Practiced PM interview questions, focused on product sense')",
+  "key_decisions": [
+    { "decision": "What was decided", "reasoning": "Why it was decided", "date": "YYYY-MM-DD" }
+  ],
+  "facts_learned": [
+    { "fact": "A concrete fact learned during the session", "category": "category (e.g., 'user_preference', 'project_info', 'domain_knowledge')" }
+  ],
+  "open_threads": [
+    { "description": "Something that needs follow-up", "urgency": "high|medium|low", "deadline": "YYYY-MM-DD or null" }
+  ],
+  "tool_data": [
+    { "tool": "tool name used", "query": "what was queried", "data_summary": "key data returned", "staleness_category": "realtime|semi_dynamic|reference" }
+  ],
+  "upsert_targets": [
+    { "existing_file_slug": "slug of existing doc to update", "update_summary": "what new info to add" }
+  ],
+  "topic_tags": ["tag1", "tag2"]
+}
+
+Rules:
+- If no items exist for a field, use an empty array []
+- Dates should be in YYYY-MM-DD format
+- The headline should be concise (under 80 chars) and describe the session from the agent's perspective
+- For upsert_targets, only reference files that appear in the existing knowledge entries above
+- tool_data should capture the RESULTS of tool calls, not just the fact that tools were used
+- Be specific in summaries \u2014 include names, numbers, and concrete details
+- Output ONLY the JSON object, nothing else`;
+}
+
+// src/memory/pipeline/organize.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync2,
+  readdirSync
+} from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/memory/tool-classifier.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_PATTERNS = {
+  "google-calendar__list-events": { category: "semi_dynamic", maxAgeMinutes: 120 },
+  "google-calendar__get-event": { category: "semi_dynamic", maxAgeMinutes: 120 },
+  "google-calendar__search-events": { category: "semi_dynamic", maxAgeMinutes: 120 },
+  "google-calendar__get-freebusy": { category: "semi_dynamic", maxAgeMinutes: 60 },
+  "gmail__search_emails": { category: "semi_dynamic", maxAgeMinutes: 60 },
+  "gmail__read_email": { category: "reference", maxAgeMinutes: 10080 },
+  "gmail__list_email_labels": { category: "reference", maxAgeMinutes: 1440 },
+  "WebSearch": { category: "semi_dynamic", maxAgeMinutes: 1440 },
+  "WebFetch": { category: "semi_dynamic", maxAgeMinutes: 1440 },
+  "browser-use__browser_task": { category: "semi_dynamic", maxAgeMinutes: 240 }
+};
+var DEFAULT_FALLBACK = {
+  category: "semi_dynamic",
+  maxAgeMinutes: 240
+};
+function loadUserConfig() {
+  const configPath = join(homedir(), ".claude", "forge", "config.json");
+  if (!existsSync(configPath)) return null;
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return config.toolStaleness || null;
+  } catch {
+    return null;
+  }
+}
+function classifyToolStaleness(toolName) {
+  const normalized = toolName.replace(/^mcp__/, "");
+  const userConfig = loadUserConfig();
+  if (userConfig) {
+    if (userConfig.patterns[normalized]) {
+      return userConfig.patterns[normalized];
+    }
+    if (userConfig.patterns[toolName]) {
+      return userConfig.patterns[toolName];
+    }
+    for (const [pattern, config] of Object.entries(userConfig.defaults || {})) {
+      if (matchWildcard(normalized, pattern) || matchWildcard(toolName, pattern)) {
+        return config;
+      }
+    }
+  }
+  for (const [pattern, config] of Object.entries(DEFAULT_PATTERNS)) {
+    if (normalized.includes(pattern) || toolName.includes(pattern)) {
+      return config;
+    }
+  }
+  return DEFAULT_FALLBACK;
+}
+function isStale(fetchedAt, maxAgeMinutes) {
+  const fetchedTime = new Date(fetchedAt).getTime();
+  const now = Date.now();
+  const ageMinutes = (now - fetchedTime) / (1e3 * 60);
+  return ageMinutes > maxAgeMinutes;
+}
+function matchWildcard(text, pattern) {
+  if (pattern.endsWith("*")) {
+    return text.startsWith(pattern.slice(0, -1));
+  }
+  return text === pattern;
+}
+function formatStaleness(fetchedAt) {
+  const fetchedTime = new Date(fetchedAt).getTime();
+  const now = Date.now();
+  const ageMinutes = (now - fetchedTime) / (1e3 * 60);
+  if (ageMinutes < 60) return `${Math.round(ageMinutes)}m ago`;
+  if (ageMinutes < 1440) return `${Math.round(ageMinutes / 60)}h ago`;
+  return `${Math.round(ageMinutes / 1440)}d ago`;
+}
+
+// src/memory/pipeline/organize.ts
+function getKnowledgeDir() {
+  return join2(homedir2(), ".claude", "forge", "knowledge");
+}
+function getTranscriptsDir() {
+  return join2(homedir2(), ".claude", "forge", "transcripts");
+}
+function getAgentKnowledgeDir(agentSlug) {
+  return join2(getKnowledgeDir(), agentSlug);
+}
+function getIndexPath() {
+  return join2(getKnowledgeDir(), "_index.json");
+}
+function getFeedPath() {
+  return join2(getKnowledgeDir(), "_feed.md");
+}
+function getQueuePath() {
+  return join2(getKnowledgeDir(), "_queue.json");
+}
+function loadKnowledgeIndex() {
+  const indexPath = getIndexPath();
+  if (!existsSync2(indexPath)) return null;
+  try {
+    return JSON.parse(readFileSync2(indexPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveKnowledgeIndex(index) {
+  const dir = getKnowledgeDir();
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(getIndexPath(), JSON.stringify(index, null, 2), "utf-8");
+}
+function ensureAgentDirs(agentSlug) {
+  const agentDir = getAgentKnowledgeDir(agentSlug);
+  mkdirSync(join2(agentDir, "sessions"), { recursive: true });
+  mkdirSync(join2(agentDir, "reference"), { recursive: true });
+  mkdirSync(join2(agentDir, "tool-cache"), { recursive: true });
+}
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function formatRelativeDate(dateStr) {
+  const date = new Date(dateStr);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "yesterday";
+  if (diffDays < 7) return `${diffDays} days ago`;
+  if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
+  return `${Math.floor(diffDays / 30)} months ago`;
+}
+function formatDateWithRelative(dateStr) {
+  const date = new Date(dateStr);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const abs = `${months[date.getMonth()]} ${date.getDate()}`;
+  const rel = formatRelativeDate(dateStr);
+  return `${abs} (${rel})`;
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+}
+function organizeKnowledge(extraction, transcript) {
+  const { agentSlug } = transcript;
+  ensureAgentDirs(agentSlug);
+  const today = formatDate(/* @__PURE__ */ new Date());
+  let index = loadKnowledgeIndex() || {
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    agents: {}
+  };
+  if (!index.agents[agentSlug]) {
+    index.agents[agentSlug] = {
+      slug: agentSlug,
+      sessionCount: 0,
+      lastSessionDate: today,
+      knowledgeItems: []
+    };
+  }
+  const agentIndex = index.agents[agentSlug];
+  agentIndex.sessionCount++;
+  agentIndex.lastSessionDate = today;
+  const topicSlug = slugify(extraction.headline);
+  const sessionFileName = `${today}-${topicSlug}.md`;
+  const sessionFilePath = join2(getAgentKnowledgeDir(agentSlug), "sessions", sessionFileName);
+  const sessionContent = buildSessionSummary(extraction, transcript);
+  writeFileSync(sessionFilePath, sessionContent, "utf-8");
+  agentIndex.knowledgeItems.push({
+    id: `session-${transcript.conversationId}`,
+    type: "session_summary",
+    filePath: `sessions/${sessionFileName}`,
+    title: extraction.headline,
+    summary: extraction.sessionSummary,
+    tags: extraction.topicTags,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  for (const target of extraction.upsertTargets) {
+    const refPath = join2(getAgentKnowledgeDir(agentSlug), "reference", `${target.existingFileSlug}.md`);
+    if (existsSync2(refPath)) {
+      const existing = readFileSync2(refPath, "utf-8");
+      const updated = `${existing}
+
+---
+**Updated ${today}:**
+${target.updateSummary}
+`;
+      writeFileSync(refPath, updated, "utf-8");
+      const item = agentIndex.knowledgeItems.find(
+        (i) => i.filePath === `reference/${target.existingFileSlug}.md`
+      );
+      if (item) {
+        item.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        item.summary = target.updateSummary;
+      }
+    }
+  }
+  if (extraction.keyDecisions.length > 0) {
+    const decisionsPath = join2(getAgentKnowledgeDir(agentSlug), "decisions.md");
+    let existing = "";
+    if (existsSync2(decisionsPath)) {
+      existing = readFileSync2(decisionsPath, "utf-8");
+    } else {
+      existing = `# Key Decisions
+
+Running log of important decisions made during sessions.
+`;
+    }
+    const newDecisions = extraction.keyDecisions.map(
+      (d) => `
+## ${d.date}: ${d.decision}
+- **Reasoning:** ${d.reasoning}
+`
+    ).join("");
+    writeFileSync(decisionsPath, existing + newDecisions, "utf-8");
+  }
+  for (const toolData of extraction.toolData) {
+    const staleness = classifyToolStaleness(toolData.tool);
+    const sourceSlug = slugify(toolData.tool);
+    const querySlug = slugify(toolData.query);
+    const cacheFileName = `${sourceSlug}-${querySlug}.json`;
+    const cachePath = join2(getAgentKnowledgeDir(agentSlug), "tool-cache", cacheFileName);
+    const cacheEntry = {
+      source: toolData.tool,
+      tool: toolData.tool,
+      query: toolData.query,
+      fetched: (/* @__PURE__ */ new Date()).toISOString(),
+      staleness: {
+        category: toolData.stalenessCategory || staleness.category,
+        maxAgeMinutes: staleness.maxAgeMinutes,
+        isStale: false
+      },
+      refreshHint: `Re-fetch ${toolData.tool} data for: ${toolData.query}`,
+      data: toolData.dataSummary
+    };
+    writeFileSync(cachePath, JSON.stringify(cacheEntry, null, 2), "utf-8");
+    agentIndex.knowledgeItems.push({
+      id: `tool-${sourceSlug}-${querySlug}`,
+      type: "tool_cache",
+      filePath: `tool-cache/${cacheFileName}`,
+      title: `${toolData.tool}: ${toolData.query}`,
+      summary: toolData.dataSummary.slice(0, 200),
+      tags: [toolData.tool],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      staleness: {
+        category: staleness.category,
+        maxAgeMinutes: staleness.maxAgeMinutes,
+        lastFetched: (/* @__PURE__ */ new Date()).toISOString(),
+        isStale: false,
+        refreshHint: cacheEntry.refreshHint
+      }
+    });
+  }
+  appendToFeed(agentSlug, extraction.headline);
+  index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  saveKnowledgeIndex(index);
+  regenerateReadme(agentSlug, index);
+}
+function buildSessionSummary(extraction, transcript) {
+  const lines = [];
+  const today = formatDate(/* @__PURE__ */ new Date());
+  lines.push(`# Session Summary \u2014 ${today}`);
+  lines.push("");
+  lines.push(`**Agent:** ${transcript.agentSlug}`);
+  lines.push(`**Messages:** ${transcript.messageCount} | **Tools:** ${transcript.toolsUsed.join(", ") || "none"}`);
+  lines.push(`**Model:** ${transcript.usage.model} | **Cost:** $${transcript.usage.cost.toFixed(4)} | **Duration:** ${Math.round(transcript.usage.durationMs / 1e3)}s`);
+  lines.push("");
+  lines.push(`## Summary`);
+  lines.push(extraction.sessionSummary);
+  lines.push("");
+  if (extraction.keyDecisions.length > 0) {
+    lines.push(`## Decisions Made`);
+    for (const d of extraction.keyDecisions) {
+      lines.push(`- **${d.decision}** \u2014 ${d.reasoning}`);
+    }
+    lines.push("");
+  }
+  if (extraction.openThreads.length > 0) {
+    lines.push(`## Open Threads`);
+    for (const t of extraction.openThreads) {
+      const urgencyLabel = t.urgency === "high" ? "HIGH" : t.urgency === "medium" ? "MED" : "LOW";
+      lines.push(`- [${urgencyLabel}] ${t.description}${t.deadline ? ` (deadline: ${t.deadline})` : ""}`);
+    }
+    lines.push("");
+  }
+  if (extraction.factsLearned.length > 0) {
+    lines.push(`## Facts Learned`);
+    for (const f of extraction.factsLearned) {
+      lines.push(`- [${f.category}] ${f.fact}`);
+    }
+    lines.push("");
+  }
+  if (extraction.topicTags.length > 0) {
+    lines.push(`**Tags:** ${extraction.topicTags.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function appendToFeed(agentSlug, headline) {
+  const feedPath = getFeedPath();
+  mkdirSync(getKnowledgeDir(), { recursive: true });
+  let existing = "";
+  if (existsSync2(feedPath)) {
+    existing = readFileSync2(feedPath, "utf-8");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace("T", " ").slice(0, 16);
+  const entry = `[${timestamp}] ${agentSlug}: ${headline}
+`;
+  writeFileSync(feedPath, entry + existing, "utf-8");
+}
+function regenerateReadme(agentSlug, index) {
+  if (!index) {
+    index = loadKnowledgeIndex();
+  }
+  if (!index) return;
+  const agentIndex = index.agents[agentSlug];
+  if (!agentIndex) return;
+  const agentDir = getAgentKnowledgeDir(agentSlug);
+  const today = /* @__PURE__ */ new Date();
+  const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  const dayName = days[today.getDay()];
+  const todayStr = formatDate(today);
+  const lines = [];
+  lines.push(`# ${agentSlug} \u2014 Knowledge Briefing`);
+  lines.push(
+    `**Today:** ${todayStr} (${dayName}) | **Last session:** ${formatDateWithRelative(agentIndex.lastSessionDate)} | **Total sessions:** ${agentIndex.sessionCount}`
+  );
+  lines.push("");
+  const sessionItems = agentIndex.knowledgeItems.filter((i) => i.type === "session_summary").sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+  if (sessionItems.length > 0) {
+    lines.push(`## Active Context`);
+    const latest = sessionItems[0];
+    lines.push(`- Last session: ${latest.summary}`);
+    const recentItems = sessionItems.slice(0, 5);
+    const allThreads = [];
+    const seenThreads = /* @__PURE__ */ new Set();
+    const allFacts = [];
+    for (const item of recentItems) {
+      const itemPath = join2(agentDir, item.filePath);
+      if (!existsSync2(itemPath)) continue;
+      const content = readFileSync2(itemPath, "utf-8");
+      const threadStart = content.indexOf("\n## Open Threads\n");
+      if (threadStart !== -1) {
+        const afterHeader = content.indexOf("\n", threadStart + 1);
+        const nextSection = content.indexOf("\n## ", afterHeader + 1);
+        const tagsLine = content.indexOf("\n**Tags:", afterHeader + 1);
+        const threadEnd = Math.min(
+          nextSection === -1 ? content.length : nextSection,
+          tagsLine === -1 ? content.length : tagsLine
+        );
+        const threadBlock = content.slice(afterHeader + 1, threadEnd).trim();
+        for (const line of threadBlock.split("\n").filter((l) => l.startsWith("- "))) {
+          const key = line.toLowerCase().replace(/\s+/g, " ").trim();
+          if (!seenThreads.has(key)) {
+            seenThreads.add(key);
+            allThreads.push(line);
+          }
+        }
+      }
+      const factStart = content.indexOf("\n## Facts Learned\n");
+      if (factStart !== -1) {
+        const afterFactHeader = content.indexOf("\n", factStart + 1);
+        const nextFactSection = content.indexOf("\n## ", afterFactHeader + 1);
+        const factTagsLine = content.indexOf("\n**Tags:", afterFactHeader + 1);
+        const factEnd = Math.min(
+          nextFactSection === -1 ? content.length : nextFactSection,
+          factTagsLine === -1 ? content.length : factTagsLine
+        );
+        const factBlock = content.slice(afterFactHeader + 1, factEnd).trim();
+        for (const line of factBlock.split("\n").filter((l) => l.startsWith("- "))) {
+          allFacts.push(line);
+        }
+      }
+    }
+    if (allThreads.length > 0) {
+      lines.push("");
+      lines.push("**Open threads:**");
+      for (const thread of allThreads.slice(0, 5)) {
+        lines.push(thread);
+      }
+    }
+    if (allFacts.length > 0) {
+      lines.push("");
+      lines.push("**Key facts:**");
+      for (const fact of allFacts.slice(0, 5)) {
+        lines.push(fact);
+      }
+    }
+    lines.push("");
+  }
+  const feedPath = getFeedPath();
+  if (existsSync2(feedPath)) {
+    const feed = readFileSync2(feedPath, "utf-8");
+    const feedLines = feed.split("\n").filter((l) => l.trim().length > 0);
+    if (feedLines.length > 0) {
+      lines.push(`## Recent Activity (from all agents)`);
+      for (const line of feedLines.slice(0, 5)) {
+        lines.push(`- ${line}`);
+      }
+      lines.push("");
+    }
+  }
+  const toolItems = agentIndex.knowledgeItems.filter((i) => i.type === "tool_cache" && i.staleness);
+  if (toolItems.length > 0) {
+    lines.push(`## Tool Data Status`);
+    for (const item of toolItems) {
+      if (item.staleness) {
+        const stale = isStale(item.staleness.lastFetched, item.staleness.maxAgeMinutes);
+        const ageStr = formatStaleness(item.staleness.lastFetched);
+        const status = stale ? `STALE (last fetched ${ageStr})` : `Fresh (updated ${ageStr})`;
+        const hint = stale ? ` \u2014 ${item.staleness.refreshHint}` : "";
+        lines.push(`- ${item.title}: ${status}${hint}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push(`## Deep Knowledge Available (use Read to access)`);
+  const knowledgePath = getAgentKnowledgeDir(agentSlug);
+  const sessionsDir = join2(knowledgePath, "sessions");
+  if (existsSync2(sessionsDir)) {
+    const sessionFiles = readdirSync(sessionsDir).filter((f) => f.endsWith(".md"));
+    lines.push(`- sessions/ \u2014 ${sessionFiles.length} session summaries`);
+  }
+  const refDir = join2(knowledgePath, "reference");
+  if (existsSync2(refDir)) {
+    const refFiles = readdirSync(refDir).filter((f) => f.endsWith(".md"));
+    for (const file of refFiles) {
+      const item = agentIndex.knowledgeItems.find(
+        (i) => i.filePath === `reference/${file}`
+      );
+      const updated = item ? ` \u2014 last updated ${formatDateWithRelative(item.updatedAt)}` : "";
+      lines.push(`- reference/${file}${updated}`);
+    }
+  }
+  const decisionsPath = join2(knowledgePath, "decisions.md");
+  if (existsSync2(decisionsPath)) {
+    const content = readFileSync2(decisionsPath, "utf-8");
+    const decisionCount = (content.match(/^## /gm) || []).length;
+    lines.push(`- decisions.md \u2014 ${decisionCount} tracked decisions`);
+  }
+  lines.push("");
+  lines.push(`## How to Access Knowledge`);
+  lines.push(`Your knowledge library is at ${knowledgePath}/`);
+  lines.push(`  sessions/   \u2014 summaries of your past sessions`);
+  lines.push(`  reference/  \u2014 long-lived reference docs`);
+  lines.push(`  tool-cache/ \u2014 cached tool data (check staleness dates)`);
+  lines.push(`  decisions.md \u2014 running log of key decisions`);
+  lines.push(`Use Read to access any file. Use Grep to search across all agents' knowledge at ${getKnowledgeDir()}/`);
+  lines.push("");
+  writeFileSync(join2(agentDir, "README.md"), lines.join("\n"), "utf-8");
+}
+function loadQueue() {
+  const queuePath = getQueuePath();
+  if (!existsSync2(queuePath)) return { entries: [] };
+  try {
+    return JSON.parse(readFileSync2(queuePath, "utf-8"));
+  } catch {
+    return { entries: [] };
+  }
+}
+function saveQueue(queue) {
+  mkdirSync(getKnowledgeDir(), { recursive: true });
+  writeFileSync(getQueuePath(), JSON.stringify(queue, null, 2), "utf-8");
+}
+function enqueueTranscript(agentSlug, conversationId, transcriptPath) {
+  const queue = loadQueue();
+  queue.entries.push({
+    agentSlug,
+    conversationId,
+    transcriptPath,
+    enqueuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "pending"
+  });
+  saveQueue(queue);
+}
+
+// src/memory/pipeline/extract.ts
+async function extractFromTranscript(transcript) {
+  const transcriptText = transcript.entries.map((entry) => {
+    switch (entry.type) {
+      case "user_message":
+        return `[USER]: ${entry.content}`;
+      case "assistant_text":
+        return `[ASSISTANT]: ${entry.content}`;
+      case "tool_call":
+        return `[TOOL CALL: ${entry.metadata?.toolName}]: ${entry.content}`;
+      case "tool_result":
+        return `[TOOL RESULT: ${entry.metadata?.toolName} (${entry.metadata?.status})]: ${entry.content}`;
+      default:
+        return entry.content;
+    }
+  }).join("\n\n");
+  const existingIndex = loadKnowledgeIndex();
+  const prompt = buildExtractionPrompt(
+    transcriptText,
+    transcript.agentSlug,
+    existingIndex
+  );
+  const response = await callOpenRouter([
+    { role: "user", content: prompt }
+  ], {
+    maxTokens: 4096,
+    temperature: 0.2
+  });
+  return parseExtractionResponse(response);
+}
+function parseExtractionResponse(response) {
+  let cleaned = response.trim();
+  if (cleaned.startsWith("```")) {
+    cleaned = cleaned.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  try {
+    const parsed = JSON.parse(cleaned);
+    return {
+      sessionSummary: parsed.session_summary || "No summary extracted.",
+      headline: parsed.headline || "Session completed",
+      keyDecisions: (parsed.key_decisions || []).map((d) => ({
+        decision: d.decision || "",
+        reasoning: d.reasoning || "",
+        date: d.date || (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      })),
+      factsLearned: (parsed.facts_learned || []).map((f) => ({
+        fact: f.fact || "",
+        category: f.category || "general"
+      })),
+      openThreads: (parsed.open_threads || []).map((t) => ({
+        description: t.description || "",
+        urgency: t.urgency || "medium",
+        deadline: t.deadline || void 0
+      })),
+      toolData: (parsed.tool_data || []).map((t) => ({
+        tool: t.tool || "",
+        query: t.query || "",
+        dataSummary: t.data_summary || "",
+        stalenessCategory: t.staleness_category || "semi_dynamic"
+      })),
+      upsertTargets: (parsed.upsert_targets || []).map((u) => ({
+        existingFileSlug: u.existing_file_slug || "",
+        updateSummary: u.update_summary || ""
+      })),
+      topicTags: parsed.topic_tags || []
+    };
+  } catch {
+    return {
+      sessionSummary: response.slice(0, 500),
+      headline: "Session completed (extraction failed)",
+      keyDecisions: [],
+      factsLearned: [],
+      openThreads: [],
+      toolData: [],
+      upsertTargets: [],
+      topicTags: []
+    };
+  }
+}
+
+// src/memory/pipeline/maintain.ts
+import {
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  unlinkSync
+} from "fs";
+import { join as join3 } from "path";
+function runMaintenance() {
+  let staleMarked = 0;
+  let readmesRegenerated = 0;
+  let transcriptsDeleted = 0;
+  const index = loadKnowledgeIndex();
+  if (!index) return { staleMarked, readmesRegenerated, transcriptsDeleted };
+  for (const [slug, agentData] of Object.entries(index.agents)) {
+    for (const item of agentData.knowledgeItems) {
+      if (item.type === "tool_cache" && item.staleness) {
+        const wasStale = item.staleness.isStale;
+        item.staleness.isStale = isStale(
+          item.staleness.lastFetched,
+          item.staleness.maxAgeMinutes
+        );
+        if (!wasStale && item.staleness.isStale) {
+          staleMarked++;
+        }
+        const cachePath = join3(getKnowledgeDir(), slug, item.filePath);
+        if (existsSync3(cachePath)) {
+          try {
+            const cacheEntry = JSON.parse(
+              readFileSync3(cachePath, "utf-8")
+            );
+            cacheEntry.staleness.isStale = item.staleness.isStale;
+            writeFileSync2(cachePath, JSON.stringify(cacheEntry, null, 2), "utf-8");
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  const indexPath = join3(getKnowledgeDir(), "_index.json");
+  writeFileSync2(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  for (const slug of Object.keys(index.agents)) {
+    regenerateReadme(slug, index);
+    readmesRegenerated++;
+  }
+  const transcriptsDir = getTranscriptsDir();
+  if (existsSync3(transcriptsDir)) {
+    const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+    try {
+      const agentDirs = readdirSync2(transcriptsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const agentDir of agentDirs) {
+        const agentTranscriptsPath = join3(transcriptsDir, agentDir);
+        const files = readdirSync2(agentTranscriptsPath).filter(
+          (f) => f.endsWith(".json")
+        );
+        for (const file of files) {
+          const filePath = join3(agentTranscriptsPath, file);
+          try {
+            const transcript = JSON.parse(readFileSync3(filePath, "utf-8"));
+            const startedAt = new Date(transcript.startedAt).getTime();
+            if (startedAt < thirtyDaysAgo) {
+              unlinkSync(filePath);
+              transcriptsDeleted++;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return { staleMarked, readmesRegenerated, transcriptsDeleted };
+}
+
+// src/memory/index.ts
+function saveTranscript(transcript) {
+  const transcriptsDir = join4(
+    getTranscriptsDir(),
+    transcript.agentSlug
+  );
+  mkdirSync2(transcriptsDir, { recursive: true });
+  const filePath = join4(transcriptsDir, `${transcript.conversationId}.json`);
+  writeFileSync3(filePath, JSON.stringify(transcript, null, 2), "utf-8");
+  enqueueTranscript(
+    transcript.agentSlug,
+    transcript.conversationId,
+    filePath
+  );
+  return filePath;
+}
+async function processTranscript(transcript) {
+  const extraction = await extractFromTranscript(transcript);
+  organizeKnowledge(extraction, transcript);
+}
+async function processQueue() {
+  if (!isMemoryAgentConfigured()) {
+    return { processed: 0, failed: 0, skipped: 0 };
+  }
+  const queue = loadQueue();
+  let processed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const entry of queue.entries) {
+    if (entry.status !== "pending") {
+      skipped++;
+      continue;
+    }
+    entry.status = "processing";
+    saveQueue(queue);
+    try {
+      if (!existsSync4(entry.transcriptPath)) {
+        entry.status = "failed";
+        entry.error = "Transcript file not found";
+        failed++;
+        continue;
+      }
+      const transcript = JSON.parse(
+        readFileSync4(entry.transcriptPath, "utf-8")
+      );
+      await processTranscript(transcript);
+      entry.status = "completed";
+      processed++;
+    } catch (err) {
+      entry.status = "failed";
+      entry.error = err instanceof Error ? err.message : String(err);
+      failed++;
+    }
+    saveQueue(queue);
+  }
+  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1e3;
+  queue.entries = queue.entries.filter(
+    (e) => e.status !== "completed" || new Date(e.enqueuedAt).getTime() > oneDayAgo
+  );
+  saveQueue(queue);
+  return { processed, failed, skipped };
+}
+function getMemoryStatus() {
+  const configured = isMemoryAgentConfigured();
+  let model;
+  const configPath = join4(homedir3(), ".claude", "forge", "config.json");
+  if (existsSync4(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+      model = config.memoryAgent?.model;
+    } catch {
+    }
+  }
+  const queue = loadQueue();
+  const queueDepth = queue.entries.filter((e) => e.status === "pending").length;
+  const agentStats = [];
+  const indexPath = join4(getKnowledgeDir(), "_index.json");
+  if (existsSync4(indexPath)) {
+    try {
+      const index = JSON.parse(readFileSync4(indexPath, "utf-8"));
+      for (const [slug, data] of Object.entries(index.agents || {})) {
+        const agentData = data;
+        agentStats.push({
+          slug,
+          sessionCount: agentData.sessionCount || 0,
+          knowledgeItems: agentData.knowledgeItems?.length || 0,
+          lastProcessed: agentData.lastSessionDate
+        });
+      }
+    } catch {
+    }
+  }
+  return { configured, model, queueDepth, agentStats };
+}
+
+export {
+  getKnowledgeDir,
+  getTranscriptsDir,
+  enqueueTranscript,
+  runMaintenance,
+  saveTranscript,
+  processTranscript,
+  processQueue,
+  getMemoryStatus
+};