@lucapimenta/copy-chief-black 1.0.0

package/framework/.aios-core/copy-chief/memory/agent-memory-writeback.js

@@ -0,0 +1,178 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_memory_writeback_exports = {};
+__export(agent_memory_writeback_exports, {
+  AGENTS_DIR: () => AGENTS_DIR,
+  HOME: () => HOME,
+  PERSONA_MAP: () => PERSONA_MAP,
+  appendAndTrim: () => appendAndTrim,
+  buildEntry: () => buildEntry,
+  extractKeyLearnings: () => extractKeyLearnings,
+  extractPersona: () => extractPersona,
+  extractSummary: () => extractSummary,
+  handleAgentMemoryWriteback: () => handleAgentMemoryWriteback
+});
+module.exports = __toCommonJS(agent_memory_writeback_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+const HOME = process.env.HOME || "/tmp";
+const AGENTS_DIR = (0, import_path.join)(HOME, ".claude", "agents");
+const PERSONA_MAP = {
+  vox: "vox",
+  researcher: "vox",
+  "@researcher": "vox",
+  cipher: "cipher",
+  miner: "cipher",
+  "@miner": "cipher",
+  atlas: "atlas",
+  briefer: "atlas",
+  "@briefer": "atlas",
+  blade: "blade",
+  producer: "blade",
+  "@producer": "blade",
+  echo: "echo",
+  vsl: "echo",
+  "@vsl": "echo",
+  forge: "forge",
+  lp: "forge",
+  "@lp": "forge",
+  scout: "scout",
+  creative: "scout",
+  "@creative": "scout",
+  hawk: "hawk",
+  critic: "hawk",
+  "@critic": "hawk",
+  sentinel: "sentinel",
+  gatekeeper: "sentinel",
+  "@gatekeeper": "sentinel",
+  helix: "helix",
+  chief: "helix",
+  "@chief": "helix"
+};
+function extractPersona(description) {
+  if (!description) return null;
+  const prefixMatch = description.match(/^([A-Za-z@][A-Za-z_-]*)[\s:]/);
+  if (prefixMatch) {
+    const candidate = prefixMatch[1].toLowerCase().replace(/^@/, "");
+    if (PERSONA_MAP[candidate]) return PERSONA_MAP[candidate];
+    if (PERSONA_MAP[`@${candidate}`]) return PERSONA_MAP[`@${candidate}`];
+  }
+  const lower = description.toLowerCase();
+  for (const [keyword, dir] of Object.entries(PERSONA_MAP)) {
+    if (lower.includes(keyword.toLowerCase())) return dir;
+  }
+  return null;
+}
+function extractSummary(output, taskDesc) {
+  if (!output) return taskDesc.slice(0, 120);
+  const lines = output.split("\n").map((l) => l.trim()).filter(Boolean);
+  const meaningful = lines.filter((l) => !l.startsWith("#") && l.length > 10);
+  if (meaningful.length === 0) return taskDesc.slice(0, 120);
+  return meaningful[0].slice(0, 120);
+}
+function extractKeyLearnings(output) {
+  if (!output) return [];
+  const learnings = [];
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if ((trimmed.startsWith("- ") || trimmed.startsWith("* ") || trimmed.match(/^\d+\./)) && trimmed.length > 10) {
+      learnings.push(
+        trimmed.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "").slice(0, 100)
+      );
+      if (learnings.length >= 3) break;
+    }
+  }
+  if (learnings.length === 0) {
+    const meaningful = lines.map((l) => l.trim()).filter((l) => l.length > 15 && !l.startsWith("#")).slice(-2);
+    learnings.push(...meaningful.map((l) => l.slice(0, 100)));
+  }
+  return learnings.slice(0, 3);
+}
+function buildEntry(taskSummary, learnings) {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 16).replace("T", " ");
+  const keyLines = learnings.length > 0 ? learnings.map((l) => `- Key: ${l}`).join("\n") : "- Key: (no structured output detected)";
+  return `
+### ${dateStr} \u2014 ${taskSummary}
+${keyLines}
+`;
+}
+function appendAndTrim(memPath, entry) {
+  const existing = (0, import_fs.existsSync)(memPath) ? (0, import_fs.readFileSync)(memPath, "utf-8") : "";
+  const combined = existing.trimEnd() + "\n" + entry;
+  const allLines = combined.split("\n");
+  let finalLines;
+  if (allLines.length > 200) {
+    const header = allLines.slice(0, 20);
+    const recent = allLines.slice(-175);
+    finalLines = [
+      ...header,
+      "",
+      "<!-- Older entries trimmed by agent-memory-writeback.ts -->",
+      "",
+      ...recent
+    ];
+  } else {
+    finalLines = allLines;
+  }
+  (0, import_fs.writeFileSync)(memPath, finalLines.join("\n"), "utf-8");
+}
+function handleAgentMemoryWriteback(data, startMs, timeoutMs) {
+  if (data.tool_name !== "Agent") {
+    return { continue: true };
+  }
+  const description = data.tool_input?.description || "";
+  const output = typeof data.tool_output === "string" ? data.tool_output : JSON.stringify(data.tool_output || "");
+  const persona = extractPersona(description);
+  if (!persona) {
+    return {
+      continue: true,
+      feedback: "[AMW] No persona detected \u2014 skipping writeback"
+    };
+  }
+  if (Date.now() - startMs > timeoutMs) {
+    return {
+      continue: true,
+      feedback: "[AMW] Timeout after persona extract"
+    };
+  }
+  const memPath = (0, import_path.join)(AGENTS_DIR, persona, "MEMORY.md");
+  (0, import_fs.mkdirSync)((0, import_path.dirname)(memPath), { recursive: true });
+  const taskSummary = extractSummary(description, description);
+  const learnings = extractKeyLearnings(output);
+  const entry = buildEntry(taskSummary, learnings);
+  appendAndTrim(memPath, entry);
+  const elapsedMs = Date.now() - startMs;
+  return {
+    continue: true,
+    feedback: `[AMW] Memory written to ${persona}/MEMORY.md (${elapsedMs}ms)`
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENTS_DIR,
+  HOME,
+  PERSONA_MAP,
+  appendAndTrim,
+  buildEntry,
+  extractKeyLearnings,
+  extractPersona,
+  extractSummary,
+  handleAgentMemoryWriteback
+});

package/framework/.aios-core/copy-chief/memory/index-updater.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * Index Updater
+ *
+ * Maintains _index.yaml files for cross-agent memory queries.
+ * Allows querying entries across agents by niche, deliverable_type, etc.
+ *
+ * @module index-updater
+ * @version 1.0.0
+ */
+
+const fs = require('fs');
+const fsp = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+const AGENT_MEMORY_DIR = path.join(process.env.HOME, '.claude', 'agent-memory');
+const INDEX_MAX_ENTRIES = 200;
+
+class IndexUpdater {
+  constructor(options = {}) {
+    this.options = {
+      memoryDir: AGENT_MEMORY_DIR,
+      debug: false,
+      ...options,
+    };
+  }
+
+  /**
+   * Update the cross-agent index with a new entry.
+   */
+  async update(agentId, memoryType, entry) {
+    if (!entry.offer && !entry.niche) return; // Nothing to index
+
+    const indexPath = path.join(this.options.memoryDir, '_index.yaml');
+    let index = this._loadIndex(indexPath);
+
+    const niche = entry.niche || (entry.offer ? entry.offer.split('/')[0] : 'unknown');
+
+    index.entries.unshift({
+      agent: agentId,
+      memory_type: memoryType,
+      niche,
+      offer: entry.offer || null,
+      deliverable_type: entry.deliverable_type || null,
+      score: entry.score || null,
+      timestamp: entry.timestamp || new Date().toISOString(),
+      summary: (entry.learning || entry.task || '').slice(0, 100),
+    });
+
+    // Cap
+    if (index.entries.length > INDEX_MAX_ENTRIES) {
+      index.entries = index.entries.slice(0, INDEX_MAX_ENTRIES);
+    }
+
+    index.updated_at = new Date().toISOString();
+    await this._save(indexPath, index);
+  }
+
+  /**
+   * Query the index for entries matching filters.
+   */
+  query(filter = {}) {
+    const indexPath = path.join(this.options.memoryDir, '_index.yaml');
+    const index = this._loadIndex(indexPath);
+
+    return index.entries.filter(entry => {
+      if (filter.niche && entry.niche !== filter.niche) return false;
+      if (filter.agent && entry.agent !== filter.agent) return false;
+      if (filter.deliverable_type && entry.deliverable_type !== filter.deliverable_type) return false;
+      if (filter.offer && entry.offer !== filter.offer) return false;
+      return true;
+    });
+  }
+
+  _loadIndex(indexPath) {
+    if (!fs.existsSync(indexPath)) {
+      return { version: '1.0', entries: [], updated_at: new Date().toISOString() };
+    }
+
+    try {
+      const content = fs.readFileSync(indexPath, 'utf8');
+      const data = yaml.load(content);
+      if (!data || !Array.isArray(data.entries)) {
+        return { version: '1.0', entries: [], updated_at: new Date().toISOString() };
+      }
+      return data;
+    } catch {
+      return { version: '1.0', entries: [], updated_at: new Date().toISOString() };
+    }
+  }
+
+  async _save(indexPath, index) {
+    const dir = path.dirname(indexPath);
+    await fsp.mkdir(dir, { recursive: true });
+
+    const tmpPath = indexPath + '.tmp';
+    await fsp.writeFile(tmpPath, yaml.dump(index, { lineWidth: 120, noRefs: true }), 'utf8');
+    await fsp.rename(tmpPath, indexPath);
+  }
+}
+
+module.exports = { IndexUpdater };

package/framework/.aios-core/copy-chief/memory/memory-compactor.js

@@ -0,0 +1,152 @@
+'use strict';
+
+/**
+ * Memory Compactor
+ *
+ * Groups episodic entries by offer+deliverable_type, extracts proven patterns
+ * into technique-register entries, prunes episodic to ≤30 entries.
+ *
+ * Source: AIOS Agent Memory — 3-file architecture with caps (50/30/20)
+ * Pattern: PatternStore auto-prune at 90% capacity
+ *
+ * @module memory-compactor
+ * @version 1.0.0
+ * @atom U-07
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const AGENT_MEMORY_DIR = path.join(process.env.HOME, '.claude', 'agent-memory');
+const EPISODIC_CAP_POST_COMPACT = 30;
+const MIN_GROUP_SIZE_FOR_TECHNIQUE = 3;
+const TECHNIQUE_MIN_SCORE = 6;
+
+/**
+ * Compact episodic memory for a single agent.
+ * Groups by offer+deliverable_type, extracts techniques, prunes old entries.
+ *
+ * @param {string} agentId - Agent identifier (e.g. 'echo', 'scout')
+ * @param {object} memoryManager - AgentMemoryManager instance
+ * @returns {{ prunedCount: number, techniquesExtracted: number }}
+ */
+async function compactAgent(agentId, memoryManager) {
+  const episodic = memoryManager.load(agentId, 'episodic');
+
+  if (episodic.length <= EPISODIC_CAP_POST_COMPACT) {
+    return { prunedCount: 0, techniquesExtracted: 0 };
+  }
+
+  // Group by offer + deliverable_type
+  const groups = {};
+  for (const entry of episodic) {
+    const key = `${entry.offer || 'unknown'}::${entry.deliverable_type || 'unknown'}`;
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(entry);
+  }
+
+  // Extract techniques from groups with 3+ entries and good scores
+  let techniquesExtracted = 0;
+  const existingTechniques = memoryManager.load(agentId, 'technique-register');
+  const existingNames = new Set(existingTechniques.map(t => t.name));
+
+  for (const [key, entries] of Object.entries(groups)) {
+    if (entries.length < MIN_GROUP_SIZE_FOR_TECHNIQUE) continue;
+
+    const scored = entries.filter(e => e.score && e.score >= TECHNIQUE_MIN_SCORE);
+    if (scored.length < 2) continue;
+
+    const [offer, deliverableType] = key.split('::');
+    const niche = offer.includes('/') ? offer.split('/')[0] : 'unknown';
+
+    // Build technique from high-scoring entries
+    const learnings = scored
+      .filter(e => e.learning)
+      .map(e => e.learning)
+      .slice(0, 5);
+
+    if (learnings.length === 0) continue;
+
+    const techniqueName = `${deliverableType}-pattern-${offer.replace(/\//g, '-')}`;
+    if (existingNames.has(techniqueName)) continue;
+
+    const technique = {
+      name: techniqueName,
+      offer,
+      niche,
+      deliverable_type: deliverableType,
+      description: learnings.join(' | '),
+      source_count: scored.length,
+      avg_score: Math.round((scored.reduce((s, e) => s + (e.score || 0), 0) / scored.length) * 10) / 10,
+      extracted_from: 'compaction',
+      timestamp: new Date().toISOString(),
+    };
+
+    await memoryManager.append(agentId, 'technique-register', technique);
+    existingNames.add(techniqueName);
+    techniquesExtracted++;
+  }
+
+  // Prune episodic to cap — keep most recent entries
+  const prunedCount = episodic.length - EPISODIC_CAP_POST_COMPACT;
+  if (prunedCount > 0) {
+    const kept = episodic.slice(0, EPISODIC_CAP_POST_COMPACT);
+    const filePath = path.join(AGENT_MEMORY_DIR, agentId, 'episodic.yaml');
+
+    // Backup before prune
+    const backupPath = filePath + '.pre-compact';
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.copyFileSync(filePath, backupPath);
+      }
+    } catch { /* non-critical */ }
+
+    // Write pruned entries via manager's internal method
+    const yaml = require('js-yaml');
+    const tmpPath = filePath + '.tmp';
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tmpPath, yaml.dump(kept, { lineWidth: 120, noRefs: true }), 'utf8');
+    fs.renameSync(tmpPath, filePath);
+  }
+
+  return { prunedCount: Math.max(0, prunedCount), techniquesExtracted };
+}
+
+/**
+ * Compact memory for all agents that have episodic files.
+ *
+ * @param {object} memoryManager - AgentMemoryManager instance
+ * @returns {{ agents: Object.<string, {prunedCount: number, techniquesExtracted: number}>, totalPruned: number, totalTechniques: number }}
+ */
+async function compactAll(memoryManager) {
+  const memDir = memoryManager.options?.memoryDir || AGENT_MEMORY_DIR;
+  const result = { agents: {}, totalPruned: 0, totalTechniques: 0 };
+
+  if (!fs.existsSync(memDir)) return result;
+
+  try {
+    const dirs = fs.readdirSync(memDir, { withFileTypes: true });
+    for (const dir of dirs) {
+      if (!dir.isDirectory()) continue;
+      const agentId = dir.name;
+      const episodicPath = path.join(memDir, agentId, 'episodic.yaml');
+      if (!fs.existsSync(episodicPath)) continue;
+
+      try {
+        const agentResult = await compactAgent(agentId, memoryManager);
+        if (agentResult.prunedCount > 0 || agentResult.techniquesExtracted > 0) {
+          result.agents[agentId] = agentResult;
+          result.totalPruned += agentResult.prunedCount;
+          result.totalTechniques += agentResult.techniquesExtracted;
+        }
+      } catch (e) {
+        // Non-critical — skip agent
+      }
+    }
+  } catch { /* empty dir or no access */ }
+
+  return result;
+}
+
+module.exports = { compactAgent, compactAll, EPISODIC_CAP_POST_COMPACT, MIN_GROUP_SIZE_FOR_TECHNIQUE };

package/framework/.aios-core/copy-chief/memory/memory-populator.js

@@ -0,0 +1,215 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memory_populator_exports = {};
+__export(memory_populator_exports, {
+  EPISODIC_DIR: () => EPISODIC_DIR,
+  HOME: () => HOME,
+  KNOWN_OFFERS: () => KNOWN_OFFERS,
+  MEMORY_DIR: () => MEMORY_DIR,
+  NARRATIVE_DIR: () => NARRATIVE_DIR,
+  NICHO_MAP: () => NICHO_MAP,
+  ensureDir: () => ensureDir,
+  handleGatePass: () => handleGatePass,
+  handleProductionWrite: () => handleProductionWrite,
+  inferDeliverableType: () => inferDeliverableType,
+  nextId: () => nextId,
+  nowIso: () => nowIso,
+  parseOfferFromPath: () => parseOfferFromPath,
+  readYamlLines: () => readYamlLines,
+  runMemoryPopulate: () => runMemoryPopulate,
+  today: () => today
+});
+module.exports = __toCommonJS(memory_populator_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+production;
+const HOME = process.env.HOME || "/tmp";
+const MEMORY_DIR = (0, import_path.join)(HOME, ".claude", "memory");
+const EPISODIC_DIR = (0, import_path.join)(MEMORY_DIR, "episodic");
+const NARRATIVE_DIR = (0, import_path.join)(MEMORY_DIR, "narrative");
+const KNOWN_OFFERS = ["florayla", "neuvelys", "quimica-amarracao", "decifra-lei-seca"];
+const NICHO_MAP = {
+  florayla: "saude",
+  neuvelys: "saude",
+  "quimica-amarracao": "relacionamento",
+  "decifra-lei-seca": "concursos"
+};
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nextId(existingIds) {
+  const prefix = today();
+  const todayIds = existingIds.filter((id) => id.startsWith(prefix));
+  const seq = (todayIds.length + 1).toString().padStart(3, "0");
+  return `${prefix}-${seq}`;
+}
+function readYamlLines(path) {
+  if (!(0, import_fs.existsSync)(path)) return "";
+  return (0, import_fs.readFileSync)(path, "utf-8");
+}
+function ensureDir(dir) {
+  (0, import_fs.mkdirSync)(dir, { recursive: true });
+}
+function parseOfferFromPath(filePath) {
+  const m = filePath.match(/\/(saude|relacionamento|concursos|riqueza)\/([^/]+)\/production\/([^/]*)\//);
+  if (!m) {
+    const m2 = filePath.match(/\/(saude|relacionamento|concursos|riqueza)\/([^/]+)\/production\/([^/]+)$/);
+    if (!m2) return null;
+    return { nicho: m2[1], offer: m2[2], deliverableType: inferDeliverableType(m2[3], "") };
+  }
+  return { nicho: m[1], offer: m[2], deliverableType: inferDeliverableType(m[3], filePath) };
+}
+function inferDeliverableType(segment, fullPath) {
+  const s = (segment + fullPath).toLowerCase();
+  if (s.includes("vsl")) return "vsl";
+  if (s.includes("landing") || s.includes("lp-")) return "landing-page";
+  if (s.includes("email")) return "emails";
+  if (s.includes("criativo") || s.includes("creative")) return "creatives";
+  if (s.includes("mup") || s.includes("mus")) return "mup-mus";
+  return "generic";
+}
+function handleProductionWrite(toolInput) {
+  const filePath = toolInput?.tool_input?.file_path || toolInput?.file_path || "";
+  if (!filePath) return;
+  const parsed = parseOfferFromPath(filePath);
+  if (!parsed) return;
+  const { offer, nicho, deliverableType } = parsed;
+  const filename = filePath.split("/").pop() || filePath;
+  ensureDir(EPISODIC_DIR);
+  const episodicPath = (0, import_path.join)(EPISODIC_DIR, `${offer}.yaml`);
+  const existing = readYamlLines(episodicPath);
+  const idMatches = [...existing.matchAll(/id:\s*(\d{4}-\d{2}-\d{2}-\d{3})/g)].map((m) => m[1]);
+  const id = nextId(idMatches);
+  const entryBlock = [
+    `  - # ${id}`,
+    `    id: ${id}`,
+    `    date: "${today()}"`,
+    `    deliverable: "${filename.replace(/\.[^.]+$/, "")}"`,
+    `    deliverable_type: "${deliverableType}"`,
+    `    persona: "helix"`,
+    `    outcome: "success"`,
+    `    learning: Arquivo ${filename} produzido em production/. Revisar blind_critic e EST apos validacao.`,
+    `    tags: ["${deliverableType}", "${offer}", "auto-populated"]`
+  ].join("\n");
+  if (!existing) {
+    const header = [
+      `# Episodic Memory \u2014 ${offer}`,
+      `# Nicho: ${nicho}`,
+      `# Auto-generated by memory-auto-populate.ts`,
+      ``,
+      `offer: "${offer}"`,
+      `nicho: "${nicho}"`,
+      `entries:`,
+      entryBlock
+    ].join("\n");
+    (0, import_fs.writeFileSync)(episodicPath, header + "\n");
+  } else {
+    (0, import_fs.writeFileSync)(episodicPath, existing.trimEnd() + "\n" + entryBlock + "\n");
+  }
+}
+function handleGatePass(toolInput, toolOutput) {
+  const outputStr = typeof toolOutput === "string" ? toolOutput : JSON.stringify(toolOutput || "");
+  const inputStr = JSON.stringify(toolInput?.tool_input || toolInput || "");
+  const combined = outputStr + " " + inputStr;
+  const phaseMatch = combined.match(/phase['":\s]+([a-z]+)/i);
+  const phase = phaseMatch?.[1]?.toLowerCase() || "research";
+  const offerMatch = combined.match(/offer['":\s]+([a-z][a-z0-9-]+)/i);
+  let offer = offerMatch?.[1] || "";
+  if (!offer) {
+    for (const o of KNOWN_OFFERS) {
+      if (combined.includes(o)) {
+        offer = o;
+        break;
+      }
+    }
+  }
+  if (!offer) return;
+  const passed = /pass|approved|true|success/i.test(outputStr);
+  if (!passed) return;
+  const nicho = NICHO_MAP[offer] || "generic";
+  ensureDir(NARRATIVE_DIR);
+  const narrativePath = (0, import_path.join)(NARRATIVE_DIR, `${offer}.yaml`);
+  const existing = readYamlLines(narrativePath);
+  const idMatches = [...existing.matchAll(/id:\s*(\d{4}-\d{2}-\d{2}-\d{3})/g)].map((m) => m[1]);
+  const id = nextId(idMatches);
+  const ts = nowIso();
+  const insightBlock = [
+    `  - # ${id} \u2014 delivery-learning`,
+    `    id: ${id}`,
+    `    date: "${today()}"`,
+    `    phase: "${phase}"`,
+    `    category: "delivery-learning"`,
+    `    insight: |`,
+    `      Gate ${phase} passed para ${offer}. Proximo: avancar para fase seguinte.`,
+    `    confidence: ALTA`,
+    `    evidence: validate_gate result positive`,
+    `    tags: ["gate-pass", "${phase}", "${offer}"]`
+  ].join("\n");
+  if (!existing) {
+    const header = [
+      `# Narrative Memory \u2014 ${offer}`,
+      `# Nicho: ${nicho}`,
+      `# Auto-generated by memory-auto-populate.ts`,
+      ``,
+      `offer: "${offer}"`,
+      `nicho: "${nicho}"`,
+      `created_at: "${ts}"`,
+      `updated_at: "${ts}"`,
+      `current_phase: "${phase}"`,
+      `insights:`,
+      insightBlock
+    ].join("\n");
+    (0, import_fs.writeFileSync)(narrativePath, header + "\n");
+  } else {
+    const updated = existing.replace(/updated_at:\s*"[^"]*"/, `updated_at: "${ts}"`).trimEnd();
+    (0, import_fs.writeFileSync)(narrativePath, updated + "\n" + insightBlock + "\n");
+  }
+}
+function runMemoryPopulate(input) {
+  const toolName = input?.tool_name || "";
+  if (toolName === "mcp__copywriting__validate_gate") {
+    handleGatePass(input, input?.tool_response ?? input?.tool_output ?? "");
+  } else if (toolName === "Write" || toolName === "Edit") {
+    const filePath = input?.tool_input?.file_path || input?.file_path || "";
+    if (filePath.includes("/production/")) {
+      handleProductionWrite(input);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EPISODIC_DIR,
+  HOME,
+  KNOWN_OFFERS,
+  MEMORY_DIR,
+  NARRATIVE_DIR,
+  NICHO_MAP,
+  ensureDir,
+  handleGatePass,
+  handleProductionWrite,
+  inferDeliverableType,
+  nextId,
+  nowIso,
+  parseOfferFromPath,
+  readYamlLines,
+  runMemoryPopulate,
+  today
+});