swarmdo 1.29.0 → 1.37.0

package/v3/@swarmdo/cli/dist/src/env/env.js

@@ -36,6 +36,26 @@ const VITE_BUILTINS = new Set(['MODE', 'BASE_URL', 'PROD', 'DEV', 'SSR']);
 export function extractEnvRefs(source, file) {
     const out = [];
     const lines = source.split('\n');
+    // Map a byte offset in `source` to its 1-based line, for the whole-source
+    // destructure scan below (which can span lines). lineStart[i] = the offset
+    // where line i+1 begins; binary-search for the last start <= offset.
+    const lineStart = [0];
+    for (let k = 0; k < source.length; k++)
+        if (source[k] === '\n')
+            lineStart.push(k + 1);
+    const lineAt = (index) => {
+        let lo = 0, hi = lineStart.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStart[mid] <= index)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    };
+    // Member-style reads (process.env.X, os.getenv('X'), …) are inherently
+    // single-line — scan line by line so each ref carries its own line number.
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         if (!line.includes('env') && !line.includes('getenv'))
@@ -50,21 +70,27 @@ export function extractEnvRefs(source, file) {
                 out.push({ key, file, line: i + 1 });
             }
         }
-        // Destructuring reads: `const { PORT, DB_URL } = process.env` (each property
-        // key is an env-var reference). The `(?![.[])` guard keeps it to the bare
-        // `process.env` object, not `= process.env.FOO`. Single-line, like the rest.
-        DESTRUCTURE_RE.lastIndex = 0;
-        let dm;
-        while ((dm = DESTRUCTURE_RE.exec(line)) !== null) {
-            for (const part of dm[1].split(',')) {
-                // The env-var name is the property key — left of a rename `:` or default `=`.
-                const key = part.trim().split(/[:=]/)[0].trim();
-                if (!/^[A-Za-z_$][\w$]*$/.test(key))
-                    continue; // skip `...rest`, empties
-                if (VITE_BUILTINS.has(key))
-                    continue;
-                out.push({ key, file, line: i + 1 });
+    }
+    // Destructuring reads: `const { PORT, DB_URL } = process.env`. Scanned over the
+    // WHOLE source, not per line — a Prettier-wrapped list spans lines:
+    //   const {\n  PORT,\n  DB_URL,\n} = process.env
+    // The regex's `\s*`/`[^}]+` already match newlines, so running it per line was
+    // exactly what hid multi-line destructures (a false-clean `env --ci`). The
+    // `(?![.[])` guard keeps it to the bare object, not `= process.env.FOO`; each
+    // property key maps back to its own line via its offset.
+    DESTRUCTURE_RE.lastIndex = 0;
+    let dm;
+    while ((dm = DESTRUCTURE_RE.exec(source)) !== null) {
+        const bodyStart = dm.index + dm[0].indexOf(dm[1]);
+        let partOffset = 0;
+        for (const part of dm[1].split(',')) {
+            // The env-var name is the property key — left of a rename `:` or default `=`.
+            const key = part.trim().split(/[:=]/)[0].trim();
+            if (/^[A-Za-z_$][\w$]*$/.test(key) && !VITE_BUILTINS.has(key)) { // skip `...rest`, empties, builtins
+                const kOff = part.indexOf(key);
+                out.push({ key, file, line: lineAt(bodyStart + partOffset + (kOff < 0 ? 0 : kOff)) });
             }
+            partOffset += part.length + 1; // + the comma consumed by split
         }
     }
     return out;

package/v3/@swarmdo/cli/dist/src/hooks-recipe/recipe.js

@@ -23,6 +23,20 @@ export const RECIPES = [
         title: 'Desktop ping when Claude needs input',
         description: 'Fires a desktop notification when Claude is waiting for input or a permission decision (Notification hook).',
     },
+    {
+        name: 'memory-inject',
+        event: 'UserPromptSubmit',
+        command: 'swarmdo hooks memory-inject',
+        title: 'Inject relevant memories into each prompt',
+        description: 'On every prompt, semantically searches your stored memories (claude-memories/auto-memory/patterns) and injects the most relevant ones as context under a token budget (UserPromptSubmit hook). Powered by `swarmdo hooks memory-inject`. Opt-in: adds a small per-prompt search.',
+    },
+    {
+        name: 'comms-inbox',
+        event: 'UserPromptSubmit',
+        command: 'swarmdo comms inbox --hook',
+        title: 'Surface new cross-session messages each prompt',
+        description: 'On every prompt, injects any unread messages other sessions sent to this one (multiplayer swarms) as context, then marks them read — so mail surfaces without polling (UserPromptSubmit hook). Powered by `swarmdo comms inbox --hook`. Opt-in.',
+    },
 ];
 export function findRecipe(name) {
     const n = (name ?? '').trim().toLowerCase();
@@ -37,7 +51,12 @@ export function hasRecipe(settings, r) {
     const events = hooks?.[r.event];
     if (!Array.isArray(events))
         return false;
-    return events.some((e) => e && typeof e === 'object' && Array.isArray(e.hooks) &&
+    // Match on matcher too: the same command under a DIFFERENT matcher is a
+    // distinct binding, so a matcher-scoped recipe isn't "already installed" just
+    // because its command appears elsewhere (matcher-less recipes compare
+    // undefined === undefined, unchanged).
+    return events.some((e) => e && typeof e === 'object' && e.matcher === r.matcher &&
+        Array.isArray(e.hooks) &&
         e.hooks.some((h) => h?.command === r.command));
 }
 /** Additively merge a recipe into a settings object. Pure: returns a new object,

package/v3/@swarmdo/cli/dist/src/hotspots/hotspots.d.ts

@@ -64,6 +64,9 @@ export declare function resolveRenamePath(raw: string): string;
 export declare function parseGitLog(raw: string): Commit[];
 /** Aggregate commits into per-file hotspots, scored and ranked. Pure. */
 export declare function computeHotspots(commits: Commit[], now: number, opts?: HotspotOptions): FileHotspot[];
+/** Export the ranking as CSV for spreadsheets / tech-debt review. Epoch dates
+ * render as ISO `YYYY-MM-DD` (UTC). Pure. */
+export declare function hotspotsToCsv(spots: FileHotspot[]): string;
 /** Human-readable table. Pure. */
 export declare function formatHotspots(spots: FileHotspot[], now: number): string;
 //# sourceMappingURL=hotspots.d.ts.map

package/v3/@swarmdo/cli/dist/src/hotspots/hotspots.js

@@ -15,6 +15,7 @@
  *   <SOH>%H<US>%an<US>%aI      ← one header line per commit
  *   <added>\t<deleted>\t<path> ← one numstat line per file ('-' for binary)
  */
+import { toCsv } from '../util/csv.js';
 const SOH = '\x01'; // start-of-commit marker (git --format=format:%x01...)
 const US = '\x1f'; // field separator (%x1f)
 /**
@@ -134,6 +135,14 @@ export function computeHotspots(commits, now, opts = {}) {
         out = out.slice(0, opts.top);
     return out;
 }
+/** Export the ranking as CSV for spreadsheets / tech-debt review. Epoch dates
+ * render as ISO `YYYY-MM-DD` (UTC). Pure. */
+export function hotspotsToCsv(spots) {
+    const isoDay = (ms) => (ms > 0 ? new Date(ms).toISOString().slice(0, 10) : '');
+    const headers = ['path', 'risk', 'commits', 'churn', 'authors', 'firstTouched', 'lastTouched'];
+    const rows = spots.map((s) => [s.path, s.risk, s.commits, s.churn, s.authors, isoDay(s.firstTouched), isoDay(s.lastTouched)]);
+    return toCsv(headers, rows);
+}
 /** Human-readable table. Pure. */
 export function formatHotspots(spots, now) {
     if (spots.length === 0)

package/v3/@swarmdo/cli/dist/src/index.js

@@ -20,6 +20,7 @@ import { commands, getCommandsByCategory, getCommand, getCommandAsync, getComman
 import { suggestCommand } from './suggest.js';
 import { runStartupUpdateCheck } from './update/index.js';
 import { migrateStorageDir } from './storage-migration.js';
+import { guardStreamEpipe } from './util/stdout.js';
 // Read version from package.json at runtime
 function getPackageVersion() {
     try {
@@ -68,6 +69,13 @@ export class CLI {
      */
     async run(args = process.argv.slice(2)) {
         try {
+            // #78 — Arm the EPIPE guard on stdout/stderr before ANY write happens, so
+            // `swarmdo <cmd> | head` (reader closes the pipe early) terminates cleanly
+            // instead of crashing with an unhandled 'error' event + raw stack trace.
+            // Covers every write path (output.writeln, console, writeStdout), not just
+            // writeStdout callers. Idempotent per stream.
+            guardStreamEpipe(process.stdout);
+            guardStreamEpipe(process.stderr);
             // One-time storage migration: rename a legacy `.claude-flow/` data dir
             // to `.swarmdo/` so users upgrading across the clean-break rename keep
             // their agent registry, swarm state, task store, and sessions. Cheap

package/v3/@swarmdo/cli/dist/src/license/license.js

@@ -39,7 +39,10 @@ export function classifyLicense(pkg) {
     if (Array.isArray(arr) && arr.length) {
         const types = arr
             .map((e) => (typeof e === 'string' ? e : e?.type))
-            .filter((t) => typeof t === 'string' && !!t.trim());
+            .filter((t) => typeof t === 'string' && !!t.trim())
+            // Normalize each entry like the singular `license`/`{type}` branches above,
+            // so npm sentinels (`SEE LICENSE IN …`, `UNLICENSED`) become UNKNOWN here too.
+            .map(normalizeNpmLicense);
         if (types.length)
             return types.join(' OR ');
     }

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

@@ -15,6 +15,7 @@ import { memoryTools } from './mcp-tools/memory-tools.js';
 import { configTools } from './mcp-tools/config-tools.js';
 import { hooksTools } from './mcp-tools/hooks-tools.js';
 import { taskTools } from './mcp-tools/task-tools.js';
+import { commsTools } from './mcp-tools/comms-tools.js';
 import { sessionTools } from './mcp-tools/session-tools.js';
 import { hiveMindTools } from './mcp-tools/hive-mind-tools.js';
 import { workflowTools } from './mcp-tools/workflow-tools.js';
@@ -107,6 +108,7 @@ const TOOL_GROUPS = {
     config: () => configTools,
     hooks: () => hooksTools,
     task: () => taskTools,
+    comms: () => commsTools,
     session: () => sessionTools,
     'hive-mind': () => hiveMindTools,
     workflow: () => workflowTools,

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

@@ -0,0 +1,11 @@
+/**
+ * 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 { type MCPTool } from './types.js';
+export declare const commsTools: MCPTool[];
+//# sourceMappingURL=comms-tools.d.ts.map

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/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';

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';

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) {

package/v3/@swarmdo/cli/dist/src/pack/pack.js

@@ -193,9 +193,13 @@ export function makeIgnoreMatcher(patterns) {
         const dirOnly = body.endsWith('/');
         if (dirOnly)
             body = body.slice(0, -1);
-        const anchored = body.startsWith('/');
-        if (anchored)
+        const leadingSlash = body.startsWith('/');
+        if (leadingSlash)
             body = body.slice(1);
+        // gitignore(5): a slash ANYWHERE (not just leading) anchors the pattern to
+        // the root — `src/fixtures` matches `src/fixtures` but NOT `a/src/fixtures`.
+        // Only a slash-free pattern (`dir`, `*.ext`) matches at any depth.
+        const anchored = leadingSlash || body.includes('/');
         const re = new RegExp('^' + globToRegExp(body) + (dirOnly ? '(/|$)' : '($|/)'));
         return { negate, anchored, re };
     });