moflo 4.12.4 → 4.12.5

package/dist/src/cli/commands/swarm.js

@@ -10,6 +10,75 @@ import * as path from 'path';
 import { LEGACY_SWARM_DIR, memoryDbCandidatePaths, mofloDir } from '../services/moflo-paths.js';
 import { findProjectRoot } from '../services/project-root.js';
 import { resolveStateRoot } from '../services/project-root.js';
+/**
+ * Canonical path first, then the pre-#1168 `.swarm/state.json` fallback, so a
+ * consumer who initialised on an older moflo still resolves their swarm.
+ * Writes only ever go to `[0]`.
+ */
+function swarmStateFileCandidates() {
+    const root = findProjectRoot();
+    return [
+        path.join(mofloDir(root), 'swarm', 'state.json'),
+        path.join(root, LEGACY_SWARM_DIR, 'state.json'),
+    ];
+}
+function readSwarmState() {
+    for (const file of swarmStateFileCandidates()) {
+        if (!fs.existsSync(file))
+            continue;
+        try {
+            return JSON.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch {
+            // A malformed state file is treated as absent rather than fatal — the
+            // remedy is `flo swarm init`, which overwrites it.
+        }
+    }
+    return null;
+}
+function writeSwarmState(state) {
+    const [canonical] = swarmStateFileCandidates();
+    fs.mkdirSync(path.dirname(canonical), { recursive: true });
+    fs.writeFileSync(canonical, JSON.stringify(state, null, 2));
+}
+/**
+ * Resolve the recorded swarm, or print why it cannot be and return null —
+ * in which case the caller exits non-zero without doing anything.
+ *
+ * Shared by `stop` and `scale`: both must refuse an id that is not the active
+ * swarm rather than acting on it, which is half of what #1428 was about.
+ */
+function resolveActiveSwarm(swarmId, missingMessage) {
+    const existing = readSwarmState();
+    if (!existing) {
+        output.printError(missingMessage);
+        output.printInfo('Run "flo swarm status" to see what is recorded for this project.');
+        return null;
+    }
+    if (existing.id !== swarmId) {
+        output.printError(`Swarm ${swarmId} is not the active swarm.`);
+        output.printInfo(`Active swarm is ${existing.id} — run "flo swarm status" to confirm.`);
+        return null;
+    }
+    return existing;
+}
+/** Remove both the canonical and legacy state files; returns true if any existed. */
+function clearSwarmState() {
+    let removed = false;
+    for (const file of swarmStateFileCandidates()) {
+        if (!fs.existsSync(file))
+            continue;
+        try {
+            fs.rmSync(file, { force: true });
+            removed = true;
+        }
+        catch {
+            // Leave `removed` false — the caller reports the failure rather than
+            // claiming a stop that did not happen.
+        }
+    }
+    return removed;
+}
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
     const projectRoot = findProjectRoot();
@@ -19,24 +88,11 @@ function getSwarmStatus(swarmId) {
     // were removed — no current writer creates those directories, so they
     // always produced 0 counts. The coordinator-backed MCP tools
     // (agent_list / task_list) are the live source of truth.
-    const canonicalSwarmDir = path.join(mofloDir(projectRoot), 'swarm');
-    const legacySwarmDir = path.join(projectRoot, LEGACY_SWARM_DIR);
     const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
     const memoryPaths = memoryDbCandidatePaths(resolveStateRoot());
-    // Check for active swarm state file — canonical first, then legacy.
-    let swarmStateFile = path.join(canonicalSwarmDir, 'state.json');
-    if (!fs.existsSync(swarmStateFile)) {
-        swarmStateFile = path.join(legacySwarmDir, 'state.json');
-    }
-    let swarmState = null;
-    if (fs.existsSync(swarmStateFile)) {
-        try {
-            swarmState = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
-        }
-        catch {
-            // Ignore parse errors
-        }
-    }
+    // Canonical first, then legacy — shared with init/start/stop so all four
+    // subcommands resolve the same file.
+    const swarmState = readSwarmState();
     // agents/tasks counters: no file-store readers post-#1168. Coordinator
     // MCP tools own the live counts; getSwarmStatus surfaces a static summary
     // of the persisted state file plus session/memory rough indicators.
@@ -88,7 +144,10 @@ function getSwarmStatus(swarmId) {
         status = 'completed';
     }
     else if (swarmState) {
-        status = 'ready';
+        // Honour what was recorded. `start` writes `running`; `init` writes
+        // `ready`. Pre-#1428 this collapsed both to `ready`, so a recorded
+        // objective was invisible here.
+        status = swarmState.status || 'ready';
     }
     return {
         id: swarmId || swarmState?.id || 'no-active-swarm',
@@ -249,14 +308,9 @@ const initCommand = {
             // Save swarm state locally for status command to read. Post-#1168 the
             // canonical home is `<root>/.moflo/swarm/state.json`; the legacy
             // `.swarm/state.json` path is preserved as a read-only fallback in
-            // `getSwarmStatus`.
-            const swarmDir = path.join(mofloDir(findProjectRoot()), 'swarm');
+            // `readSwarmState`.
             try {
-                if (!fs.existsSync(swarmDir)) {
-                    fs.mkdirSync(swarmDir, { recursive: true });
-                }
-                const stateFile = path.join(swarmDir, 'state.json');
-                fs.writeFileSync(stateFile, JSON.stringify({
+                writeSwarmState({
                     id: result.swarmId,
                     topology: result.topology,
                     maxAgents: result.config.maxAgents,
@@ -264,7 +318,7 @@ const initCommand = {
                     v3Mode,
                     initializedAt: result.initializedAt,
                     status: 'ready'
-                }, null, 2));
+                });
             }
             catch {
                 // Ignore errors writing state file
@@ -338,12 +392,22 @@ const startCommand = {
             });
         }
         strategy = strategy || 'development';
+        // #1428 — refuse rather than narrate. Pre-fix this command printed "All
+        // agents deployed" and a `flo swarm status <id>` follow-up for an id it
+        // never persisted, so the advertised command reported either no active
+        // swarm or the state of an unrelated earlier `init`.
+        const existing = readSwarmState();
+        if (!existing) {
+            output.printError('No initialised swarm found.');
+            output.printInfo('Run "flo swarm init" first — it records the topology this objective attaches to.');
+            return { success: false, exitCode: 1 };
+        }
         output.writeln();
         output.printInfo(`Starting swarm with objective: ${output.highlight(objective)}`);
         output.writeln();
         // Compute agent deployment plan based on strategy
         const agentPlan = getAgentPlan(strategy);
-        output.writeln(output.bold('Agent Deployment Plan'));
+        output.writeln(output.bold('Planned Agent Roster'));
         output.printTable({
             columns: [
                 { key: 'role', header: 'Role', width: 20 },
@@ -353,10 +417,11 @@ const startCommand = {
             ],
             data: agentPlan
         });
+        const plannedAgents = agentPlan.reduce((sum, a) => sum + a.count, 0);
         // Confirm execution
         if (ctx.interactive) {
             const confirmed = await confirm({
-                message: `Deploy ${agentPlan.reduce((sum, a) => sum + a.count, 0)} agents?`,
+                message: `Record this objective for ${plannedAgents} agents?`,
                 default: true
             });
             if (!confirmed) {
@@ -364,26 +429,47 @@ const startCommand = {
                 return { success: true };
             }
         }
-        output.writeln();
-        output.printInfo('Deploying agents...');
-        // Show deployment progress
-        const spinner = output.createSpinner({ text: 'Initializing agents...', spinner: 'dots' });
-        spinner.start();
-        // Brief delay for spinner animation
-        await new Promise(resolve => setTimeout(resolve, 500));
-        spinner.succeed('All agents deployed');
+        const startedAt = new Date().toISOString();
         const executionState = {
-            swarmId: `swarm-${Date.now().toString(36)}`,
+            // The persisted id, never a freshly-minted one — `flo swarm status`
+            // resolves ids out of this same file, so a local mint was guaranteed
+            // to be unresolvable.
+            swarmId: existing.id,
             objective,
             strategy,
             status: 'running',
-            agents: agentPlan.reduce((sum, a) => sum + a.count, 0),
-            startedAt: new Date().toISOString(),
+            agents: plannedAgents,
+            startedAt,
             parallel: ctx.flags.parallel ?? true
         };
+        try {
+            writeSwarmState({
+                ...existing,
+                strategy,
+                objective,
+                plannedAgents,
+                startedAt,
+                status: 'running',
+            });
+        }
+        catch (error) {
+            output.printError(`Failed to record objective: ${String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
         output.writeln();
-        output.printSuccess('Swarm execution started');
+        output.printSuccess(`Objective recorded against swarm ${executionState.swarmId}`);
         output.writeln(output.dim(`  Monitor: flo swarm status ${executionState.swarmId}`));
+        output.writeln();
+        // Say plainly what did NOT happen. The CLI reaches its MCP tools in-process
+        // (see SwarmStateFile above), so agents spawned here would not outlive this
+        // command — the long-lived coordinator is the one inside the MCP server.
+        output.printInfo('No agents were spawned by this command.');
+        output.writeln(output.dim('  The roster above is a plan. Agents run on the long-lived coordinator'));
+        output.writeln(output.dim('  in the MCP server — drive them from a Claude Code session with the'));
+        output.writeln(output.dim('  swarm_init / agent_spawn / task_orchestrate tools.'));
+        if (ctx.flags.format === 'json') {
+            output.printJson(executionState);
+        }
         return { success: true, data: executionState };
     }
 };
@@ -491,9 +577,16 @@ const stopCommand = {
             output.printInfo('Run "moflo swarm status" to find the active swarm ID');
             return { success: false, exitCode: 1 };
         }
+        // #1428 — `stop` used to print "Swarm <id> stopped" for any string at all,
+        // including an id that never existed, while leaving the state file in
+        // place. It is the counterpart to `start`: if it does not clear that file,
+        // `flo swarm status` reports the objective as running indefinitely.
+        const existing = resolveActiveSwarm(swarmId, 'No active swarm to stop.');
+        if (!existing)
+            return { success: false, exitCode: 1 };
         if (ctx.interactive && !force) {
             const confirmed = await confirm({
-                message: `Stop swarm ${swarmId}? Progress will be saved.`,
+                message: `Stop swarm ${swarmId}? Its recorded objective will be cleared.`,
                 default: false
             });
             if (!confirmed) {
@@ -502,13 +595,14 @@ const stopCommand = {
             }
         }
         output.printInfo(`Stopping swarm ${swarmId}...`);
-        if (!force) {
-            output.writeln(output.dim('  Completing in-progress tasks...'));
-            output.writeln(output.dim('  Saving coordination state...'));
-            output.writeln(output.dim('  Notifying agents...'));
-            output.writeln(output.dim('  Saving memory state...'));
+        if (!clearSwarmState()) {
+            output.printError(`Failed to clear swarm state for ${swarmId}.`);
+            return { success: false, exitCode: 1 };
         }
         output.printSuccess(`Swarm ${swarmId} stopped`);
+        // Only the recorded state is ours to clear — see SwarmStateFile.
+        output.writeln(output.dim('  Cleared the recorded swarm state. Agents running on the MCP'));
+        output.writeln(output.dim('  coordinator are unaffected — terminate those with agent_terminate.'));
         return { success: true, data: { swarmId, stopped: true, force } };
     }
 };
@@ -544,88 +638,106 @@ const scaleCommand = {
             output.printError('Target agent count required. Use --agents or -a');
             return { success: false, exitCode: 1 };
         }
-        output.printInfo(`Scaling swarm ${swarmId} to ${targetAgents} agents...`);
-        // Calculate scaling delta
-        const currentAgents = 8;
-        const delta = targetAgents - currentAgents;
-        if (delta > 0) {
-            output.writeln(output.dim(`  Spawning ${delta} new agents...`));
+        // #1428 — same treatment as `start`, for the same structural reason. The
+        // wired `swarm_scale` MCP tool really does call coordinator.spawnAgent /
+        // terminateAgent, but calling it from here would drive a coordinator that
+        // dies with this process: the agents would be spawned and lost between one
+        // command and the next. Pre-fix this computed a delta against a hardcoded
+        // `currentAgents = 8` and announced "Swarm scaled to N agents".
+        const existing = resolveActiveSwarm(swarmId, 'No initialised swarm found.');
+        if (!existing)
+            return { success: false, exitCode: 1 };
+        // The recorded ceiling, which is a real number `init` wrote — not a guess.
+        const previous = existing.maxAgents;
+        if (previous === targetAgents) {
+            output.printInfo(`Recorded agent ceiling is already ${targetAgents}.`);
+            return { success: true, data: { swarmId, agents: targetAgents, changed: false } };
+        }
+        try {
+            writeSwarmState({ ...existing, maxAgents: targetAgents });
         }
-        else if (delta < 0) {
-            output.writeln(output.dim(`  Gracefully stopping ${-delta} agents...`));
+        catch (error) {
+            output.printError(`Failed to record agent ceiling: ${String(error)}`);
+            return { success: false, exitCode: 1 };
         }
-        else {
-            output.printInfo('Swarm already at target size');
-            return { success: true };
+        output.printSuccess(`Recorded agent ceiling for ${swarmId}: ${previous ?? 'unset'} → ${targetAgents}`);
+        output.writeln();
+        output.printInfo('No agents were spawned or terminated by this command.');
+        output.writeln(output.dim('  This records the ceiling a later swarm_init will use. To scale a'));
+        output.writeln(output.dim('  running swarm, call the swarm_scale MCP tool from a Claude Code'));
+        output.writeln(output.dim('  session — that reaches the live coordinator, which this CLI cannot.'));
+        if (agentType) {
+            output.writeln(output.dim(`  --type ${agentType} applies only to live scaling via swarm_scale.`));
         }
-        output.printSuccess(`Swarm scaled to ${targetAgents} agents`);
-        return { success: true, data: { swarmId, agents: targetAgents, delta } };
+        return {
+            success: true,
+            data: { swarmId, agents: targetAgents, previousAgents: previous, changed: true },
+        };
     }
 };
-// Coordinate command (V3 specific)
+/**
+ * The V3 roster `--v3-mode` is designed around. This is reference data, not
+ * observed state: no agent here is running, and nothing reads it back.
+ *
+ * #1428 — it used to carry a per-agent `status` of `primary`/`active`/
+ * `standby`, rendered in colour, which read as live telemetry for agents that
+ * did not exist. The roster itself is real (the topology it describes is what
+ * `swarm init --v3-mode` actually selects), so the fix is to drop the invented
+ * status column rather than the table.
+ */
+const V3_ROSTER = [
+    { id: 1, role: 'Queen Coordinator', domain: 'Orchestration' },
+    { id: 2, role: 'Security Architect', domain: 'Security' },
+    { id: 3, role: 'Security Auditor', domain: 'Security' },
+    { id: 4, role: 'Test Architect', domain: 'Security' },
+    { id: 5, role: 'Core Architect', domain: 'Core' },
+    { id: 6, role: 'Memory Specialist', domain: 'Core' },
+    { id: 7, role: 'Swarm Specialist', domain: 'Core' },
+    { id: 8, role: 'Integration Architect', domain: 'Integration' },
+    { id: 9, role: 'Performance Engineer', domain: 'Integration' },
+    { id: 10, role: 'CLI Developer', domain: 'Integration' },
+    { id: 11, role: 'Hooks Developer', domain: 'Integration' },
+    { id: 12, role: 'MCP Specialist', domain: 'Integration' },
+    { id: 13, role: 'Project Coordinator', domain: 'Management' },
+    { id: 14, role: 'Documentation Lead', domain: 'Management' },
+    { id: 15, role: 'DevOps Engineer', domain: 'Management' },
+];
+// Reference display for the V3 roster. Named `coordinate` for backward
+// compatibility — it coordinates nothing, and no longer claims to.
 const coordinateCommand = {
     name: 'coordinate',
-    description: 'Execute V3 15-agent hierarchical mesh coordination',
+    description: 'Show the V3 15-agent hierarchical-mesh roster (reference only — starts nothing)',
     options: [
         {
             name: 'agents',
-            description: 'Number of agents',
+            description: 'Number of roster entries to show',
             type: 'number',
             default: 15
-        },
-        {
-            name: 'domains',
-            description: 'Domains to activate',
-            type: 'array'
         }
     ],
     action: async (ctx) => {
         const agentCount = ctx.flags.agents || 15;
+        const roster = V3_ROSTER.slice(0, agentCount);
         output.writeln();
-        output.writeln(output.bold('V3 15-Agent Hierarchical Mesh Coordination'));
+        output.writeln(output.bold('V3 Hierarchical-Mesh Roster (reference)'));
+        output.writeln(output.dim('  The layout `flo swarm init --v3-mode` is designed around.'));
         output.writeln();
-        // V3 agent structure
-        const v3Agents = [
-            { id: 1, role: 'Queen Coordinator', domain: 'Orchestration', status: 'primary' },
-            { id: 2, role: 'Security Architect', domain: 'Security', status: 'active' },
-            { id: 3, role: 'Security Auditor', domain: 'Security', status: 'active' },
-            { id: 4, role: 'Test Architect', domain: 'Security', status: 'active' },
-            { id: 5, role: 'Core Architect', domain: 'Core', status: 'active' },
-            { id: 6, role: 'Memory Specialist', domain: 'Core', status: 'active' },
-            { id: 7, role: 'Swarm Specialist', domain: 'Core', status: 'active' },
-            { id: 8, role: 'Integration Architect', domain: 'Integration', status: 'active' },
-            { id: 9, role: 'Performance Engineer', domain: 'Integration', status: 'active' },
-            { id: 10, role: 'CLI Developer', domain: 'Integration', status: 'active' },
-            { id: 11, role: 'Hooks Developer', domain: 'Integration', status: 'active' },
-            { id: 12, role: 'MCP Specialist', domain: 'Integration', status: 'active' },
-            { id: 13, role: 'Project Coordinator', domain: 'Management', status: 'active' },
-            { id: 14, role: 'Documentation Lead', domain: 'Management', status: 'standby' },
-            { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' }
-        ].slice(0, agentCount);
         output.printTable({
             columns: [
                 { key: 'id', header: '#', width: 3, align: 'right' },
                 { key: 'role', header: 'Role', width: 22 },
-                { key: 'domain', header: 'Domain', width: 15 },
-                { key: 'status', header: 'Status', width: 10, format: (v) => {
-                        if (v === 'primary')
-                            return output.highlight(String(v));
-                        if (v === 'active')
-                            return output.success(String(v));
-                        return output.dim(String(v));
-                    } }
+                { key: 'domain', header: 'Domain', width: 15 }
             ],
-            data: v3Agents
+            data: roster
         });
         output.writeln();
-        output.printInfo('Capabilities:');
-        output.printList([
-            `Flash Attention: ${output.success('memory-efficient attention')}`,
-            `AgentDB Search: ${output.success('HNSW (ANN)')}`,
-            `Memory: ${output.success('Int8 quantized')}`,
-            `Code Reduction: ${output.success('<5,000 lines')}`
-        ]);
-        return { success: true, data: { agents: v3Agents, count: agentCount } };
+        output.printInfo('No agents were started, and none are running as a result of this command.');
+        output.writeln(output.dim('  Initialise the topology with: flo swarm init --v3-mode'));
+        output.writeln(output.dim('  Spawn real agents from a Claude Code session with agent_spawn.'));
+        if (ctx.flags.format === 'json') {
+            output.printJson({ roster, count: roster.length });
+        }
+        return { success: true, data: { agents: roster, count: roster.length } };
     }
 };
 // Main swarm command
@@ -637,7 +749,7 @@ export const swarmCommand = {
     examples: [
         { command: 'flo swarm init --v3-mode', description: 'Initialize V3 swarm' },
         { command: 'flo swarm start -o "Build API" -s development', description: 'Start development swarm' },
-        { command: 'flo swarm coordinate --agents 15', description: 'V3 coordination' }
+        { command: 'flo swarm coordinate --agents 15', description: 'Show the V3 roster (reference)' }
     ],
     action: async (ctx) => {
         output.writeln();
@@ -652,7 +764,7 @@ export const swarmCommand = {
             `${output.highlight('status')}      - Show swarm status`,
             `${output.highlight('stop')}        - Stop swarm execution`,
             `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - V3 15-agent coordination`
+            `${output.highlight('coordinate')}  - Show the V3 15-agent roster (reference)`
         ]);
         return { success: true };
     }

package/dist/src/cli/guidance/headless.js

@@ -13,6 +13,7 @@
  *
  * @module moflo/cli/guidance/headless
  */
+import { escapeShellArg, NULL_DEVICE } from '../shared/utils/platform.js';
 /**
  * Default command executor using child_process
  */
@@ -162,14 +163,10 @@ export class HeadlessRunner {
      * Build the Claude Code headless command
      */
     buildCommand(task) {
-        // Escape the prompt for shell safety
-        const nd = process.platform === 'win32' ? 'NUL' : '/dev/null';
-        if (process.platform === 'win32') {
-            const escapedPrompt = task.prompt.replace(/"/g, '\\"');
-            return `claude -p "${escapedPrompt}" --output-format json 2>${nd}`;
-        }
-        const escapedPrompt = task.prompt.replace(/'/g, "'\\''");
-        return `claude -p '${escapedPrompt}' --output-format json 2>${nd}`;
+        // Quoting and the null device both come from platform.ts — this used to
+        // branch on process.platform twice and hand-roll the Windows escape, which
+        // is where the trailing-backslash defect lived (#1419).
+        return `claude -p ${escapeShellArg(task.prompt)} --output-format json 2>${NULL_DEVICE}`;
     }
     /**
      * Parse Claude Code JSON output

package/dist/src/cli/guidance/retriever.js

@@ -303,12 +303,7 @@ export class ShardRetriever {
     matchGlob(path, glob) {
         let re = this.globCache.get(glob);
         if (!re) {
-            const pattern = glob
-                .replace(/\*\*/g, '{{GLOBSTAR}}')
-                .replace(/\*/g, '[^/]*')
-                .replace(/{{GLOBSTAR}}/g, '.*')
-                .replace(/\//g, '\\/');
-            re = new RegExp(`^${pattern}$`);
+            re = globToRegExp(glob);
             this.globCache.set(glob, re);
         }
         return re.test(path);
@@ -348,4 +343,30 @@ export class ShardRetriever {
 export function createRetriever(embeddingProvider) {
     return new ShardRetriever(embeddingProvider);
 }
+/**
+ * Compile a repo-scope glob (`*`, `**`) into an anchored regex.
+ *
+ * Metacharacters are escaped FIRST, then the wildcards are substituted. Without
+ * the escape a glob containing `.`, `+`, `(` or `[` either matched the wrong
+ * thing — `docs/*.md` happily matching `docsXmd`, because the `.` was a
+ * wildcard — or threw from `new RegExp` on an unbalanced bracket. Guidance
+ * scopes carry `.md` routinely, so the silent-mismatch case was the live one
+ * (#1419).
+ *
+ * `*` is left unescaped so the substitutions can still see it. The
+ * `{{GLOBSTAR}}` placeholder cannot collide with a literal `{{GLOBSTAR}}` in the
+ * input because that input has already had its braces escaped to `\{\{…\}\}` by
+ * the time the placeholder is inserted.
+ *
+ * Exported for direct testing: the only caller is a private method reachable
+ * solely through a fully-loaded retriever.
+ */
+export function globToRegExp(glob) {
+    const pattern = glob
+        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '{{GLOBSTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+    return new RegExp(`^${pattern}$`);
+}
 //# sourceMappingURL=retriever.js.map

package/dist/src/cli/guidance/ruvbot-integration.js

@@ -16,6 +16,7 @@
  *
  * @module moflo/cli/guidance/ruvbot-integration
  */
+import { generateId } from '../shared/utils/id.js';
 // ============================================================================
 // Severity Mapping
 // ============================================================================
@@ -587,7 +588,7 @@ export class RuvBotGuidanceBridge {
      */
     async handleSessionCreate(...args) {
         const data = (args[0] ?? {});
-        const sessionId = String(data['sessionId'] ?? data['id'] ?? `session-${Date.now()}`);
+        const sessionId = String(data['sessionId'] ?? data['id'] ?? generateId('session'));
         this.logEvent('session:create', { sessionId });
         if (this.config.enableProofChain) {
             if (!this.config.proofSigningKey) {

package/dist/src/cli/guidance/uncertainty.js

@@ -24,6 +24,7 @@
  * @module moflo/cli/guidance/uncertainty
  */
 import { randomUUID } from 'node:crypto';
+import { generateId } from '../shared/utils/id.js';
 // ============================================================================
 // Default Configuration
 // ============================================================================
@@ -294,7 +295,7 @@ export class UncertaintyLedger {
         }
         // Record the resolution as evidence
         const resolutionEvidence = {
-            sourceId: `resolution:${beliefId}:${Date.now()}`,
+            sourceId: generateId(`resolution:${beliefId}`, { separator: ':' }),
             sourceType: 'human-input',
             supports: status === 'confirmed',
             weight: 1.0,

package/dist/src/cli/hooks/bridge/official-hooks-bridge.js

@@ -8,6 +8,7 @@
  * @module v3/hooks/bridge/official-hooks-bridge
  */
 import { HookEvent } from '../types.js';
+import { generateId } from '../../shared/utils/id.js';
 /**
  * Mapping from V3 HookEvent to Official hook events
  */
@@ -100,7 +101,7 @@ export class OfficialHooksBridge {
         // Add task information for Task tool
         if (input.tool_name === 'Task') {
             context.task = {
-                id: `task-${Date.now()}`,
+                id: generateId('task'),
                 description: input.tool_input?.prompt ?? '',
                 agent: input.tool_input?.subagent_type,
             };

package/dist/src/cli/hooks/mcp/index.js

@@ -4,6 +4,7 @@
  * MCP tool definitions for hooks system integration.
  * These tools provide programmatic access to hooks functionality.
  */
+import { generateId } from '../../shared/utils/id.js';
 /**
  * Pre-edit hook MCP tool
  */
@@ -110,7 +111,7 @@ export const postEditTool = {
             success,
             recorded: true,
             recordedAt: new Date().toISOString(),
-            patternId: success ? `pattern-${Date.now()}` : undefined,
+            patternId: success ? generateId('pattern') : undefined,
         };
     },
 };
@@ -314,7 +315,7 @@ export const postCommandTool = {
         const success = input.success;
         return {
             recorded: true,
-            patternId: success ? `cmd-${Date.now()}` : undefined,
+            patternId: success ? generateId('cmd') : undefined,
         };
     },
 };

package/dist/src/cli/hooks/reasoningbank/index.js

@@ -15,6 +15,7 @@
 import { EventEmitter } from 'node:events';
 import { TestDeterministicEmbedding } from './__mocks__/test-embedding-service.js';
 import { MEMORY_DB_FILE, MOFLO_DIR } from '../../services/moflo-paths.js';
+import { generateId } from '../../shared/utils/id.js';
 // Dynamic imports for optional dependencies
 let MofloDbAdapter = null;
 let HNSWIndex = null;
@@ -244,7 +245,7 @@ export class ReasoningBank extends EventEmitter {
         }
         // Create new pattern
         const pattern = {
-            id: `pat_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            id: generateId('pat', { separator: '_' }),
             strategy,
             domain,
             embedding,

package/dist/src/cli/hooks/registry/index.js

@@ -4,6 +4,7 @@
  * Central registry for hook registration, management, and lookup.
  * Provides priority-based execution ordering and filtering.
  */
+import { generateId } from '../../shared/utils/id.js';
 /**
  * Hook Registry - manages hook registration and lookup
  */
@@ -189,7 +190,7 @@ export class HookRegistry {
      * Generate unique hook ID
      */
     generateId() {
-        return `hook-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        return generateId('hook');
     }
 }
 /**