@goondocks/myco 0.20.2 → 0.21.1

package/dist/chunk-N7Z3LUEZ.js

@@ -0,0 +1,858 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  enqueueOutbox,
+  getTeamMachineId,
+  isTeamSyncEnabled,
+  listSessions,
+  syncRow
+} from "./chunk-RQSJLWP4.js";
+import {
+  COLLECTIVE_TOOL_DEFINITIONS,
+  TOOL_DEFINITIONS,
+  getToolCortexPriority
+} from "./chunk-EEOJWLMP.js";
+import {
+  getDatabase
+} from "./chunk-MYX5NCRH.js";
+import {
+  CONTENT_HASH_ALGORITHM,
+  DEFAULT_AGENT_ID,
+  DIGEST_FALLBACK_TIER,
+  DIGEST_TIERS,
+  epochSeconds
+} from "./chunk-6C6QZ4PM.js";
+
+// src/db/queries/cortex-instructions.ts
+var CORTEX_INSTRUCTION_COLUMNS = [
+  "id",
+  "agent_id",
+  "content",
+  "input_hash",
+  "source_run_id",
+  "generated_at",
+  "machine_id",
+  "synced_at"
+];
+var SELECT_COLUMNS = CORTEX_INSTRUCTION_COLUMNS.join(", ");
+var DEFAULT_CORTEX_INSTRUCTIONS_ID = "session-start";
+function toCortexInstructionsRow(row) {
+  return {
+    id: row.id,
+    agent_id: row.agent_id,
+    content: row.content,
+    input_hash: row.input_hash,
+    source_run_id: row.source_run_id ?? null,
+    generated_at: row.generated_at,
+    machine_id: row.machine_id ?? "local",
+    synced_at: row.synced_at ?? null
+  };
+}
+function upsertCortexInstructions(input) {
+  const db = getDatabase();
+  const id = input.id ?? `${input.agent_id}:${DEFAULT_CORTEX_INSTRUCTIONS_ID}`;
+  const row = db.prepare(
+    `INSERT INTO cortex_instructions (
+       id, agent_id, content, input_hash, source_run_id, generated_at, machine_id
+     ) VALUES (
+       ?, ?, ?, ?, ?, ?, ?
+     )
+     ON CONFLICT (id) DO UPDATE SET
+       content = EXCLUDED.content,
+       input_hash = EXCLUDED.input_hash,
+       source_run_id = EXCLUDED.source_run_id,
+       generated_at = EXCLUDED.generated_at,
+       machine_id = EXCLUDED.machine_id
+     RETURNING ${SELECT_COLUMNS}`
+  ).get(
+    id,
+    input.agent_id,
+    input.content,
+    input.input_hash,
+    input.source_run_id ?? null,
+    input.generated_at,
+    input.machine_id ?? getTeamMachineId()
+  );
+  return toCortexInstructionsRow(row);
+}
+function getCortexInstructions(agentId) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS}
+     FROM cortex_instructions
+     WHERE agent_id = ?
+     ORDER BY generated_at DESC
+     LIMIT 1`
+  ).get(agentId);
+  return row ? toCortexInstructionsRow(row) : null;
+}
+
+// src/db/queries/digest-extracts.ts
+var EXTRACT_COLUMNS = [
+  "id",
+  "agent_id",
+  "tier",
+  "content",
+  "substrate_hash",
+  "generated_at",
+  "machine_id",
+  "synced_at"
+];
+var SELECT_COLUMNS2 = EXTRACT_COLUMNS.join(", ");
+function toDigestExtractRow(row) {
+  return {
+    id: row.id,
+    agent_id: row.agent_id,
+    tier: row.tier,
+    content: row.content,
+    substrate_hash: row.substrate_hash ?? null,
+    generated_at: row.generated_at,
+    machine_id: row.machine_id ?? "local",
+    synced_at: row.synced_at ?? null
+  };
+}
+function upsertDigestExtract(data, options = {}) {
+  if (options.dryRun) return null;
+  const db = getDatabase();
+  return db.transaction(() => {
+    const existingRow = db.prepare(
+      `SELECT ${SELECT_COLUMNS2} FROM digest_extracts WHERE agent_id = ? AND tier = ?`
+    ).get(data.agent_id, data.tier);
+    if (existingRow) {
+      const priorRevisionId = db.prepare(
+        `SELECT id FROM digest_extract_revisions
+         WHERE agent_id = ? AND tier = ?
+         ORDER BY id DESC
+         LIMIT 1`
+      ).get(data.agent_id, data.tier);
+      db.prepare(
+        `INSERT INTO digest_extract_revisions
+           (agent_id, tier, content, metadata, run_id, parent_revision_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        data.agent_id,
+        data.tier,
+        existingRow.content,
+        options.metadata ?? null,
+        options.runId ?? null,
+        priorRevisionId?.id ?? null,
+        epochSeconds()
+      );
+    }
+    db.prepare(
+      `INSERT INTO digest_extracts (agent_id, tier, content, generated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT (agent_id, tier) DO UPDATE SET
+         content = EXCLUDED.content,
+         generated_at = EXCLUDED.generated_at`
+    ).run(data.agent_id, data.tier, data.content, data.generated_at);
+    const row = db.prepare(
+      `SELECT ${SELECT_COLUMNS2} FROM digest_extracts WHERE agent_id = ? AND tier = ?`
+    ).get(data.agent_id, data.tier);
+    return toDigestExtractRow(row);
+  })();
+}
+function getDigestExtract(agentId, tier) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS2} FROM digest_extracts
+     WHERE agent_id = ? AND tier = ?`
+  ).get(agentId, tier);
+  if (!row) return null;
+  return toDigestExtractRow(row);
+}
+function listDigestExtracts(agentId) {
+  const db = getDatabase();
+  const tierPlaceholders = DIGEST_TIERS.map(() => "?").join(", ");
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS2}
+     FROM digest_extracts
+     WHERE agent_id = ? AND tier IN (${tierPlaceholders})
+     ORDER BY tier ASC`
+  ).all(agentId, ...DIGEST_TIERS);
+  return rows.map(toDigestExtractRow);
+}
+var REVISION_COLUMNS = [
+  "id",
+  "agent_id",
+  "tier",
+  "content",
+  "metadata",
+  "run_id",
+  "parent_revision_id",
+  "created_at"
+];
+var REVISION_SELECT = REVISION_COLUMNS.join(", ");
+function toRevisionRow(row) {
+  return {
+    id: row.id,
+    agent_id: row.agent_id,
+    tier: row.tier,
+    content: row.content,
+    metadata: row.metadata ?? null,
+    run_id: row.run_id ?? null,
+    parent_revision_id: row.parent_revision_id ?? null,
+    created_at: row.created_at
+  };
+}
+function listDigestRevisions(options) {
+  const db = getDatabase();
+  const limit = options.limit ?? 50;
+  const rows = db.prepare(
+    `SELECT ${REVISION_SELECT}
+     FROM digest_extract_revisions
+     WHERE agent_id = ? AND tier = ?
+     ORDER BY created_at DESC, id DESC
+     LIMIT ?`
+  ).all(options.agentId, options.tier, limit);
+  return rows.map(toRevisionRow);
+}
+function rollbackDigestExtract(options) {
+  const db = getDatabase();
+  const revision = db.prepare(
+    `SELECT ${REVISION_SELECT}
+     FROM digest_extract_revisions
+     WHERE id = ?`
+  ).get(options.revisionId);
+  if (!revision) return null;
+  const agentId = revision.agent_id;
+  const tier = revision.tier;
+  const targetContent = revision.content;
+  const now = epochSeconds();
+  return db.transaction(() => {
+    const currentRow = db.prepare(
+      `SELECT ${SELECT_COLUMNS2} FROM digest_extracts WHERE agent_id = ? AND tier = ?`
+    ).get(agentId, tier);
+    let newRevisionId = null;
+    if (currentRow) {
+      const priorRevisionId = db.prepare(
+        `SELECT id FROM digest_extract_revisions
+         WHERE agent_id = ? AND tier = ?
+         ORDER BY id DESC
+         LIMIT 1`
+      ).get(agentId, tier);
+      const info = db.prepare(
+        `INSERT INTO digest_extract_revisions
+           (agent_id, tier, content, metadata, run_id, parent_revision_id, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        agentId,
+        tier,
+        currentRow.content,
+        JSON.stringify({ rollback_of: options.revisionId }),
+        options.runId ?? null,
+        priorRevisionId?.id ?? null,
+        now
+      );
+      newRevisionId = Number(info.lastInsertRowid);
+    }
+    db.prepare(
+      `INSERT INTO digest_extracts (agent_id, tier, content, generated_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT (agent_id, tier) DO UPDATE SET
+         content = EXCLUDED.content,
+         generated_at = EXCLUDED.generated_at`
+    ).run(agentId, tier, targetContent, now);
+    const restored = db.prepare(
+      `SELECT ${SELECT_COLUMNS2} FROM digest_extracts WHERE agent_id = ? AND tier = ?`
+    ).get(agentId, tier);
+    return {
+      row: toDigestExtractRow(restored),
+      newRevisionId
+    };
+  })();
+}
+
+// src/db/queries/plans.ts
+var DEFAULT_LIST_LIMIT = 100;
+var DEFAULT_STATUS = "active";
+var DEFAULT_PROCESSED = 0;
+var PLAN_COLUMNS = [
+  "id",
+  "logical_key",
+  "status",
+  "author",
+  "title",
+  "content",
+  "source_path",
+  "tags",
+  "session_id",
+  "prompt_batch_id",
+  "content_hash",
+  "processed",
+  "embedded",
+  "created_at",
+  "updated_at",
+  "machine_id",
+  "synced_at"
+];
+var SELECT_COLUMNS3 = PLAN_COLUMNS.join(", ");
+function toPlanRow(row) {
+  return {
+    id: row.id,
+    logical_key: row.logical_key,
+    status: row.status,
+    author: row.author ?? null,
+    title: row.title ?? null,
+    content: row.content ?? null,
+    source_path: row.source_path ?? null,
+    tags: row.tags ?? null,
+    session_id: row.session_id ?? null,
+    prompt_batch_id: row.prompt_batch_id ?? null,
+    content_hash: row.content_hash ?? null,
+    processed: row.processed,
+    embedded: row.embedded ?? 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at ?? null,
+    machine_id: row.machine_id ?? "local",
+    synced_at: row.synced_at ?? null
+  };
+}
+function upsertPlan(data) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO plans (
+       id, logical_key, status, author, title, content,
+       source_path, tags, session_id, prompt_batch_id, content_hash,
+       processed, created_at, updated_at, machine_id
+     ) VALUES (
+       ?, ?, ?, ?, ?, ?,
+       ?, ?, ?, ?, ?,
+       ?, ?, ?, ?
+     )
+     ON CONFLICT (logical_key) DO UPDATE SET
+       id              = EXCLUDED.id,
+       status          = EXCLUDED.status,
+       author          = EXCLUDED.author,
+       title           = EXCLUDED.title,
+       content         = EXCLUDED.content,
+       source_path     = EXCLUDED.source_path,
+       tags            = EXCLUDED.tags,
+       session_id      = EXCLUDED.session_id,
+       prompt_batch_id = EXCLUDED.prompt_batch_id,
+       content_hash    = EXCLUDED.content_hash,
+       processed       = EXCLUDED.processed,
+       updated_at      = EXCLUDED.updated_at,
+       embedded        = CASE
+         WHEN EXCLUDED.content_hash != plans.content_hash THEN 0
+         ELSE plans.embedded
+       END`
+  ).run(
+    data.id,
+    data.logical_key,
+    data.status ?? DEFAULT_STATUS,
+    data.author ?? null,
+    data.title ?? null,
+    data.content ?? null,
+    data.source_path ?? null,
+    data.tags ?? null,
+    data.session_id ?? null,
+    data.prompt_batch_id ?? null,
+    data.content_hash ?? null,
+    data.processed ?? DEFAULT_PROCESSED,
+    data.created_at,
+    data.updated_at ?? null,
+    data.machine_id ?? getTeamMachineId()
+  );
+  const row = toPlanRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS3} FROM plans WHERE logical_key = ?`).get(data.logical_key)
+  );
+  syncRow("plans", row);
+  return row;
+}
+function getPlan(id) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS3} FROM plans WHERE id = ?`
+  ).get(id);
+  if (!row) return null;
+  return toPlanRow(row);
+}
+function getPlanByLogicalKey(logicalKey) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS3} FROM plans WHERE logical_key = ?`
+  ).get(logicalKey);
+  if (!row) return null;
+  return toPlanRow(row);
+}
+function deletePlan(id) {
+  const db = getDatabase();
+  const row = getPlan(id);
+  if (!row) return null;
+  const info = db.prepare(`DELETE FROM plans WHERE id = ?`).run(id);
+  if (info.changes === 0) return null;
+  if (isTeamSyncEnabled()) {
+    enqueueOutbox({
+      table_name: "plans",
+      row_id: row.id,
+      operation: "delete",
+      payload: JSON.stringify({
+        id: row.id,
+        logical_key: row.logical_key,
+        title: row.title
+      }),
+      machine_id: getTeamMachineId(),
+      created_at: epochSeconds()
+    });
+  }
+  return row;
+}
+function listPlans(options = {}) {
+  const db = getDatabase();
+  const conditions = [];
+  const params = [];
+  if (options.status !== void 0) {
+    conditions.push(`status = ?`);
+    params.push(options.status);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = options.limit ?? DEFAULT_LIST_LIMIT;
+  params.push(limit);
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS3}
+     FROM plans
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT ?`
+  ).all(...params);
+  return rows.map(toPlanRow);
+}
+function listPlansBySession(sessionId) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS3}
+     FROM plans
+     WHERE session_id = ?
+     ORDER BY created_at DESC`
+  ).all(sessionId);
+  return rows.map(toPlanRow);
+}
+
+// src/db/queries/spores.ts
+var DEFAULT_LIST_LIMIT2 = 100;
+var DEFAULT_STATUS2 = "active";
+var DEFAULT_IMPORTANCE = 5;
+var SPORE_COLUMNS = [
+  "id",
+  "agent_id",
+  "session_id",
+  "prompt_batch_id",
+  "observation_type",
+  "status",
+  "content",
+  "context",
+  "importance",
+  "file_path",
+  "tags",
+  "content_hash",
+  "properties",
+  "embedded",
+  "created_at",
+  "updated_at",
+  "machine_id",
+  "synced_at"
+];
+var SELECT_COLUMNS4 = SPORE_COLUMNS.join(", ");
+function toSporeRow(row) {
+  return {
+    id: row.id,
+    agent_id: row.agent_id,
+    session_id: row.session_id ?? null,
+    prompt_batch_id: row.prompt_batch_id ?? null,
+    observation_type: row.observation_type,
+    status: row.status,
+    content: row.content,
+    context: row.context ?? null,
+    importance: row.importance,
+    file_path: row.file_path ?? null,
+    tags: row.tags ?? null,
+    content_hash: row.content_hash ?? null,
+    properties: row.properties ?? null,
+    embedded: row.embedded ?? 0,
+    created_at: row.created_at,
+    updated_at: row.updated_at ?? null,
+    machine_id: row.machine_id ?? "local",
+    synced_at: row.synced_at ?? null
+  };
+}
+function insertSpore(data) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO spores (
+       id, agent_id, session_id, prompt_batch_id,
+       observation_type, status, content, context,
+       importance, file_path, tags, content_hash,
+       properties, created_at, updated_at, machine_id
+     ) VALUES (
+       ?, ?, ?, ?,
+       ?, ?, ?, ?,
+       ?, ?, ?, ?,
+       ?, ?, ?, ?
+     )`
+  ).run(
+    data.id,
+    data.agent_id,
+    data.session_id ?? null,
+    data.prompt_batch_id ?? null,
+    data.observation_type,
+    data.status ?? DEFAULT_STATUS2,
+    data.content,
+    data.context ?? null,
+    data.importance ?? DEFAULT_IMPORTANCE,
+    data.file_path ?? null,
+    data.tags ?? null,
+    data.content_hash ?? null,
+    data.properties ?? null,
+    data.created_at,
+    data.updated_at ?? null,
+    data.machine_id ?? getTeamMachineId()
+  );
+  const row = toSporeRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS4} FROM spores WHERE id = ?`).get(data.id)
+  );
+  syncRow("spores", row);
+  return row;
+}
+function getSpore(id) {
+  const db = getDatabase();
+  const row = db.prepare(
+    `SELECT ${SELECT_COLUMNS4} FROM spores WHERE id = ?`
+  ).get(id);
+  if (!row) return null;
+  return toSporeRow(row);
+}
+function buildSporeWhere(options) {
+  const conditions = [];
+  const params = [];
+  if (options.agent_id !== void 0) {
+    conditions.push(`agent_id = ?`);
+    params.push(options.agent_id);
+  }
+  if (options.observation_type !== void 0) {
+    conditions.push(`observation_type = ?`);
+    params.push(options.observation_type);
+  }
+  if (options.status !== void 0) {
+    conditions.push(`status = ?`);
+    params.push(options.status);
+  }
+  if (options.session_id !== void 0) {
+    conditions.push(`session_id = ?`);
+    params.push(options.session_id);
+  }
+  if (options.search !== void 0 && options.search.length > 0) {
+    conditions.push(`(content LIKE ? OR observation_type LIKE ?)`);
+    const pattern = `%${options.search}%`;
+    params.push(pattern, pattern);
+  }
+  if (options.since !== void 0) {
+    conditions.push("created_at > ?");
+    params.push(options.since);
+  }
+  if (options.includeActive === false && options.session_id === void 0) {
+    conditions.push(
+      `(session_id IS NULL OR EXISTS (SELECT 1 FROM sessions s WHERE s.id = spores.session_id AND s.status != 'active'))`
+    );
+  }
+  return {
+    where: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+    params
+  };
+}
+function listSpores(options = {}) {
+  const db = getDatabase();
+  const { where, params } = buildSporeWhere(options);
+  const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
+  const offset = options.offset ?? 0;
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS4}
+     FROM spores
+     ${where}
+     ORDER BY created_at DESC
+     LIMIT ?
+     OFFSET ?`
+  ).all(...params, limit, offset);
+  return rows.map(toSporeRow);
+}
+function countSpores(options = {}) {
+  const db = getDatabase();
+  const { where, params } = buildSporeWhere(options);
+  const row = db.prepare(
+    `SELECT COUNT(*) as count FROM spores ${where}`
+  ).get(...params);
+  return row.count;
+}
+function listSporeIdsSince(sinceEpoch, limit = 20) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT id FROM spores WHERE created_at > ? AND status = 'active' ORDER BY created_at DESC LIMIT ?`
+  ).all(sinceEpoch, limit);
+  return rows.map((r) => r.id);
+}
+function updateSporeStatus(id, status, updatedAt) {
+  const db = getDatabase();
+  const info = db.prepare(
+    `UPDATE spores
+     SET status = ?, updated_at = ?
+     WHERE id = ?`
+  ).run(status, updatedAt, id);
+  if (info.changes === 0) return null;
+  const row = toSporeRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS4} FROM spores WHERE id = ?`).get(id)
+  );
+  syncRow("spores", row);
+  return row;
+}
+
+// src/context/cortex-brief.ts
+import { createHash } from "crypto";
+var MAX_COLLECTIVE_CAPABILITY_LABELS = 4;
+var ALL_CORTEX_TOOL_DEFINITIONS = [...TOOL_DEFINITIONS, ...COLLECTIVE_TOOL_DEFINITIONS];
+var RECENT_SESSION_LIMIT = 5;
+var RECENT_WISDOM_SPORE_LIMIT = 3;
+var RECENT_DECISION_SPORE_LIMIT = 3;
+var RECENT_DISCOVERY_SPORE_LIMIT = 3;
+var RECENT_PLAN_LIMIT = 3;
+var CONTENT_PREVIEW_MAX_CHARS = 360;
+var DIGEST_EXCERPT_MAX_CHARS = 1800;
+var JSON_INDENT = 2;
+var CORTEX_SKILLS_NOTE = "Project and Myco skills are already registered with the agent separately. Tell the agent to use those skills directly when relevant, and do not instruct it to call `myco_skills`.";
+function toCortexToolGuidance(tool) {
+  const cortex = tool.cortex;
+  if (!cortex) return null;
+  return {
+    tool: tool.name,
+    guidance: cortex.guidance,
+    requiresTeam: cortex.requiresTeam,
+    requiresCollective: cortex.requiresCollective,
+    priority: getToolCortexPriority(tool)
+  };
+}
+var RETRIEVAL_GUIDANCE = ALL_CORTEX_TOOL_DEFINITIONS.map(toCortexToolGuidance).filter((entry) => entry !== null).sort((left, right) => left.priority - right.priority);
+async function resolveCortexCapabilities(config, getTeamClient) {
+  const teamClient = getTeamClient?.() ?? null;
+  const teamEnabled = Boolean(config.team.enabled && teamClient);
+  let collectiveConnected = false;
+  let collectiveCapabilities = [];
+  if (teamEnabled && teamClient) {
+    try {
+      const status = await teamClient.getCollectiveStatus();
+      collectiveConnected = Boolean(status?.connected);
+      collectiveCapabilities = status?.capabilities ?? [];
+    } catch {
+      collectiveConnected = false;
+      collectiveCapabilities = [];
+    }
+  }
+  return {
+    teamEnabled,
+    collectiveConnected,
+    collectiveCapabilities
+  };
+}
+function shouldInjectCortex(config) {
+  return config.cortex_enabled;
+}
+function resolveInstructionDelivery(config, symbiont) {
+  if (!symbiont) {
+    return { inlineInstructions: true, reason: "missing-symbiont" };
+  }
+  if (!config.cortex_enabled) {
+    return { inlineInstructions: true, reason: "session-start-disabled" };
+  }
+  if (symbiont.supportsSessionStartInjection) {
+    return { inlineInstructions: false, reason: "session-start-supported" };
+  }
+  return { inlineInstructions: true, reason: "no-session-start" };
+}
+function buildCapabilitySummary(capabilities) {
+  const summary = [
+    capabilities.collectiveConnected ? "Myco can retrieve local, team, and collective knowledge in this project." : capabilities.teamEnabled ? "Myco can retrieve local and shared team knowledge in this project." : "Myco can retrieve local project knowledge in this project.",
+    "Use only the currently available Myco MCP tools described below, and omit any surfaces that are offline."
+  ];
+  if (capabilities.collectiveConnected && capabilities.collectiveCapabilities.length > 0) {
+    const labels = capabilities.collectiveCapabilities.slice(0, MAX_COLLECTIVE_CAPABILITY_LABELS);
+    const remaining = Math.max(
+      0,
+      capabilities.collectiveCapabilities.length - MAX_COLLECTIVE_CAPABILITY_LABELS
+    );
+    const suffix = remaining > 0 ? ` (+${remaining} more)` : "";
+    summary.push(`Collective capabilities online: ${labels.join(", ")}${suffix}.`);
+  }
+  return summary;
+}
+function buildRetrievalGuidanceLines(capabilities) {
+  const lines = [];
+  for (const entry of RETRIEVAL_GUIDANCE) {
+    if (entry.requiresTeam && !capabilities.teamEnabled) continue;
+    if (entry.requiresCollective && !capabilities.collectiveConnected) continue;
+    lines.push(`- \`${entry.tool}\`: ${entry.guidance}`);
+  }
+  return lines;
+}
+function hashInput(value) {
+  return createHash(CONTENT_HASH_ALGORITHM).update(JSON.stringify(value)).digest("hex");
+}
+function truncatePreview(text, maxChars = CONTENT_PREVIEW_MAX_CHARS) {
+  if (!text) return null;
+  return text.length > maxChars ? `${text.slice(0, maxChars)}...` : text;
+}
+function formatRecentSessions() {
+  const sessions = listSessions({
+    includeActive: false,
+    limit: RECENT_SESSION_LIMIT
+  });
+  if (sessions.length === 0) return "No recent sessions are available.";
+  return sessions.map((session) => {
+    const head = `- ${session.title ?? session.id}${session.branch ? ` (branch=${session.branch})` : ""}`;
+    const body = truncatePreview(session.summary);
+    return body ? `${head}
+  ${body}` : head;
+  }).join("\n");
+}
+function formatSporesOfType(observationType, limit) {
+  const spores = listSpores({
+    observation_type: observationType,
+    includeActive: false,
+    status: "active",
+    limit
+  });
+  if (spores.length === 0) return `No recent ${observationType} spores are available.`;
+  return spores.map((spore) => {
+    const parts = [
+      `- ${truncatePreview(spore.content)}`,
+      spore.session_id ? `session=${spore.session_id}` : null
+    ].filter(Boolean);
+    return parts.join(" \u2014 ");
+  }).join("\n");
+}
+function formatRecentPlans() {
+  const plans = listPlans({
+    status: "active",
+    limit: RECENT_PLAN_LIMIT
+  });
+  if (plans.length === 0) return "No active plans are available.";
+  return plans.map((plan) => {
+    const parts = [
+      `- ${plan.title ?? plan.id}`,
+      `status=${plan.status}`,
+      truncatePreview(plan.content)
+    ].filter(Boolean);
+    return parts.join(" \u2014 ");
+  }).join("\n");
+}
+function formatDigestExcerpt(config) {
+  const preferredTier = config.context.digest_tier;
+  const extract = getDigestExtract(DEFAULT_AGENT_ID, preferredTier) ?? getDigestExtract(DEFAULT_AGENT_ID, DIGEST_FALLBACK_TIER);
+  if (!extract) return "No current digest extract is available.";
+  const excerpt = truncatePreview(extract.content, DIGEST_EXCERPT_MAX_CHARS) ?? "";
+  return excerpt ? `Tier ${extract.tier} digest excerpt:
+${excerpt}` : `Tier ${extract.tier} digest extract is empty.`;
+}
+async function buildCortexInstructionsInput(config, getTeamClient) {
+  const capabilities = await resolveCortexCapabilities(config, getTeamClient);
+  const capabilitySummary = buildCapabilitySummary(capabilities);
+  const retrievalGuidance = buildRetrievalGuidanceLines(capabilities);
+  const recentSessions = formatRecentSessions();
+  const recentWisdomSpores = formatSporesOfType("wisdom", RECENT_WISDOM_SPORE_LIMIT);
+  const recentDecisionSpores = formatSporesOfType("decision", RECENT_DECISION_SPORE_LIMIT);
+  const recentDiscoverySpores = formatSporesOfType("discovery", RECENT_DISCOVERY_SPORE_LIMIT);
+  const recentPlans = formatRecentPlans();
+  const digestExcerpt = formatDigestExcerpt(config);
+  const input = {
+    context: {
+      digest_tier: config.context.digest_tier,
+      cortex_enabled: config.context.cortex_enabled,
+      prompt_search: config.context.prompt_search,
+      prompt_max_spores: config.context.prompt_max_spores
+    },
+    capabilities,
+    digestExcerpt,
+    recentSessions,
+    recentWisdomSpores,
+    recentDecisionSpores,
+    recentDiscoverySpores,
+    recentPlans,
+    skillsNote: CORTEX_SKILLS_NOTE
+  };
+  return {
+    inputHash: hashInput(input),
+    instruction: [
+      "Author compact session-start instructions for another coding agent.",
+      "Focus on teaching how to use the highest-signal Myco tools correctly, especially retrieval and plan persistence.",
+      "Do not restate AGENTS.md or static installation details.",
+      "",
+      "## Runtime config",
+      JSON.stringify(input.context, null, JSON_INDENT),
+      "",
+      "## Authoring requirements",
+      "- Start with the heading `## Myco-Enabled Project`.",
+      "- Follow the heading with one brief sentence explaining that Myco provides project memory, prior decisions, plans, and retrieval tools for this repository.",
+      "- Teach the most useful current Myco MCP tool behavior, especially retrieval and plan persistence.",
+      "- Use the recent vault activity below to mention live project hotspots when that improves usefulness.",
+      `- ${CORTEX_SKILLS_NOTE}`,
+      "- Keep the heading and description brief so most of the budget goes to retrieval guidance.",
+      "- Keep the output compact and ready for direct injection.",
+      "",
+      "## Capability summary",
+      ...capabilitySummary,
+      "",
+      "## Tool guidance to encode",
+      ...retrievalGuidance,
+      "",
+      "## Current digest excerpt",
+      digestExcerpt,
+      "",
+      "## Recent sessions",
+      recentSessions,
+      "",
+      "## Recent wisdom spores",
+      recentWisdomSpores,
+      "",
+      "## Recent decision spores",
+      recentDecisionSpores,
+      "",
+      "## Recent discovery spores",
+      recentDiscoverySpores,
+      "",
+      "## Active plans",
+      recentPlans
+    ].join("\n")
+  };
+}
+async function buildScheduledCortexInstruction(config, getTeamClient) {
+  const built = await buildCortexInstructionsInput(config, getTeamClient);
+  const existing = getCortexInstructions(DEFAULT_AGENT_ID);
+  if (existing?.input_hash === built.inputHash) {
+    return void 0;
+  }
+  return built;
+}
+
+export {
+  upsertCortexInstructions,
+  getCortexInstructions,
+  upsertDigestExtract,
+  getDigestExtract,
+  listDigestExtracts,
+  listDigestRevisions,
+  rollbackDigestExtract,
+  upsertPlan,
+  getPlan,
+  getPlanByLogicalKey,
+  deletePlan,
+  listPlans,
+  listPlansBySession,
+  DEFAULT_IMPORTANCE,
+  insertSpore,
+  getSpore,
+  listSpores,
+  countSpores,
+  listSporeIdsSince,
+  updateSporeStatus,
+  shouldInjectCortex,
+  resolveInstructionDelivery,
+  buildCortexInstructionsInput,
+  buildScheduledCortexInstruction
+};
+//# sourceMappingURL=chunk-N7Z3LUEZ.js.map