monomind 2.0.3 → 2.1.3

package/packages/@monomind/cli/dist/src/mcp-tools/coherence/types.d.ts

@@ -69,8 +69,8 @@ export declare const CoherenceInputSchema: z.ZodObject<{
     vectors: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
     threshold: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    threshold: number;
     vectors: number[][];
+    threshold: number;
 }, {
     vectors: number[][];
     threshold?: number | undefined;
@@ -98,10 +98,10 @@ export declare const SpectralInputSchema: z.ZodObject<{
     analyzeType: z.ZodDefault<z.ZodEnum<["stability", "clustering", "connectivity"]>>;
 }, "strip", z.ZodTypeAny, {
     matrix: number[][];
-    analyzeType: "stability" | "clustering" | "connectivity";
+    analyzeType: "clustering" | "connectivity" | "stability";
 }, {
     matrix: number[][];
-    analyzeType?: "stability" | "clustering" | "connectivity" | undefined;
+    analyzeType?: "clustering" | "connectivity" | "stability" | undefined;
 }>;
 export type SpectralInput = z.infer<typeof SpectralInputSchema>;
 export interface SpectralResult {
@@ -150,15 +150,15 @@ export declare const CausalInputSchema: z.ZodObject<{
         nodes: string[];
         edges: [string, string][];
     };
-    outcome: string;
     intervention: string;
+    outcome: string;
 }, {
     graph: {
         nodes: string[];
         edges: [string, string][];
     };
-    outcome: string;
     intervention: string;
+    outcome: string;
 }>;
 export type CausalInput = z.infer<typeof CausalInputSchema>;
 export interface CausalResult {
@@ -185,13 +185,13 @@ export declare const AgentStateSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     agentId: string;
     embedding: number[];
-    metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
 }, {
     agentId: string;
     embedding: number[];
-    metadata?: Record<string, unknown> | undefined;
     vote?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
 }>;
 export type AgentState = z.infer<typeof AgentStateSchema>;
 export declare const ConsensusInputSchema: z.ZodObject<{
@@ -203,29 +203,29 @@ export declare const ConsensusInputSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }, {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }>, "many">;
     threshold: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    threshold: number;
     agentStates: {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }[];
+    threshold: number;
 }, {
     agentStates: {
         agentId: string;
         embedding: number[];
-        metadata?: Record<string, unknown> | undefined;
         vote?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
     }[];
     threshold?: number | undefined;
 }>;
@@ -247,11 +247,11 @@ export declare const SimplexSchema: z.ZodObject<{
     vertices: z.ZodArray<z.ZodNumber, "many">;
     dimension: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    dimension: number;
     vertices: number[];
-}, {
     dimension: number;
+}, {
     vertices: number[];
+    dimension: number;
 }>;
 export type Simplex = z.infer<typeof SimplexSchema>;
 export declare const SimplicialComplexSchema: z.ZodObject<{
@@ -260,25 +260,25 @@ export declare const SimplicialComplexSchema: z.ZodObject<{
         vertices: z.ZodArray<z.ZodNumber, "many">;
         dimension: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
-        dimension: number;
         vertices: number[];
-    }, {
         dimension: number;
+    }, {
         vertices: number[];
+        dimension: number;
     }>, "many">>;
     maxDimension: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     vertices: number[][];
-    maxDimension: number;
     simplices?: {
-        dimension: number;
         vertices: number[];
+        dimension: number;
     }[] | undefined;
+    maxDimension: number;
 }, {
     vertices: number[][];
     simplices?: {
-        dimension: number;
         vertices: number[];
+        dimension: number;
     }[] | undefined;
     maxDimension?: number | undefined;
 }>;
@@ -290,43 +290,43 @@ export declare const TopologyInputSchema: z.ZodObject<{
             vertices: z.ZodArray<z.ZodNumber, "many">;
             dimension: z.ZodNumber;
         }, "strip", z.ZodTypeAny, {
-            dimension: number;
             vertices: number[];
-        }, {
             dimension: number;
+        }, {
             vertices: number[];
+            dimension: number;
         }>, "many">>;
         maxDimension: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
         vertices: number[][];
-        maxDimension: number;
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
+        maxDimension: number;
     }, {
         vertices: number[][];
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
         maxDimension?: number | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     complex: {
         vertices: number[][];
-        maxDimension: number;
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
+        maxDimension: number;
     };
 }, {
     complex: {
         vertices: number[][];
         simplices?: {
-            dimension: number;
             vertices: number[];
+            dimension: number;
         }[] | undefined;
         maxDimension?: number | undefined;
     };
@@ -362,27 +362,27 @@ export declare const MemoryGateInputSchema: z.ZodObject<{
         reject: z.ZodDefault<z.ZodNumber>;
         warn: z.ZodDefault<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        warn: number;
         reject: number;
+        warn: number;
     }, {
-        warn?: number | undefined;
         reject?: number | undefined;
+        warn?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     key: string;
     value?: unknown;
     existingVectors?: number[][] | undefined;
     thresholds?: {
-        warn: number;
         reject: number;
+        warn: number;
     } | undefined;
 }, {
     key: string;
     value?: unknown;
     existingVectors?: number[][] | undefined;
     thresholds?: {
-        warn?: number | undefined;
         reject?: number | undefined;
+        warn?: number | undefined;
     } | undefined;
 }>;
 export type MemoryGateInput = z.infer<typeof MemoryGateInputSchema>;

package/packages/@monomind/cli/dist/src/mcp-tools/github-tools.js

@@ -60,6 +60,18 @@ function runSafe(cmd, args, cwd) {
         return null;
     }
 }
+/** Run a `gh` command and preserve the real failure reason instead of collapsing to null. */
+function runSafeResult(cmd, args, cwd) {
+    try {
+        const stdout = execFileSync(cmd, args, { encoding: 'utf-8', timeout: 15000, cwd: cwd || getProjectCwd(), stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        return { ok: true, stdout };
+    }
+    catch (err) {
+        const e = err;
+        const stderr = e.stderr ? String(e.stderr).trim() : '';
+        return { ok: false, error: stderr || e.message || 'gh command failed' };
+    }
+}
 /** Check if gh CLI is available */
 function hasGhCli() {
     return run('gh --version') !== null;
@@ -216,7 +228,11 @@ export const githubTools = [
                 }
                 // Fallback: local store
                 const prId = `pr-${Date.now()}`;
-                const pr = { id: prId, title, status: 'open', branch: headBranch, baseBranch, createdAt: new Date().toISOString() };
+                // Locally-assigned PR number, independent of the timestamp-based key —
+                // monotonic within this store so lookups by number are unambiguous.
+                const existingNumbers = Object.values(store.prs).map(p => p.number || 0);
+                const nextNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) + 1 : 1;
+                const pr = { id: prId, number: nextNumber, title, status: 'open', branch: headBranch, baseBranch, createdAt: new Date().toISOString() };
                 store.prs[prId] = pr;
                 saveGitHubStore(store);
                 return { success: true, source: 'local-store', action: 'created', pullRequest: pr };
@@ -241,13 +257,17 @@ export const githubTools = [
                 if (!prNumber)
                     return { success: false, error: 'prNumber is required and must be a positive integer for merge.' };
                 if (gh) {
-                    const result = runSafe('gh', ['pr', 'merge', String(prNumber), '--merge']);
-                    if (result !== null) {
+                    // gh CLI is actually installed — trust its real exit status. A genuine
+                    // failure (branch protection, conflicts, auth) must be reported as a
+                    // failure, not silently swallowed into the local-store simulation.
+                    const result = runSafeResult('gh', ['pr', 'merge', String(prNumber), '--merge']);
+                    if (result.ok) {
                         return { success: true, _real: true, action: 'merged', prNumber, mergedAt: new Date().toISOString() };
                     }
+                    return { success: false, error: result.error };
                 }
-                // Fallback: local store
-                const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
+                // Fallback: local store (only reached when gh CLI is not installed at all)
+                const prKey = Object.keys(store.prs).find(k => store.prs[k].number === prNumber);
                 if (prKey && store.prs[prKey]) {
                     store.prs[prKey].status = 'merged';
                     saveGitHubStore(store);
@@ -259,12 +279,14 @@ export const githubTools = [
                 if (!prNumber)
                     return { success: false, error: 'prNumber is required and must be a positive integer for close.' };
                 if (gh) {
-                    const result = runSafe('gh', ['pr', 'close', String(prNumber)]);
-                    if (result !== null) {
+                    const result = runSafeResult('gh', ['pr', 'close', String(prNumber)]);
+                    if (result.ok) {
                         return { success: true, _real: true, action: 'closed', prNumber, closedAt: new Date().toISOString() };
                     }
+                    return { success: false, error: result.error };
                 }
-                const prKey = Object.keys(store.prs).find(k => k.includes(String(prNumber)));
+                // Fallback: local store (only reached when gh CLI is not installed at all)
+                const prKey = Object.keys(store.prs).find(k => store.prs[k].number === prNumber);
                 if (prKey && store.prs[prKey]) {
                     store.prs[prKey].status = 'closed';
                     saveGitHubStore(store);

package/packages/@monomind/cli/dist/src/mcp-tools/graphify-tools.js

@@ -4,7 +4,14 @@
  * All graphify_* tools are deprecated. They proxy to monograph_* tools.
  * Will be removed in next major release.
  */
-import { allMonographTools } from './monograph-tools.js';
+import { allMonographTools, monographTools } from './monograph-tools.js';
+// Advanced monograph tools are gated behind MONOGRAPH_MCP_ADVANCED=1 (see
+// monograph-tools.ts). Shims that target an advanced-tier tool must be gated
+// the same way, otherwise they re-expose advanced tools under a different
+// name regardless of the flag. `monographTools` is the already-gated export
+// (core-only unless MONOGRAPH_MCP_ADVANCED=1); a target is "advanced" if it's
+// present in allMonographTools but absent from monographTools.
+const exposedMonographNames = new Set(monographTools.map(t => t.name));
 function findMonographTool(name) {
     const tool = allMonographTools.find(t => t.name === name);
     if (!tool)
@@ -12,6 +19,8 @@ function findMonographTool(name) {
     return tool;
 }
 function shimTool(graphifyName, monographName, paramMap) {
+    if (!exposedMonographNames.has(monographName))
+        return null;
     const target = findMonographTool(monographName);
     return {
         name: graphifyName,
@@ -44,6 +53,6 @@ export const graphifyTools = [
     shimTool('graphify_report', 'monograph_report'),
     // Bug fix: graphify_health previously referenced `files.length` (ReferenceError) — now delegates cleanly
     shimTool('graphify_health', 'monograph_health'),
-];
+].filter((t) => t !== null);
 export default graphifyTools;
 //# sourceMappingURL=graphify-tools.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/hive-mind-tools.js

@@ -13,8 +13,12 @@
 import { existsSync, readFileSync, statSync, writeFileSync, renameSync, mkdirSync } from 'node:fs';
 import { randomBytes } from 'node:crypto';
 import { join } from 'node:path';
-import { getProjectCwd } from './types.js';
+import { getProjectCwd, getMonomindDataRoot, migrateLegacyStoreFile } from './types.js';
 import { weightedTally } from '../consensus/tally.js';
+// Reuse agent-tools.ts's hardened store loader (50MB size cap + __proto__
+// rejection) instead of maintaining a second, weaker copy that reads the
+// same physical file — see loadAgentStore export note there.
+import { loadAgentStore } from './agent-tools.js';
 // Storage paths
 const STORAGE_DIR = '.monomind';
 const HIVE_DIR = 'hive-mind';
@@ -92,7 +96,7 @@ function tryResolveProposal(proposal, totalNodes) {
     return null;
 }
 function getHiveDir() {
-    return join(getProjectCwd(), STORAGE_DIR, HIVE_DIR);
+    return join(getMonomindDataRoot(), HIVE_DIR);
 }
 function getHivePath() {
     return join(getHiveDir(), HIVE_FILE);
@@ -107,6 +111,7 @@ const MAX_HIVE_STATE_BYTES = 10 * 1024 * 1024; // 10 MB
 function loadHiveState() {
     try {
         const path = getHivePath();
+        migrateLegacyStoreFile(path, join(HIVE_DIR, HIVE_FILE));
         if (existsSync(path) && statSync(path).size <= MAX_HIVE_STATE_BYTES) {
             const data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
@@ -176,21 +181,10 @@ function getOrCreateSessionSecret() {
     }
 }
 // Import agent store helpers for spawn functionality
-import { existsSync as agentStoreExists, readFileSync as readAgentStore, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
-// Canonical agent store path matches agent-tools.ts: .monomind/agents/store.json
-function loadAgentStore() {
-    const storePath = join(getProjectCwd(), '.monomind', 'agents', 'store.json');
-    try {
-        if (agentStoreExists(storePath)) {
-            return JSON.parse(readAgentStore(storePath, 'utf-8'));
-        }
-    }
-    catch { /* ignore */ }
-    return { agents: {} };
-}
+import { existsSync as agentStoreExists, writeFileSync as writeAgentStore, mkdirSync as mkdirAgentStore } from 'node:fs';
 const HIVE_RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function saveAgentStore(store) {
-    const storeDir = join(getProjectCwd(), '.monomind', 'agents');
+    const storeDir = join(getMonomindDataRoot(), 'agents');
     if (!agentStoreExists(storeDir)) {
         mkdirAgentStore(storeDir, { recursive: true });
     }
@@ -284,6 +278,10 @@ export const hiveMindTools = [
             properties: {
                 topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'], description: 'Network topology' },
                 queenId: { type: 'string', description: 'Initial queen agent ID' },
+                consensus: { type: 'string', enum: ['byzantine', 'bft', 'raft', 'quorum'], description: 'Consensus strategy to govern hive-mind_consensus propose/vote (gossip/crdt are planned but not implemented and fall back to byzantine). Default: byzantine.' },
+                maxAgents: { type: 'number', description: 'Maximum number of agents in the hive. Default: 15.' },
+                persist: { type: 'boolean', description: 'Whether to persist hive state to disk. Default: true.' },
+                memoryBackend: { type: 'string', description: 'Shared memory backend for the hive. Default: hybrid.' },
             },
         },
         handler: async (input) => {
@@ -294,32 +292,34 @@ export const hiveMindTools = [
             const queenId = typeof rawQueenId === 'string' && rawQueenId.length > MAX_QUEEN_ID_LEN
                 ? rawQueenId.slice(0, MAX_QUEEN_ID_LEN) : rawQueenId;
             const now = new Date().toISOString();
+            // Validate consensus strategy: gossip and crdt are planned but not implemented
+            const SUPPORTED_CONSENSUS = ['byzantine', 'bft', 'raft', 'quorum'];
+            const PLANNED_CONSENSUS = ['gossip', 'crdt'];
+            const requestedConsensus = input.consensus || 'byzantine';
+            const consensusWarning = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? `Strategy "${requestedConsensus}" is planned but not yet implemented; defaulting to "byzantine".`
+                : undefined;
+            const effectiveConsensus = PLANNED_CONSENSUS.includes(requestedConsensus)
+                ? 'byzantine'
+                : (SUPPORTED_CONSENSUS.includes(requestedConsensus) ? requestedConsensus : 'byzantine');
             const state = {
                 initialized: true,
                 hiveId,
                 topology: input.topology || 'mesh',
                 queen: { agentId: queenId, electedAt: now, term: 1 },
                 workers: [],
+                // Persist the chosen strategy on the hive state so hive-mind_consensus
+                // propose/vote default to it instead of silently using 'raft'.
+                // 'byzantine' is the CLI-facing name; the internal ConsensusStrategy type uses 'bft'.
+                consensusStrategy: (effectiveConsensus === 'byzantine' ? 'bft' : effectiveConsensus),
                 consensus: { pending: [], history: [] },
                 sharedMemory: {},
                 createdAt: now,
                 updatedAt: now,
             };
-            saveHiveState(state);
-            // Validate consensus strategy: gossip and crdt are planned but not implemented
-            const SUPPORTED_CONSENSUS = ['byzantine', 'bft', 'raft', 'quorum'];
-            const PLANNED_CONSENSUS = ['gossip', 'crdt'];
-            const requestedConsensus = input.consensus || 'byzantine';
-            const consensusWarning = PLANNED_CONSENSUS.includes(requestedConsensus)
-                ? `Strategy "${requestedConsensus}" is planned but not yet implemented; defaulting to "byzantine".`
-                : undefined;
-            const effectiveConsensus = PLANNED_CONSENSUS.includes(requestedConsensus)
-                ? 'byzantine'
-                : (SUPPORTED_CONSENSUS.includes(requestedConsensus) ? requestedConsensus : 'byzantine');
-            // Persist the chosen strategy on the hive state so hive-mind_consensus
-            // propose/vote default to it instead of silently using 'raft'.
-            // 'byzantine' is the CLI-facing name; the internal ConsensusStrategy type uses 'bft'.
-            state.consensusStrategy = (effectiveConsensus === 'byzantine' ? 'bft' : effectiveConsensus);
+            // Single write — a prior version of this handler saved state twice
+            // (once before setting consensusStrategy, once after), which was
+            // redundant.
             saveHiveState(state);
             return {
                 success: true,
@@ -357,7 +357,8 @@ export const hiveMindTools = [
             // Load agent store once for all workers
             const agentStore = loadAgentStore();
             // Compute real task metrics from task store
-            const taskStorePath = join(getProjectCwd(), '.monomind', 'tasks', 'store.json');
+            const taskStorePath = join(getMonomindDataRoot(), 'tasks', 'store.json');
+            migrateLegacyStoreFile(taskStorePath, join('tasks', 'store.json'));
             let pendingTaskCount = 0;
             let activeTaskCount = 0;
             let completedTaskCount = 0;
@@ -382,7 +383,14 @@ export const hiveMindTools = [
                 hiveId: state.hiveId ?? `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 status: state.initialized ? 'active' : 'offline',
                 topology: state.topology,
-                consensus: 'byzantine', // Default consensus type
+                // Reflect the strategy actually chosen at hive-mind_init (persisted
+                // as state.consensusStrategy so it "actually governs voting" — see
+                // the field's doc comment) instead of hardcoding a default that
+                // ignored what was configured. 'bft' is the internal name for the
+                // CLI-facing 'byzantine' strategy.
+                consensus: state.consensusStrategy
+                    ? (state.consensusStrategy === 'bft' ? 'byzantine' : state.consensusStrategy)
+                    : 'byzantine',
                 queen: state.queen ? {
                     id: state.queen.agentId,
                     agentId: state.queen.agentId,
@@ -398,7 +406,11 @@ export const hiveMindTools = [
                         id: w,
                         type: agent?.agentType || 'worker',
                         status: agent?.status || 'unknown',
-                        currentTask: agent?.currentTask || null,
+                        // AgentRecord has no currentTask field — always null. Kept in the
+                        // response shape for API stability; was already dead before this
+                        // (the previous `as unknown as Record<string, unknown>` cast hid
+                        // that `agent?.currentTask` never matched a real field).
+                        currentTask: null,
                         tasksCompleted: agent?.taskCount || 0,
                     };
                 }),
@@ -729,9 +741,18 @@ export const hiveMindTools = [
                     confidence: 1.0, // uniform until confidence-probe is wired
                 }));
                 const cpwbftTally = weightedTally(weightedVotes);
-                // O-Information gate: defer resolution if we haven't seen enough divergent rounds
+                // O-Information gate: defer resolution if we haven't seen enough divergent rounds.
+                // BUT: if every expected voter has already cast a vote (electorate
+                // exhausted), no more votes can ever arrive to produce a divergent
+                // round — a unanimous first-round vote would otherwise deadlock the
+                // proposal permanently since divergenceRoundsSeen only increments on
+                // disagreement. Treat electorate exhaustion as a terminal condition
+                // that opens the gate regardless of divergence.
+                const totalVotesCast = Object.keys(proposal.votes).length;
+                const electorateExhausted = totalNodes > 0 && totalVotesCast >= totalNodes;
                 const divergenceGateOpen = !proposal.minDivergenceRounds
-                    || (proposal.divergenceRoundsSeen ?? 0) >= proposal.minDivergenceRounds;
+                    || (proposal.divergenceRoundsSeen ?? 0) >= proposal.minDivergenceRounds
+                    || electorateExhausted;
                 // Try to resolve
                 const resolution = divergenceGateOpen ? tryResolveProposal(proposal, totalNodes) : null;
                 let resolved = false;

package/packages/@monomind/cli/dist/src/mcp-tools/knowledge-tools.js

@@ -1,6 +1,7 @@
 /**
  * MCP Knowledge Tools — Second Brain document ingest and search
  */
+import { validateInput } from '../utils/input-guards.js';
 const knowledgeIngest = {
     name: 'knowledge_ingest',
     description: 'Ingest documents into the Second Brain knowledge base. Accepts a file or directory path. Extracts text, chunks, embeds, and stores in LanceDB for semantic search.',
@@ -15,10 +16,17 @@ const knowledgeIngest = {
         required: ['path'],
     },
     handler: async (input) => {
+        const pathCheck = validateInput(input.path, { type: 'path' });
+        if (!pathCheck.valid) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: false, error: pathCheck.error }) }],
+                isError: true,
+            };
+        }
         const { ingestDocument, ingestDirectory } = await import('../knowledge/document-pipeline.js');
         const fs = await import('node:fs');
         const pathMod = await import('node:path');
-        const target = pathMod.resolve(String(input.path));
+        const target = pathMod.resolve(pathCheck.sanitized);
         const scope = String(input.scope || 'shared');
         try {
             const stat = fs.statSync(target);

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-compat.js

@@ -6,26 +6,67 @@
  * moved to the real package.
  */
 import { join, resolve, relative } from 'path';
-import { existsSync, readFileSync, statSync } from 'fs';
-import { openDb, closeDb, countNodes } from '@monoes/monograph';
+import { existsSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+import { openDb, closeDb, countNodes, parseGroupConfig } from '@monoes/monograph';
+import { getProjectCwd } from './types.js';
+import { realOrResolved } from '../utils/input-guards.js';
+// ── Group config reader ───────────────────────────────────────────────────────
 const MAX_GROUP_CONFIG_BYTES = 1 * 1024 * 1024; // 1 MB
+/**
+ * Read repos from a group.yaml config (the real group config format used by
+ * monograph_group_query / monograph_group_sync / monograph_group_list — see
+ * @monoes/monograph's groups/group-config.ts).
+ *
+ * Throws on an out-of-bounds or oversized path instead of silently returning
+ * an empty list, so callers can distinguish "no groups configured" from
+ * "your repoPath was rejected".
+ */
 function readGroupConfig(configPath) {
     if (!existsSync(configPath))
         return [];
+    // Guard: only allow paths within the project cwd to prevent traversal to
+    // /etc/passwd etc. Uses getProjectCwd() (honors MONOMIND_CWD) rather than
+    // process.cwd(), which is trivially bypassed when the MCP server runs with
+    // cwd "/".
+    // realOrResolved resolves symlinks (walking up to the longest existing
+    // ancestor) so a link that's lexically inside projectCwd but physically
+    // points outside it can't bypass this containment check — same guard
+    // input-guards.ts's validatePath uses, applied here against getProjectCwd()
+    // instead of process.cwd() since that's the whole reason this check isn't
+    // just a direct call to validateInput({type:'path'}).
+    const projectCwd = realOrResolved(getProjectCwd());
+    const resolved = realOrResolved(resolve(configPath));
+    const rel = relative(projectCwd, resolved);
+    if (rel.startsWith('..') || resolve(rel) === resolve('/')) {
+        throw new Error(`Rejected group config path outside project directory: ${resolved} (project cwd: ${projectCwd})`);
+    }
+    // OOM guard: skip files larger than 1 MB
+    if (statSync(configPath).size > MAX_GROUP_CONFIG_BYTES) {
+        throw new Error(`Group config file too large (> ${MAX_GROUP_CONFIG_BYTES} bytes): ${configPath}`);
+    }
+    return parseGroupConfig(configPath).repos;
+}
+/**
+ * Compute whether a repo's monograph index is stale relative to HEAD, the
+ * same way monograph_staleness does: compare the last indexed commit hash
+ * against `git rev-list --count <lastCommit>..HEAD`. Mirrors the threshold
+ * used by monograph-tools.ts (STALENESS_THRESHOLD = 10).
+ */
+function isRepoStale(db, repoPath) {
     try {
-        // Guard: only allow paths within cwd to prevent traversal to /etc/passwd etc.
-        const resolved = resolve(configPath);
-        const rel = relative(process.cwd(), resolved);
-        if (rel.startsWith('..') || resolve(rel) === resolve('/'))
-            return [];
-        // OOM guard: skip files larger than 1 MB
-        if (statSync(configPath).size > MAX_GROUP_CONFIG_BYTES)
-            return [];
-        const raw = readFileSync(configPath, 'utf-8');
-        return JSON.parse(raw);
+        const meta = (db.prepare("SELECT value FROM index_meta WHERE key = 'last_commit_hash'").get()
+            ?? db.prepare("SELECT value FROM index_meta WHERE key = 'lastCommit'").get());
+        const lastCommit = meta?.value;
+        if (!lastCommit || !/^[0-9a-f]{7,40}$/i.test(lastCommit))
+            return false;
+        const out = execSync(`git rev-list --count ${lastCommit}..HEAD`, {
+            cwd: repoPath, encoding: 'utf-8',
+        }).trim();
+        return parseInt(out, 10) > 10;
     }
     catch {
-        return [];
+        return false;
     }
 }
 // ── getGroupContracts ─────────────────────────────────────────────────────────
@@ -74,11 +115,12 @@ export async function getGroupStatus(configPath) {
             const nc = countNodes(db);
             const contracts = db.prepare("SELECT COUNT(*) as n FROM nodes WHERE label = 'Route'").get();
             const meta = db.prepare("SELECT value FROM index_meta WHERE key IN ('ua_last_commit','lastCommit') LIMIT 1").get();
+            const stale = isRepoStale(db, repoPath);
             closeDb(db);
             groups.push({
                 name,
                 indexed: nc > 0,
-                stale: false,
+                stale,
                 contractCount: contracts?.n ?? 0,
                 ...(meta?.value ? { lastSync: meta.value } : {}),
             });