swarmdo 1.30.0 → 1.45.0

package/v3/@swarmdo/cli/dist/src/mcp-tools/comms-tools.js

@@ -0,0 +1,93 @@
+/**
+ * Comms MCP Tools — cross-session agent mailbox (#44).
+ *
+ * Thin wrappers over the pure comms/mailbox.ts engine + comms/store.ts fs
+ * persistence, so an in-Claude session can message another session (or read its
+ * own inbox) without shelling out. Same `.swarmdo/comms/store.json` the
+ * `swarmdo comms` CLI uses.
+ */
+import { getProjectCwd } from './types.js';
+import { createMessage, addMessage, filterInbox, markRead, pruneMailbox } from '../comms/mailbox.js';
+import { loadMailbox, saveMailbox, resolveSelf, newMessageId, RETENTION } from '../comms/store.js';
+export const commsTools = [
+    {
+        name: 'comms_send',
+        description: 'Send a message to another Claude Code session working on the same repo (cross-session mailbox). Address "all" to broadcast to every session. Use for multi-session/"multiplayer" coordination; delivery is via a shared file, not the network.',
+        category: 'comms',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                to: { type: 'string', description: 'Recipient session name, or "all" to broadcast' },
+                message: { type: 'string', description: 'Message body' },
+                subject: { type: 'string', description: 'Optional subject line' },
+                from: { type: 'string', description: 'Sender name (default: this session — $SWARMDO_SESSION or hostname)' },
+            },
+            required: ['to', 'message'],
+        },
+        handler: async (input) => {
+            const to = String(input.to ?? '').trim();
+            const body = String(input.message ?? '');
+            if (!to)
+                return { success: false, error: 'recipient (to) is required' };
+            if (!body.trim())
+                return { success: false, error: 'message is required' };
+            const cwd = getProjectCwd();
+            const from = resolveSelf(input.from);
+            const msg = createMessage({
+                id: newMessageId(),
+                from,
+                to,
+                subject: input.subject,
+                body,
+                createdAt: new Date().toISOString(),
+            });
+            let box = addMessage(loadMailbox(cwd), msg);
+            box = pruneMailbox(box, { ...RETENTION, nowMs: Date.now() });
+            saveMailbox(cwd, box);
+            return { success: true, id: msg.id, to: msg.to, from: msg.from, subject: msg.subject };
+        },
+    },
+    {
+        name: 'comms_inbox',
+        description: 'List messages other sessions have sent to this session (cross-session mailbox), newest first. Includes "all" broadcasts. Set markRead to acknowledge them.',
+        category: 'comms',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                to: { type: 'string', description: 'Whose inbox (default: this session)' },
+                unreadOnly: { type: 'boolean', description: 'Only unread messages' },
+                from: { type: 'string', description: 'Only messages from this sender' },
+                since: { type: 'string', description: 'Only messages after this ISO-8601 timestamp' },
+                markRead: { type: 'boolean', description: 'Mark the returned messages as read' },
+            },
+        },
+        handler: async (input) => {
+            const cwd = getProjectCwd();
+            const self = resolveSelf(input.to);
+            let box = loadMailbox(cwd);
+            const messages = filterInbox(box, {
+                to: self,
+                unreadOnly: input.unreadOnly === true,
+                from: input.from,
+                since: input.since,
+            });
+            let marked = 0;
+            if (input.markRead === true && messages.length > 0) {
+                const res = markRead(box, messages.map((m) => m.id));
+                if (res.marked > 0)
+                    saveMailbox(cwd, res.box);
+                box = res.box;
+                marked = res.marked;
+            }
+            return {
+                success: true,
+                to: self,
+                count: messages.length,
+                unread: filterInbox(box, { to: self, unreadOnly: true }).length,
+                marked,
+                messages,
+            };
+        },
+    },
+];
+//# sourceMappingURL=comms-tools.js.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/coupling-tools.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Coupling MCP Tool
+ *
+ * Let an agent ask "which files change together?" and get ranked JSON — the
+ * EMPIRICAL complement to `affected`'s static import graph. Files that keep
+ * landing in the same commit are coupled in practice even when no import edge
+ * connects them (a JSON schema and its TS type, a serializer/deserializer split
+ * across modules, a doc that must track an API). Surfacing that lets an agent
+ * catch the co-edit it would otherwise forget. Shares the pure engine in
+ * ../coupling/coupling.ts with the CLI; captures git history via subprocess.
+ */
+import type { MCPTool } from './types.js';
+export declare const couplingTools: MCPTool[];
+//# sourceMappingURL=coupling-tools.d.ts.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/coupling-tools.js

@@ -0,0 +1,56 @@
+/**
+ * Coupling MCP Tool
+ *
+ * Let an agent ask "which files change together?" and get ranked JSON — the
+ * EMPIRICAL complement to `affected`'s static import graph. Files that keep
+ * landing in the same commit are coupled in practice even when no import edge
+ * connects them (a JSON schema and its TS type, a serializer/deserializer split
+ * across modules, a doc that must track an API). Surfacing that lets an agent
+ * catch the co-edit it would otherwise forget. Shares the pure engine in
+ * ../coupling/coupling.ts with the CLI; captures git history via subprocess.
+ */
+import { execFileSync } from 'node:child_process';
+import { parseGitLog } from '../hotspots/hotspots.js';
+import { computeCoupling } from '../coupling/coupling.js';
+import { normalizeSince } from '../util/since.js';
+const couplingTool = {
+    name: 'coupling',
+    description: 'Rank file pairs that change together in git history (temporal/co-change coupling) — the empirical complement to `affected`. Returns ranked JSON so an agent editing one file can see what else historically moves with it and avoid a forgotten co-edit. Pass `file` for a "what changes with X?" query. Runs in a git repository.',
+    category: 'coupling',
+    tags: ['git', 'co-change', 'coupling', 'impact', 'refactor'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'repo path to run in (default cwd)' },
+            since: { type: 'string', description: 'history window, e.g. 90d or "3 months ago" (default 1 year)' },
+            top: { type: 'number', description: 'keep only the top N pairs (default 30; 0 = all)' },
+            minShared: { type: 'number', description: 'drop pairs sharing fewer than N commits (default 2)' },
+            maxFiles: { type: 'number', description: 'skip commits touching more than N files (default 30; 0 = no cap)' },
+            file: { type: 'string', description: 'show only pairs involving this exact path ("what changes with X?")' },
+        },
+    },
+    handler: async (params) => {
+        const cwd = typeof params.path === 'string' ? params.path : process.cwd();
+        const since = typeof params.since === 'string' ? params.since : '1 year ago';
+        const top = typeof params.top === 'number' ? params.top : 30;
+        const minShared = typeof params.minShared === 'number' ? params.minShared : 2;
+        const maxFiles = typeof params.maxFiles === 'number' ? params.maxFiles : 30;
+        const focus = typeof params.file === 'string' && params.file ? params.file : undefined;
+        // Capture the FULL history (no pathspec filter even when focused) — filtering
+        // the log to `focus` would strip the co-changed files out of each commit's
+        // numstat. We filter PAIRS in the engine (opts.focus) instead. Same
+        // `--numstat` dump `hotspots` parses.
+        const args = ['log', '--no-merges', '--numstat', `--since=${normalizeSince(since)}`, '--format=format:%x01%H%x1f%aN%x1f%aI'];
+        let raw;
+        try {
+            raw = execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 128 * 1024 * 1024 });
+        }
+        catch {
+            return { error: true, message: 'git log failed — not a git repository?' };
+        }
+        const coupling = computeCoupling(parseGitLog(raw), { minShared, maxFiles, top: top > 0 ? top : undefined, focus });
+        return { since, minShared, count: coupling.length, coupling };
+    },
+};
+export const couplingTools = [couplingTool];
+//# sourceMappingURL=coupling-tools.js.map

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.d.ts

@@ -10,6 +10,7 @@ export { memoryTools } from './memory-tools.js';
 export { configTools } from './config-tools.js';
 export { hooksTools } from './hooks-tools.js';
 export { taskTools } from './task-tools.js';
+export { commsTools } from './comms-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
@@ -21,6 +22,7 @@ export { envTools } from './env-tools.js';
 export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
+export { couplingTools } from './coupling-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
 export { testreportTools } from './testreport-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/index.js

@@ -9,6 +9,7 @@ export { memoryTools } from './memory-tools.js';
 export { configTools } from './config-tools.js';
 export { hooksTools } from './hooks-tools.js';
 export { taskTools } from './task-tools.js';
+export { commsTools } from './comms-tools.js';
 export { sessionTools } from './session-tools.js';
 export { hiveMindTools } from './hive-mind-tools.js';
 export { workflowTools } from './workflow-tools.js';
@@ -20,6 +21,7 @@ export { envTools } from './env-tools.js';
 export { licenseTools } from './license-tools.js';
 export { applyTools } from './apply-tools.js';
 export { hotspotsTools } from './hotspots-tools.js';
+export { couplingTools } from './coupling-tools.js';
 export { affectedTools } from './affected-tools.js';
 export { cyclesTools } from './cycles-tools.js';
 export { testreportTools } from './testreport-tools.js';

package/v3/@swarmdo/cli/dist/src/mcp-tools/profiles.js

@@ -27,6 +27,7 @@ const LEAN_GROUPS = [
     'env', // env_check — env-var drift (missing/unused/undocumented)
     'apply', // apply_patch — fuzzy unified-diff applier for agent edits
     'hotspots', // hotspots — git-history change-risk ranking ("where's the debt?")
+    'coupling', // coupling — files that change together (temporal co-change), complements affected
     'affected', // affected — impacted files/tests from a change via the import graph
     'cycles', // cycles — circular-import detection via the import graph
     'testreport', // testreport — JUnit/TAP → structured failure digest (pairs w/ repair)

package/v3/@swarmdo/cli/dist/src/mcp-tools/task-deps.d.ts

@@ -42,6 +42,41 @@ export declare function readyTasks(store: TaskStore): TaskRecord[];
 export declare function blockedTasks(store: TaskStore): BlockedInfo[];
 /** Tasks that became ready exactly because `completedTaskId` completed. */
 export declare function unblockedBy(store: TaskStore, completedTaskId: string): TaskRecord[];
+export interface DeadBlock {
+    task: TaskRecord;
+    /**
+     * The terminal-dead dependency ids in this task's dependency closure — the
+     * failed, cancelled, or missing tasks that make it permanently unreachable
+     * until a human retries/cancels/creates them. Deterministic (sorted).
+     */
+    rootCause: string[];
+}
+export interface TaskDagHealth {
+    /** pending tasks whose unmet deps can STILL complete — a transient wait */
+    liveBlocked: TaskRecord[];
+    /** pending tasks that can NEVER become ready without human intervention */
+    deadBlocked: DeadBlock[];
+    /**
+     * true when pending work exists but nothing is ready AND nothing is
+     * in_progress — the DAG cannot advance on its own. A coordinator looping on
+     * `task dispatch` would otherwise spin forever doing nothing.
+     */
+    deadlocked: boolean;
+}
+/**
+ * Classify every blocked task as live- vs dead-blocked and report a global
+ * deadlock verdict. Pure.
+ *
+ * This is Apache Airflow's `upstream_failed` state + DAG-deadlock detection,
+ * ported onto the beads-style task DAG (see the module header): a dependency
+ * that failed / was cancelled / is missing NEVER satisfies (only 'completed'
+ * does), so every task transitively downstream is permanently stuck until a
+ * human intervenes. `blockedTasks()` reports the wait but can't tell a
+ * transient wait from a permanent one — the dispatcher then skips a
+ * failed-dep block every pass, indistinguishable from a normal wait, and the
+ * DAG quietly wedges. This turns that silent stall into a named diagnostic.
+ */
+export declare function taskDagHealth(store: TaskStore): TaskDagHealth;
 /**
  * Flat dependency view: one line per task, dependencies inline with their
  * states. A DAG has no single tree; a flat annotated list stays honest for

package/v3/@swarmdo/cli/dist/src/mcp-tools/task-deps.js

@@ -94,6 +94,93 @@ export function blockedTasks(store) {
 export function unblockedBy(store, completedTaskId) {
     return Object.values(store.tasks).filter((t) => t.status === 'pending' && (t.dependsOn ?? []).includes(completedTaskId) && isReady(store, t));
 }
+/**
+ * Classify every blocked task as live- vs dead-blocked and report a global
+ * deadlock verdict. Pure.
+ *
+ * This is Apache Airflow's `upstream_failed` state + DAG-deadlock detection,
+ * ported onto the beads-style task DAG (see the module header): a dependency
+ * that failed / was cancelled / is missing NEVER satisfies (only 'completed'
+ * does), so every task transitively downstream is permanently stuck until a
+ * human intervenes. `blockedTasks()` reports the wait but can't tell a
+ * transient wait from a permanent one — the dispatcher then skips a
+ * failed-dep block every pass, indistinguishable from a normal wait, and the
+ * DAG quietly wedges. This turns that silent stall into a named diagnostic.
+ */
+export function taskDagHealth(store) {
+    // canComplete(id): can this task ever reach status 'completed'?
+    //   completed → yes; failed/cancelled/missing → no; pending/in_progress →
+    //   only if EVERY dependency can complete. Memoized; a cycle (the store is
+    //   acyclic by invariant, but guard anyway) resolves to false.
+    const memo = new Map();
+    const visiting = new Set();
+    const canComplete = (id) => {
+        const cached = memo.get(id);
+        if (cached !== undefined)
+            return cached;
+        const task = store.tasks[id];
+        if (!task)
+            return false; // missing id — blocks forever
+        if (task.status === 'completed')
+            return true;
+        if (task.status === 'failed' || task.status === 'cancelled')
+            return false;
+        if (visiting.has(id))
+            return false; // cycle guard
+        visiting.add(id);
+        const ok = (task.dependsOn ?? []).every((d) => canComplete(d));
+        visiting.delete(id);
+        memo.set(id, ok);
+        return ok;
+    };
+    // The terminal-dead ids (failed/cancelled/missing) reachable from a task,
+    // descending THROUGH still-pending intermediates to name the real culprit.
+    const deadRoots = (task) => {
+        const found = new Set();
+        const seen = new Set();
+        const stack = [...(task.dependsOn ?? [])];
+        while (stack.length) {
+            const id = stack.pop();
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const dep = store.tasks[id];
+            if (!dep) {
+                found.add(id);
+                continue;
+            } // missing
+            if (dep.status === 'failed' || dep.status === 'cancelled') {
+                found.add(id);
+                continue;
+            }
+            if (dep.status === 'completed')
+                continue; // satisfied — not a culprit
+            for (const d of dep.dependsOn ?? [])
+                stack.push(d); // pending/in_progress → descend
+        }
+        return [...found].sort();
+    };
+    const liveBlocked = [];
+    const deadBlocked = [];
+    for (const task of Object.values(store.tasks)) {
+        if (task.status !== 'pending')
+            continue;
+        const deps = task.dependsOn ?? [];
+        if (deps.length === 0)
+            continue; // ready (dep-free), not blocked
+        if (deps.every((id) => satisfies(store.tasks[id])))
+            continue; // ready, not blocked
+        if (deps.every((id) => canComplete(id)))
+            liveBlocked.push(task);
+        else
+            deadBlocked.push({ task, rootCause: deadRoots(task) });
+    }
+    const all = Object.values(store.tasks);
+    const anyPending = all.some((t) => t.status === 'pending');
+    const anyInProgress = all.some((t) => t.status === 'in_progress');
+    const deadlocked = anyPending && readyTasks(store).length === 0 && !anyInProgress;
+    return { liveBlocked, deadBlocked, deadlocked };
+}
 const STATUS_MARK = {
     completed: '✔',
     in_progress: '▶',

package/v3/@swarmdo/cli/dist/src/mcp-tools/task-tools.js

@@ -485,6 +485,10 @@ export const taskTools = [
                 progress: 0,
                 assignedTo: [...original.assignedTo],
                 tags: [...original.tags, 'retry-of:' + taskId],
+                // Carry the dependency gate — a retried task must stay blocked until its
+                // prerequisites complete, exactly like the original. Dropping it let the
+                // dispatcher run the retry against unfinished/failed deps (a half-built state).
+                ...(original.dependsOn?.length ? { dependsOn: [...original.dependsOn] } : {}),
                 createdAt: new Date().toISOString(),
                 startedAt: null,
                 completedAt: null,

package/v3/@swarmdo/cli/dist/src/memory/memory-bridge.d.ts

@@ -54,6 +54,8 @@ export declare function bridgeSearchEntries(options: {
     limit?: number;
     threshold?: number;
     dbPath?: string;
+    /** Return full entry content instead of the 60-char preview (for memory injection). */
+    fullContent?: boolean;
 }): Promise<{
     success: boolean;
     results: {

package/v3/@swarmdo/cli/dist/src/memory/memory-bridge.js

@@ -714,7 +714,7 @@ export async function bridgeSearchEntries(options) {
     if (!ctx)
         return null;
     try {
-        const { query: queryStr, namespace, limit = 10, threshold = 0.3 } = options;
+        const { query: queryStr, namespace, limit = 10, threshold = 0.3, fullContent = false } = options;
         const effectiveNamespace = namespace || 'all';
         const startTime = Date.now();
         // Generate query embedding
@@ -784,7 +784,9 @@ export async function bridgeSearchEntries(options) {
                 results.push({
                     id: String(row.id).substring(0, 12),
                     key: row.key || String(row.id).substring(0, 15),
-                    content: (row.content || '').substring(0, 60) + ((row.content || '').length > 60 ? '...' : ''),
+                    content: fullContent
+                        ? (row.content || '')
+                        : (row.content || '').substring(0, 60) + ((row.content || '').length > 60 ? '...' : ''),
                     score,
                     namespace: row.namespace || 'default',
                     provenance,

package/v3/@swarmdo/cli/dist/src/memory-inject/select.d.ts

@@ -0,0 +1,82 @@
+/**
+ * memory-inject/select.ts — pure selection + formatting for prompt-time
+ * semantic memory injection (#43).
+ *
+ * A UserPromptSubmit hook embeds the current prompt, vector-searches AgentDB
+ * across the memory namespaces, and injects the most relevant stored memories
+ * into Claude's context under a strict token budget — recall at the moment of
+ * need instead of a manual `memory search` or a bulk session-start dump.
+ *
+ * This module is the DIFFERENTIATING logic and is deliberately pure (no I/O, no
+ * embeddings): given already-scored candidates it decides WHICH memories to
+ * inject (relevance threshold, cross-namespace dedup, token budget, top-k) and
+ * formats the context block. The command layer (`hooks memory-inject`) supplies
+ * the real embedding + vector search and emits the hook JSON.
+ */
+/** One candidate memory returned by the vector search. */
+export interface InjectionCandidate {
+    key: string;
+    namespace: string;
+    content: string;
+    /** Relevance (higher = more relevant), from the vector search. */
+    score: number;
+    provenance?: string;
+}
+export interface InjectionOptions {
+    /** Max tokens the whole injected block may occupy (estimate). Default 800. */
+    budgetTokens?: number;
+    /** Drop candidates scoring below this. Default 0.35. */
+    minRelevance?: number;
+    /** Never inject more than this many memories. Default 5. */
+    topK?: number;
+    /** Chars-per-token estimate for the budget. Default 4. */
+    charsPerToken?: number;
+    /** Trim each memory's content to this many chars before formatting. Default 400. */
+    maxItemChars?: number;
+    /** Heading for the injected block. */
+    header?: string;
+}
+export interface InjectionResult {
+    /** The formatted context block, or '' when nothing qualifies. */
+    block: string;
+    /** Candidates actually included (content already trimmed), in injection order. */
+    used: InjectionCandidate[];
+    /** Qualifying, unique candidates left out by the token budget or top-k cap. */
+    skipped: number;
+    /** Estimated tokens the rendered block occupies. */
+    tokensUsed: number;
+}
+/** Rough token estimate: ceil(chars / charsPerToken). */
+export declare function estimateTokens(text: string, charsPerToken?: number): number;
+/** Collapse whitespace and cap length at a word boundary, adding an ellipsis. */
+export declare function trimContent(content: string, maxChars: number): string;
+/**
+ * Select and format the memories to inject.
+ *
+ * Pipeline: drop empty/below-threshold → sort by score desc (shorter content
+ * wins ties so the budget packs more) → dedup by normalized content → greedily
+ * fill the token budget up to top-k, trimming each item. Returns block: '' when
+ * nothing qualifies (caller injects nothing — no context noise).
+ */
+export declare function selectInjectionMemories(candidates: InjectionCandidate[], options?: InjectionOptions): InjectionResult;
+/**
+ * Extract the user's prompt from a Claude Code UserPromptSubmit hook payload.
+ * Claude Code pipes JSON like `{"prompt":"…","session_id":"…"}` on stdin. Falls
+ * back to `.userPrompt`/`.message`, then to the raw text when it isn't JSON
+ * (a caller passing a plain string). Returns '' when nothing usable is found.
+ */
+export declare function extractPromptFromPayload(raw: string): string;
+/** A vector-search row as returned by bridgeSearchEntries. */
+export interface SearchRow {
+    key: string;
+    content: string;
+    score: number;
+    namespace: string;
+    provenance?: string;
+}
+/**
+ * Map raw search rows to injection candidates, dropping empty content and
+ * (when `allowed` is given) rows outside the requested namespace set.
+ */
+export declare function mapSearchResultsToCandidates(results: SearchRow[], allowed?: string[] | Set<string>): InjectionCandidate[];
+//# sourceMappingURL=select.d.ts.map

package/v3/@swarmdo/cli/dist/src/memory-inject/select.js

@@ -0,0 +1,164 @@
+/**
+ * memory-inject/select.ts — pure selection + formatting for prompt-time
+ * semantic memory injection (#43).
+ *
+ * A UserPromptSubmit hook embeds the current prompt, vector-searches AgentDB
+ * across the memory namespaces, and injects the most relevant stored memories
+ * into Claude's context under a strict token budget — recall at the moment of
+ * need instead of a manual `memory search` or a bulk session-start dump.
+ *
+ * This module is the DIFFERENTIATING logic and is deliberately pure (no I/O, no
+ * embeddings): given already-scored candidates it decides WHICH memories to
+ * inject (relevance threshold, cross-namespace dedup, token budget, top-k) and
+ * formats the context block. The command layer (`hooks memory-inject`) supplies
+ * the real embedding + vector search and emits the hook JSON.
+ */
+const DEFAULTS = {
+    budgetTokens: 800,
+    minRelevance: 0.35,
+    topK: 5,
+    charsPerToken: 4,
+    maxItemChars: 400,
+    header: '## 🧠 Relevant memories (swarmdo)',
+};
+/**
+ * Intro line placed under the header. States the provenance + a verify caveat —
+ * injected memories reflect what was true WHEN WRITTEN, so file/flag names may
+ * be stale (matches the auto-memory guidance).
+ */
+const INTRO = 'Retrieved from stored memory by semantic search — may be relevant to this request. ' +
+    'They reflect what was true when written; verify file/flag/function names before relying on them.';
+/** Rough token estimate: ceil(chars / charsPerToken). */
+export function estimateTokens(text, charsPerToken = DEFAULTS.charsPerToken) {
+    const cpt = charsPerToken > 0 ? charsPerToken : DEFAULTS.charsPerToken;
+    return Math.ceil(text.length / cpt);
+}
+/** Collapse whitespace and cap length at a word boundary, adding an ellipsis. */
+export function trimContent(content, maxChars) {
+    const collapsed = content.replace(/\s+/g, ' ').trim();
+    if (maxChars <= 0 || collapsed.length <= maxChars)
+        return collapsed;
+    const cut = collapsed.slice(0, maxChars);
+    const lastSpace = cut.lastIndexOf(' ');
+    const body = lastSpace > maxChars * 0.6 ? cut.slice(0, lastSpace) : cut;
+    return body.trimEnd() + '…';
+}
+/** Normalized dedup key — the same memory bridged into >1 namespace collapses. */
+function dedupKey(c) {
+    return c.content.replace(/\s+/g, ' ').trim().toLowerCase();
+}
+/** Format one memory as a source-attributed bullet. Score shown as a percent. */
+function formatItem(c) {
+    const pct = Math.round(Math.max(0, Math.min(1, c.score)) * 100);
+    return `- **[${c.namespace}/${c.key}]** (${pct}%) ${c.content}`;
+}
+function renderBlock(used, header) {
+    const lines = [header, INTRO, '', ...used.map(formatItem)];
+    return lines.join('\n');
+}
+/**
+ * Select and format the memories to inject.
+ *
+ * Pipeline: drop empty/below-threshold → sort by score desc (shorter content
+ * wins ties so the budget packs more) → dedup by normalized content → greedily
+ * fill the token budget up to top-k, trimming each item. Returns block: '' when
+ * nothing qualifies (caller injects nothing — no context noise).
+ */
+export function selectInjectionMemories(candidates, options = {}) {
+    const opts = {
+        budgetTokens: options.budgetTokens ?? DEFAULTS.budgetTokens,
+        minRelevance: options.minRelevance ?? DEFAULTS.minRelevance,
+        topK: options.topK ?? DEFAULTS.topK,
+        charsPerToken: options.charsPerToken ?? DEFAULTS.charsPerToken,
+        maxItemChars: options.maxItemChars ?? DEFAULTS.maxItemChars,
+        header: options.header ?? DEFAULTS.header,
+    };
+    const budget = Math.max(0, opts.budgetTokens);
+    const topK = Math.max(0, Math.floor(opts.topK));
+    const qualifying = (candidates || []).filter((c) => c &&
+        typeof c.content === 'string' &&
+        c.content.trim().length > 0 &&
+        typeof c.score === 'number' &&
+        c.score >= opts.minRelevance);
+    const sorted = [...qualifying].sort((a, b) => b.score - a.score || a.content.length - b.content.length || a.key.localeCompare(b.key));
+    const seen = new Set();
+    const unique = [];
+    for (const c of sorted) {
+        const k = dedupKey(c);
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        unique.push(c);
+    }
+    // Fixed overhead of the header + intro line; every bullet must fit alongside it.
+    const overhead = estimateTokens(`${opts.header}\n${INTRO}\n`, opts.charsPerToken);
+    const used = [];
+    let lineTokens = 0;
+    let skipped = 0;
+    for (const c of unique) {
+        if (used.length >= topK) {
+            skipped++;
+            continue;
+        }
+        const trimmed = { ...c, content: trimContent(c.content, opts.maxItemChars) };
+        const cost = estimateTokens('\n' + formatItem(trimmed), opts.charsPerToken);
+        if (overhead + lineTokens + cost > budget) {
+            skipped++;
+            continue;
+        }
+        used.push(trimmed);
+        lineTokens += cost;
+    }
+    if (used.length === 0) {
+        return { block: '', used: [], skipped, tokensUsed: 0 };
+    }
+    const block = renderBlock(used, opts.header);
+    return { block, used, skipped, tokensUsed: estimateTokens(block, opts.charsPerToken) };
+}
+/**
+ * Extract the user's prompt from a Claude Code UserPromptSubmit hook payload.
+ * Claude Code pipes JSON like `{"prompt":"…","session_id":"…"}` on stdin. Falls
+ * back to `.userPrompt`/`.message`, then to the raw text when it isn't JSON
+ * (a caller passing a plain string). Returns '' when nothing usable is found.
+ */
+export function extractPromptFromPayload(raw) {
+    const text = (raw || '').trim();
+    if (!text)
+        return '';
+    try {
+        const obj = JSON.parse(text);
+        if (obj && typeof obj === 'object') {
+            const p = obj.prompt ?? obj.userPrompt ?? obj.message ?? obj.text;
+            return typeof p === 'string' ? p.trim() : '';
+        }
+        // JSON that parsed to a bare string/number → use its string form.
+        return typeof obj === 'string' ? obj.trim() : '';
+    }
+    catch {
+        // Not JSON — treat the raw text as the prompt.
+        return text;
+    }
+}
+/**
+ * Map raw search rows to injection candidates, dropping empty content and
+ * (when `allowed` is given) rows outside the requested namespace set.
+ */
+export function mapSearchResultsToCandidates(results, allowed) {
+    const allow = allowed ? (allowed instanceof Set ? allowed : new Set(allowed)) : null;
+    const out = [];
+    for (const r of results || []) {
+        if (!r || typeof r.content !== 'string' || r.content.trim().length === 0)
+            continue;
+        if (allow && !allow.has(r.namespace))
+            continue;
+        out.push({
+            key: r.key,
+            namespace: r.namespace,
+            content: r.content,
+            score: typeof r.score === 'number' ? r.score : 0,
+            provenance: r.provenance,
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=select.js.map

package/v3/@swarmdo/cli/dist/src/memory-vault/import.js

@@ -27,12 +27,22 @@ export function unfenceBody(body) {
     const m = /^```json\n([\s\S]*)\n```$/.exec(t);
     if (!m)
         return body;
+    let parsed;
     try {
-        return JSON.stringify(JSON.parse(m[1]));
+        parsed = JSON.parse(m[1]);
     }
     catch {
         return body;
     }
+    // Only unfence a block that renderBody itself produced (it always pretty-prints
+    // with 2-space indent). A raw stored value that merely HAPPENS to already be a
+    // ```json fence — renderBody left it untouched because it isn't a bare
+    // object/array — must round-trip byte-for-byte; minifying it would silently
+    // rewrite the user's data on every export→import even with zero edits.
+    const reFenced = '```json\n' + JSON.stringify(parsed, null, 2) + '\n```';
+    if (reFenced !== t)
+        return body;
+    return JSON.stringify(parsed);
 }
 /** Parse one note. Returns null unless it carries our frontmatter stamp. */
 export function parseNote(content) {