@goondocks/myco 0.5.1 → 0.6.1

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
       "source": {
         "source": "npm",
         "package": "@goondocks/myco",
-        "version": "0.5.0"
+        "version": "0.6.0"
       },
       "description": "Collective agent intelligence — captures session knowledge and serves it back via MCP",
       "license": "MIT",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "myco",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Collective agent intelligence — captures session knowledge and serves it back to your team via MCP",
   "author": {
     "name": "goondocks-co",

package/README.md

@@ -32,15 +32,9 @@ The agent sets up your vault, configures intelligence, and starts capturing. Wor
 
 Myco captures everything your AI agents do — sessions, decisions, plans, discoveries — and connects them into a searchable intelligence graph stored as an [Obsidian](https://obsidian.md) vault. Named after [mycorrhizal networks](https://en.wikipedia.org/wiki/Mycorrhizal_network), the underground fungal systems that connect trees in a forest, Myco is the invisible network linking your agents and team members, sharing intelligence beneath the surface.
 
-**For agents** — MCP tools let any agent runtime search, recall, and build on your team's accumulated knowledge.
-```
-myco_search("how did we handle auth?")  → semantically matched sessions, decisions, and linked context
-myco_recall("migration plan")           → full decision history with session lineage
-myco_remember(observation)              → persist a discovery for the team
-myco_context(tier: 3000)                → pre-computed project understanding, instantly available
-```
+**For agents** — [12 MCP tools and 3 skills](docs/agent-tools.md) let any agent search, recall, and build on accumulated knowledge. A digest extract is injected at session start, and relevant spores are injected after each user prompt — agents get context automatically without being told to search.
 
-**For humans** — open the vault in Obsidian and browse the intelligence graph visually. Sessions link to plans, plans link to decisions, decisions link to spores. It's all Markdown with backlinks — your team's connected knowledge, navigable and searchable.
+**For humans** — open the vault in [Obsidian](https://obsidian.md) to browse the intelligence graph visually, or use the local web dashboard to manage configuration, run operations, and monitor system health. Everything is Markdown with backlinks — your team's connected knowledge, navigable and searchable.
 
 **For teams** — the vault is a Git-friendly directory of Markdown files. Share it through your existing Git workflow.
 
@@ -52,11 +46,11 @@ A background daemon reads your agent's conversation transcript after each turn
 
 ### Curate
 
-As a project evolves, older observations become stale. Myco automatically detects and supersedes outdated spores when new ones are created — using vector similarity to find candidates and an LLM to judge which are truly replaced vs. merely related. Superseded spores are preserved with lineage metadata (never deleted), but filtered from search results and digest synthesis. Run `myco curate` for vault-wide cleanup, or let it happen automatically on every spore write.
+As a project evolves, older observations become stale. Myco automatically detects and supersedes outdated spores when new ones are created — using vector similarity to find candidates and an LLM to judge which are truly replaced vs. merely related. Related spores are automatically consolidated into comprehensive wisdom notes during each digest cycle, compressing scattered observations into denser, higher-quality knowledge. Superseded spores are preserved with lineage metadata (never deleted), but filtered from search results and digest synthesis. Run vault-wide curation from the dashboard, or let it happen automatically.
 
 ### Digest
 
-A **continuous reasoning engine** runs inside the daemon, periodically synthesizing all accumulated knowledge into tiered context extracts. These pre-computed summaries give agents an instant, rich understanding of the project at session start — no searching required. Four tiers serve different needs: executive briefing (1.5K tokens), team standup (3K), deep onboarding (5K), and institutional knowledge (10K). Run `myco digest --tier 3000` to reprocess a specific tier from scratch, or `myco digest --full` for a complete rebuild.
+A **continuous reasoning engine** runs inside the daemon, periodically synthesizing all accumulated knowledge into tiered context extracts. Before each digest cycle, an optional consolidation pre-pass compresses related spores into wisdom notes, ensuring the digest operates on clean, dense substrate. The pre-computed extracts give agents an instant, rich understanding of the project at session start — no searching required. Four tiers serve different needs: executive briefing (1.5K tokens), team standup (3K), deep onboarding (5K), and institutional knowledge (10K). Trigger digest cycles and manage tiers from the dashboard.
 
 ### Index
 
@@ -64,12 +58,21 @@ Every note is indexed for both keyword search (SQLite FTS5) and semantic search
 
 ### Serve
 
-An MCP server exposes the vault to any agent runtime. The digest extract is injected at session start for immediate context, and relevant spores are injected per-prompt for targeted intelligence. Agents build on your team's accumulated knowledge without being told to.
+An MCP server exposes 12 tools to any agent runtime. Two automatic injection points ensure agents always have relevant context:
+
+- **Session start** — the digest extract is injected via the `SessionStart` hook, giving the agent a pre-computed understanding of the project before it asks a single question.
+- **Per-prompt** — after each user prompt, relevant spores are retrieved via vector search and injected via the `UserPromptSubmit` hook, providing targeted intelligence for the task at hand.
+
+Agents build on your team's accumulated knowledge without being told to. See the [Lifecycle docs](docs/lifecycle.md) for the full event flow.
 
 ### Connect
 
 Sessions link to plans. Plans link to decisions. Decisions link to spores. Obsidian backlinks and metadata create a navigable graph of your team's institutional knowledge. Open the vault in [Obsidian](https://obsidian.md) to browse it visually, or let agents traverse it via MCP tools.
 
+### Dashboard
+
+A local web dashboard at `http://localhost:<port>/` provides configuration management and operational triggers — no CLI or YAML editing needed. Manage intelligence providers, run curation and digest cycles, monitor daemon health, and view live logs. The daemon writes a `_portal.md` to your vault with the URL, so you can find it from Obsidian.
+
 ### Multi-agent
 
 Myco reads conversation transcripts from Claude Code, Cursor, and any agent that writes JSONL transcripts. Screenshots shared during sessions are extracted and embedded as Obsidian image attachments. A plugin adapter registry makes adding new agents straightforward.

package/dist/{chunk-JJL6AMDA.js → chunk-24DOZEUJ.js}

@@ -1,7 +1,10 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
 import {
-  parseNoteFrontmatter
-} from "./chunk-2AMAOSRF.js";
+  external_exports
+} from "./chunk-MQSYSQ6T.js";
+import {
+  CANDIDATE_CONTENT_PREVIEW
+} from "./chunk-6BSDCZ5Q.js";
 import {
   __commonJS,
   __require,
@@ -3380,7 +3383,7 @@ var require_parse = __commonJS({
 var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
-    var fs2 = __require("fs");
+    var fs3 = __require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults();
     var stringify = require_stringify();
@@ -3464,7 +3467,7 @@ var require_gray_matter = __commonJS({
       return stringify(file, data, options2);
     };
     matter2.read = function(filepath, options2) {
-      const str2 = fs2.readFileSync(filepath, "utf8");
+      const str2 = fs3.readFileSync(filepath, "utf8");
       const file = matter2(str2, options2);
       file.path = filepath;
       return file;
@@ -3496,6 +3499,101 @@ var require_gray_matter = __commonJS({
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 import fs from "fs";
 import path from "path";
+
+// src/vault/types.ts
+var SessionFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("session"),
+  id: external_exports.string(),
+  agent: external_exports.string(),
+  user: external_exports.string(),
+  started: external_exports.string(),
+  ended: external_exports.string().optional(),
+  parent: external_exports.string().optional(),
+  parent_reason: external_exports.string().optional(),
+  plan: external_exports.string().optional(),
+  // backward compat read path
+  plans: external_exports.array(external_exports.string()).optional(),
+  // new: multiple plans
+  branch: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([]),
+  tools_used: external_exports.number().int().optional(),
+  files_changed: external_exports.number().int().optional()
+});
+var PLAN_STATUSES = ["active", "in_progress", "completed", "abandoned"];
+var PlanFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("plan"),
+  id: external_exports.string(),
+  status: external_exports.enum(PLAN_STATUSES).default("active"),
+  created: external_exports.string(),
+  author: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var OBSERVATION_TYPES = ["gotcha", "bug_fix", "decision", "discovery", "trade_off", "cross-cutting"];
+var SPORE_STATUSES = ["active", "superseded", "archived"];
+var SporeFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("spore"),
+  id: external_exports.string(),
+  observation_type: external_exports.string(),
+  status: external_exports.enum(SPORE_STATUSES).default("active"),
+  session: external_exports.string().optional(),
+  plan: external_exports.string().optional(),
+  superseded_by: external_exports.string().optional(),
+  consolidated_from: external_exports.array(external_exports.string()).optional(),
+  created: external_exports.string(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var ARTIFACT_TYPES = ["spec", "plan", "rfc", "doc", "other"];
+var ArtifactFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("artifact"),
+  id: external_exports.string(),
+  artifact_type: external_exports.enum(ARTIFACT_TYPES).default("other"),
+  source_path: external_exports.string(),
+  title: external_exports.string(),
+  last_captured_by: external_exports.string(),
+  created: external_exports.string(),
+  updated: external_exports.string(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var TeamMemberFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("team-member"),
+  user: external_exports.string(),
+  joined: external_exports.string(),
+  role: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var schemasByType = {
+  session: SessionFrontmatterSchema,
+  plan: PlanFrontmatterSchema,
+  spore: SporeFrontmatterSchema,
+  artifact: ArtifactFrontmatterSchema,
+  "team-member": TeamMemberFrontmatterSchema
+};
+function parseNoteFrontmatter(data) {
+  const type = data.type;
+  const schema = schemasByType[type];
+  if (!schema) {
+    throw new Error(`Unknown note type: ${type}. Known types: ${Object.keys(schemasByType).join(", ")}`);
+  }
+  const coerced = coerceDatesToStrings(data);
+  return schema.parse(coerced);
+}
+function coerceDatesToStrings(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Date) {
+      result[key] = value.toISOString();
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => item instanceof Date ? item.toISOString() : item);
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = coerceDatesToStrings(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/vault/reader.ts
 var VAULT_SUBDIRS = ["sessions", "plans", "spores", "artifacts", "team"];
 var VaultReader = class {
   constructor(vaultDir) {
@@ -3573,10 +3671,161 @@ function extractTitle(content) {
   return match ? match[1].trim() : "";
 }
 
+// src/intelligence/response.ts
+var REASONING_PATTERNS = [
+  // <think>...</think>answer  (DeepSeek, Qwen, GLM, many others)
+  /<think>[\s\S]*?<\/think>\s*/gi,
+  // Implicit opening: reasoning...</think>answer  (GLM-4.7 observed)
+  /^[\s\S]*?<\/think>\s*/i,
+  // <reasoning>...</reasoning>answer
+  /<reasoning>[\s\S]*?<\/reasoning>\s*/gi,
+  // <|thinking|>...<|/thinking|>answer
+  /<\|thinking\|>[\s\S]*?<\|\/thinking\|>\s*/gi,
+  // Plain-text "Thinking Process:" block followed by actual content
+  // (Qwen 3.5 via LM Studio without native thinking mode)
+  // Matches from "Thinking Process:" up to the last numbered step, then the synthesis follows
+  /^Thinking Process:[\s\S]*?(?=\n(?:## |# |\*\*[A-Z]))/i
+];
+function stripReasoningTokens(text) {
+  if (!text) return text;
+  for (const pattern of REASONING_PATTERNS) {
+    const stripped = text.replace(pattern, "").trim();
+    if (stripped && stripped !== text.trim()) {
+      return stripped;
+    }
+  }
+  return text;
+}
+function extractJson(text) {
+  const cleaned = stripReasoningTokens(text);
+  const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  if (fenceMatch) {
+    return JSON.parse(fenceMatch[1].trim());
+  }
+  const objectMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objectMatch) {
+    return JSON.parse(objectMatch[0]);
+  }
+  return JSON.parse(cleaned);
+}
+function extractNumber(text) {
+  const cleaned = stripReasoningTokens(text).trim();
+  const match = cleaned.match(/(\d+\.?\d*)/);
+  if (match) return parseFloat(match[1]);
+  return parseFloat(cleaned);
+}
+
+// src/prompts/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function resolvePromptsDir() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 5; i++) {
+    if (fs2.existsSync(path2.join(dir, "package.json"))) {
+      return path2.join(dir, "dist", "src", "prompts");
+    }
+    if (fs2.existsSync(path2.join(dir, "extraction.md"))) {
+      return dir;
+    }
+    dir = path2.dirname(dir);
+  }
+  return path2.dirname(fileURLToPath(import.meta.url));
+}
+var PROMPTS_DIR = resolvePromptsDir();
+var promptCache = /* @__PURE__ */ new Map();
+function loadPrompt(name) {
+  let cached = promptCache.get(name);
+  if (!cached) {
+    cached = fs2.readFileSync(path2.join(PROMPTS_DIR, `${name}.md`), "utf-8").trim();
+    promptCache.set(name, cached);
+  }
+  return cached;
+}
+function interpolate(template, vars) {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function formatNoteForPrompt(note) {
+  return `[${note.id}] ${note.title}
+${note.content}`;
+}
+function formatNotesForPrompt(notes) {
+  return notes.map(formatNoteForPrompt).join("\n\n");
+}
+function buildExtractionPrompt(sessionId, eventCount, toolSummary, maxTokens) {
+  return interpolate(loadPrompt("extraction"), {
+    sessionId,
+    eventCount: String(eventCount),
+    toolSummary,
+    maxTokens: String(maxTokens ?? 2048)
+  });
+}
+function buildSummaryPrompt(sessionId, user, content, maxTokens) {
+  return interpolate(loadPrompt("summary"), {
+    sessionId,
+    user,
+    content,
+    maxTokens: String(maxTokens ?? 1024)
+  });
+}
+function buildTitlePrompt(summary, sessionId) {
+  return interpolate(loadPrompt("title"), {
+    summary,
+    sessionId
+  });
+}
+var ARTIFACT_TYPE_DESCRIPTIONS = [
+  '"spec" \u2014 Design specifications, architecture documents',
+  '"plan" \u2014 Implementation plans, roadmaps',
+  '"rfc" \u2014 Requests for comment, proposals',
+  '"doc" \u2014 Documentation, guides, READMEs',
+  '"other" \u2014 Other substantive documents'
+];
+function buildSimilarityPrompt(currentSummary, candidateSummary) {
+  return interpolate(loadPrompt("session-similarity"), {
+    currentSummary,
+    candidateSummary
+  });
+}
+function buildClassificationPrompt(sessionId, candidates, maxTokens) {
+  const fileList = candidates.map((c) => {
+    const truncated = c.content.slice(0, CANDIDATE_CONTENT_PREVIEW);
+    return `### ${c.path}
+\`\`\`
+${truncated}
+\`\`\``;
+  }).join("\n\n");
+  return interpolate(loadPrompt("classification"), {
+    sessionId,
+    fileList,
+    artifactTypes: ARTIFACT_TYPE_DESCRIPTIONS.map((d) => `- ${d}`).join("\n"),
+    validTypes: ARTIFACT_TYPES.join("|"),
+    maxTokens: String(maxTokens ?? 1024)
+  });
+}
+
 export {
   require_gray_matter,
+  PLAN_STATUSES,
+  OBSERVATION_TYPES,
+  ARTIFACT_TYPES,
   indexNote,
-  rebuildIndex
+  rebuildIndex,
+  stripReasoningTokens,
+  extractJson,
+  extractNumber,
+  loadPrompt,
+  formatNoteForPrompt,
+  formatNotesForPrompt,
+  buildExtractionPrompt,
+  buildSummaryPrompt,
+  buildTitlePrompt,
+  buildSimilarityPrompt,
+  buildClassificationPrompt
 };
 /*! Bundled license information:
 
@@ -3596,4 +3845,4 @@ strip-bom-string/index.js:
    * Released under the MIT License.
    *)
 */
-//# sourceMappingURL=chunk-JJL6AMDA.js.map
+//# sourceMappingURL=chunk-24DOZEUJ.js.map