@lumenflow/cli 2.1.1 → 2.2.0

package/dist/init-plan.d.ts

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+/**
+ * Init Plan Command (WU-1105)
+ *
+ * Links plan files to initiatives by setting the `related_plan` field
+ * in the initiative YAML.
+ *
+ * Usage:
+ *   pnpm init:plan --initiative INIT-001 --plan docs/04-operations/plans/my-plan.md
+ *   pnpm init:plan --initiative INIT-001 --create  # Create new plan template
+ *
+ * Features:
+ * - Validates initiative exists before modifying
+ * - Formats plan path as lumenflow:// URI
+ * - Idempotent: no error if same plan already linked
+ * - Warns if replacing existing plan link
+ * - Can create plan templates with --create
+ *
+ * Context: WU-1105 (INIT-003 Phase 3a: Migrate init:plan command)
+ */
+import { readInitiative } from '@lumenflow/initiatives/dist/initiative-yaml.js';
+/** Log prefix for console output */
+export declare const LOG_PREFIX: string;
+/**
+ * Validate Initiative ID format
+ * @param id - Initiative ID to validate
+ * @throws Error if format is invalid
+ */
+export declare function validateInitIdFormat(id: string): void;
+/**
+ * Validate plan file path
+ * @param planPath - Path to plan file
+ * @throws Error if path is invalid or file doesn't exist
+ */
+export declare function validatePlanPath(planPath: string): void;
+/**
+ * Format plan path as lumenflow:// URI
+ *
+ * Extracts the filename (and any subdirectory within plans/) and creates
+ * a standardized URI for the plan reference.
+ *
+ * @param planPath - Path to plan file (can be relative or absolute)
+ * @returns lumenflow://plans/<filename> URI
+ */
+export declare function formatPlanUri(planPath: string): string;
+/**
+ * Check if initiative exists and return the document
+ * @param initId - Initiative ID to check
+ * @returns Initiative document
+ * @throws Error if initiative not found
+ */
+export declare function checkInitiativeExists(initId: string): ReturnType<typeof readInitiative>;
+/**
+ * Update initiative with plan reference in micro-worktree
+ *
+ * Uses raw YAML parsing to preserve unknown fields like related_plan
+ * that are not in the strict initiative schema.
+ *
+ * @param worktreePath - Path to micro-worktree
+ * @param initId - Initiative ID
+ * @param planUri - Plan URI to set
+ * @returns True if changes were made, false if already linked
+ */
+export declare function updateInitiativeWithPlan(worktreePath: string, initId: string, planUri: string): boolean;
+/**
+ * Create a plan template file
+ *
+ * @param worktreePath - Path to repo root or worktree
+ * @param initId - Initiative ID
+ * @param title - Initiative title
+ * @returns Path to created file
+ * @throws Error if file already exists
+ */
+export declare function createPlanTemplate(worktreePath: string, initId: string, title: string): string;
+/**
+ * Generate commit message for plan link operation
+ */
+export declare function getCommitMessage(initId: string, planUri: string): string;
+declare function main(): Promise<void>;
+export { main };

package/dist/init.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @file init.ts
+ * LumenFlow project scaffolding command (WU-1045)
+ * WU-1006: Library-First - use core defaults for config generation
+ * WU-1028: Vendor-agnostic core + vendor overlays
+ * WU-1085: Added createWUParser for proper --help support
+ */
+/**
+ * WU-1085: Parse init command options using createWUParser
+ * Provides proper --help, --version, and option parsing
+ */
+export declare function parseInitOptions(): {
+    force: boolean;
+    full: boolean;
+    framework?: string;
+    vendor?: VendorType;
+    preset?: GatePresetType;
+};
+/**
+ * Supported vendor integrations
+ */
+export type VendorType = 'claude' | 'cursor' | 'aider' | 'all' | 'none';
+export type DefaultClient = 'claude-code' | 'none';
+export type GatePresetType = 'node' | 'python' | 'go' | 'rust' | 'dotnet';
+export interface ScaffoldOptions {
+    force: boolean;
+    full: boolean;
+    framework?: string;
+    vendor?: VendorType;
+    defaultClient?: DefaultClient;
+    /** WU-1067: Gate preset to populate in gates.execution */
+    gatePreset?: GatePresetType;
+}
+export interface ScaffoldResult {
+    created: string[];
+    skipped: string[];
+}
+/**
+ * Scaffold a new LumenFlow project
+ */
+export declare function scaffoldProject(targetDir: string, options: ScaffoldOptions): Promise<ScaffoldResult>;
+/**
+ * CLI entry point
+ * WU-1085: Updated to use parseInitOptions for proper --help support
+ */
+export declare function main(): Promise<void>;

package/dist/initiative-add-wu.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * Initiative Add WU Command (WU-1389)
+ *
+ * Links an existing WU to an initiative bidirectionally:
+ * 1. Adds `initiative: INIT-NNN` field to WU YAML
+ * 2. Adds WU ID to initiative `wus: []` array
+ *
+ * Uses micro-worktree isolation for atomic operations.
+ *
+ * Usage:
+ *   pnpm initiative:add-wu --initiative INIT-001 --wu WU-123
+ *
+ * Features:
+ * - Validates both WU and initiative exist before modifying
+ * - Idempotent: no error if link already exists
+ * - Errors if WU is already linked to a different initiative
+ * - Atomic: both files updated in single commit
+ *
+ * Context: WU-1389 (initial implementation)
+ */
+export {};

package/dist/initiative-bulk-assign-wus.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Initiative Bulk Assign WUs CLI (WU-1018)
+ *
+ * Bulk-assigns orphaned WUs to initiatives based on lane prefix rules.
+ * Uses micro-worktree isolation for race-safe commits.
+ *
+ * Usage:
+ *   pnpm initiative:bulk-assign                              # Dry-run (default)
+ *   LUMENFLOW_ADMIN=1 pnpm initiative:bulk-assign --apply    # Apply changes
+ *   pnpm initiative:bulk-assign --config custom-config.yaml  # Custom config
+ *   pnpm initiative:bulk-assign --reconcile-initiative INIT-001
+ *
+ * @module initiative-bulk-assign-wus
+ */
+export {};

package/dist/initiative-create.d.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+/**
+ * Initiative Create Helper (WU-1247, WU-1439)
+ *
+ * Race-safe Initiative creation using micro-worktree isolation.
+ *
+ * Canonical sequence:
+ * 1) Validate inputs (id, slug, title)
+ * 2) Ensure on main branch
+ * 3) Use micro-worktree to atomically:
+ *    a) Create temp branch without switching main checkout
+ *    b) Create INIT-{id}.yaml in micro-worktree
+ *    c) Commit with "docs: create init-{id} for <title>" message
+ *    d) Merge to main with ff-only (retry with rebase if needed)
+ *    e) Push to origin/main
+ *    f) Cleanup temp branch and micro-worktree
+ *
+ * Benefits:
+ * - Main checkout never modified (no impact on other agents)
+ * - Race conditions handled via rebase+retry (up to 3 attempts)
+ * - Cleanup guaranteed even on failure
+ *
+ * Usage:
+ *   pnpm initiative:create --id INIT-001 --slug shock-protocol --title "Shock Protocol Implementation"
+ *
+ * Context: WU-1247 (original implementation), WU-1439 (micro-worktree migration)
+ */
+export {};

package/dist/initiative-edit.d.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Initiative Edit Helper
+ *
+ * Race-safe Initiative editing using micro-worktree isolation (WU-1451).
+ *
+ * Enables editing Initiative YAML files with atomic commits, perfect for:
+ * - Updating initiative status
+ * - Setting blocked_by and blocked_reason
+ * - Unblocking initiatives
+ * - Adding lanes
+ * - Appending notes
+ * - Fixing malformed created dates (WU-2547)
+ *
+ * Uses the micro-worktree pattern with pushOnly mode (WU-1435):
+ * 1) Validate inputs (Initiative exists, status is valid enum)
+ * 2) Ensure main is clean and up-to-date with origin
+ * 3) Create temp branch WITHOUT switching (main checkout stays on main)
+ * 4) Create micro-worktree in /tmp pointing to temp branch
+ * 5) Apply edits in micro-worktree
+ * 6) Commit, push directly to origin/main
+ * 7) Cleanup temp branch and micro-worktree
+ *
+ * Usage:
+ *   pnpm initiative:edit --id INIT-001 --status in_progress
+ *   pnpm initiative:edit --id INIT-001 --blocked-by INIT-002 --blocked-reason "Waiting for Phase 1"
+ *   pnpm initiative:edit --id INIT-001 --unblock
+ *   pnpm initiative:edit --id INIT-001 --add-lane "Operations: Tooling"
+ *   pnpm initiative:edit --id INIT-001 --notes "Phase 2 started"
+ *
+ * Part of WU-1451: Add initiative:edit command for updating initiative status and blockers
+ * @see {@link tools/lib/micro-worktree.mjs} - Shared micro-worktree logic
+ */
+export {};

package/dist/initiative-list.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Initiative List Helper (WU-1247)
+ *
+ * Lists all initiatives with progress percentages.
+ *
+ * Usage:
+ *   pnpm initiative:list                    # Table format
+ *   pnpm initiative:list --format json      # JSON format
+ *   pnpm initiative:list --status open      # Filter by status
+ */
+export {};

package/dist/initiative-status.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Initiative Status Helper (WU-1247)
+ *
+ * Shows detailed initiative view with phases and WUs.
+ *
+ * Usage:
+ *   pnpm initiative:status INIT-001
+ *   pnpm initiative:status --id INIT-001 --format json
+ */
+export {};

package/dist/lumenflow-upgrade.d.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * LumenFlow Upgrade CLI Command
+ *
+ * Updates all @lumenflow/* packages to a specified version or latest.
+ * Uses micro-worktree pattern for atomic changes to main without requiring
+ * users to be in a worktree.
+ *
+ * WU-1112: INIT-003 Phase 6 - Migrate remaining Tier 1 tools
+ * WU-1127: Use micro-worktree isolation pattern (fixes user blocking issue)
+ *
+ * Key requirements:
+ * - Uses micro-worktree pattern (atomic changes, no user worktree needed)
+ * - Runs from main checkout (not inside a worktree)
+ * - Checks all 7 @lumenflow/* packages
+ *
+ * Usage:
+ *   pnpm lumenflow:upgrade --version 1.5.0
+ *   pnpm lumenflow:upgrade --latest
+ *   pnpm lumenflow:upgrade --latest --dry-run
+ */
+/**
+ * All @lumenflow/* packages that should be upgraded together
+ *
+ * WU-1112: Must include all 7 packages (not just 4 as before)
+ * Kept in alphabetical order for consistency
+ */
+export declare const LUMENFLOW_PACKAGES: readonly ["@lumenflow/agent", "@lumenflow/cli", "@lumenflow/core", "@lumenflow/initiatives", "@lumenflow/memory", "@lumenflow/metrics", "@lumenflow/shims"];
+/**
+ * Arguments for lumenflow-upgrade command
+ */
+export interface UpgradeArgs {
+    /** Specific version to upgrade to (e.g., '1.5.0') */
+    version?: string;
+    /** Upgrade to latest version */
+    latest?: boolean;
+    /** Dry run - show commands without executing */
+    dryRun?: boolean;
+    /** Show help */
+    help?: boolean;
+}
+/**
+ * Result of building upgrade commands
+ */
+export interface UpgradeResult {
+    /** The pnpm add command to run */
+    addCommand: string;
+    /** Version specifier used */
+    versionSpec: string;
+}
+/**
+ * Result of main checkout validation
+ */
+export interface MainCheckoutValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error message if validation failed */
+    error?: string;
+    /** Suggested fix command */
+    fixCommand?: string;
+}
+/**
+ * Parse command line arguments for lumenflow-upgrade
+ *
+ * @param argv - Process argv array
+ * @returns Parsed arguments
+ */
+export declare function parseUpgradeArgs(argv: string[]): UpgradeArgs;
+/**
+ * Build the upgrade commands based on arguments
+ *
+ * Creates pnpm add command for all @lumenflow/* packages.
+ * Uses --save-dev since these are development dependencies.
+ *
+ * @param args - Parsed upgrade arguments
+ * @returns Object containing the commands to run
+ */
+export declare function buildUpgradeCommands(args: UpgradeArgs): UpgradeResult;
+/**
+ * WU-1127: Validate that the command is run from main checkout
+ *
+ * The micro-worktree pattern requires the command to be run from the main
+ * checkout (not inside a worktree). This is the inverse of the old behavior
+ * which required users to be IN a worktree.
+ *
+ * @returns Validation result with error and fix command if invalid
+ */
+export declare function validateMainCheckout(): Promise<MainCheckoutValidationResult>;
+/**
+ * WU-1127: Execute the upgrade in a micro-worktree
+ *
+ * Uses the shared micro-worktree pattern (like wu:create, wu:edit) to:
+ * 1. Create a temporary worktree without switching main checkout
+ * 2. Run pnpm add in the temporary worktree
+ * 3. Commit the changes
+ * 4. FF-only merge to main
+ * 5. Push to origin
+ * 6. Cleanup
+ *
+ * @param args - Parsed upgrade arguments
+ * @returns Promise resolving when upgrade is complete
+ */
+export declare function executeUpgradeInMicroWorktree(args: UpgradeArgs): Promise<void>;

package/dist/mem-checkpoint.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Memory Checkpoint CLI (WU-1467)
+ *
+ * Create a checkpoint node for context snapshots.
+ * Used before /clear or session handoff to preserve progress state.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * Usage:
+ *   pnpm mem:checkpoint 'note' [--session <id>] [--wu <id>] [--progress <text>] [--next-steps <text>] [--trigger <type>] [--quiet]
+ *
+ * @see {@link tools/lib/mem-checkpoint-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-checkpoint.test.mjs} - Tests
+ */
+export {};

package/dist/mem-cleanup.d.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Memory Cleanup CLI (WU-1472, WU-1554)
+ *
+ * Prune closed memory nodes based on lifecycle policy and TTL.
+ * Implements compaction to prevent memory bloat.
+ *
+ * Features:
+ * - Remove ephemeral nodes (always discarded)
+ * - Remove session nodes when session is closed
+ * - Archive summarized nodes (marked with summarized_into)
+ * - Respect sensitive:true flag for stricter retention
+ * - Support dry-run mode for preview
+ * - Report compaction metrics (ratio, bytes freed)
+ * - WU-1554: TTL-based expiration (e.g., --ttl 30d)
+ * - WU-1554: Active session protection (never removed)
+ *
+ * Usage:
+ *   pnpm mem:cleanup                          # Cleanup based on lifecycle policy
+ *   pnpm mem:cleanup --dry-run                # Preview without changes
+ *   pnpm mem:cleanup --ttl 30d                # Remove nodes older than 30 days
+ *   pnpm mem:cleanup --ttl 7d --dry-run       # Preview TTL cleanup
+ *   pnpm mem:cleanup --session-id <uuid>      # Close specific session
+ *   pnpm mem:cleanup --json                   # Output as JSON
+ *
+ * @see {@link tools/lib/mem-cleanup-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-cleanup.test.mjs} - Tests
+ */
+export {};

package/dist/mem-create.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Memory Create CLI (WU-1469)
+ *
+ * Create memory nodes with discovered-from provenance.
+ * KEY DIFFERENTIATOR: supports discovered-from relationship for scope-creep
+ * forensics. Creates audit trail of WHY work expanded, not just WHAT changed.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * Usage:
+ *   pnpm mem:create 'title' [--type <type>] [--discovered-from <id>] [--wu <id>] [--quiet]
+ *
+ * @see {@link tools/lib/mem-create-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-create.test.mjs} - Tests
+ */
+export {};

package/dist/mem-export.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Memory Export CLI (WU-1137)
+ *
+ * Render memory.jsonl as markdown or JSON with basic filters.
+ *
+ * Usage:
+ *   pnpm mem:export [--wu WU-1234] [--type <type>] [--lifecycle <lifecycle>] [--format <markdown|json>] [--quiet]
+ */
+export {};

package/dist/mem-export.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+/**
+ * Memory Export CLI (WU-1137)
+ *
+ * Render memory.jsonl as markdown or JSON with basic filters.
+ *
+ * Usage:
+ *   pnpm mem:export [--wu WU-1234] [--type <type>] [--lifecycle <lifecycle>] [--format <markdown|json>] [--quiet]
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exportMemory } from '@lumenflow/memory/dist/mem-export-core.js';
+import { MEMORY_NODE_TYPES } from '@lumenflow/memory/dist/memory-schema.js';
+import { createWUParser, WU_OPTIONS } from '@lumenflow/core/dist/arg-parser.js';
+import { EXIT_CODES, LUMENFLOW_PATHS } from '@lumenflow/core/dist/wu-constants.js';
+const LOG_PREFIX = '[mem:export]';
+const TOOL_NAME = 'mem:export';
+const CLI_OPTIONS = {
+    type: {
+        name: 'type',
+        flags: '-t, --type <type>',
+        description: `Filter by node type (${MEMORY_NODE_TYPES.join(', ')})`,
+    },
+    lifecycle: {
+        name: 'lifecycle',
+        flags: '-l, --lifecycle <lifecycle>',
+        description: 'Filter by lifecycle (ephemeral, session, wu, project)',
+    },
+    format: {
+        name: 'format',
+        flags: '-f, --format <format>',
+        description: 'Output format (markdown, json). Default: markdown',
+    },
+    baseDir: {
+        name: 'baseDir',
+        flags: '-d, --base-dir <path>',
+        description: 'Base directory (defaults to current directory)',
+    },
+    quiet: {
+        name: 'quiet',
+        flags: '-q, --quiet',
+        description: 'Suppress header/footer output',
+    },
+};
+async function writeAuditLog(baseDir, entry) {
+    try {
+        const logPath = path.join(baseDir, LUMENFLOW_PATHS.AUDIT_LOG);
+        const logDir = path.dirname(logPath);
+        await fs.mkdir(logDir, { recursive: true });
+        await fs.appendFile(logPath, `${JSON.stringify(entry)}\n`, 'utf-8');
+    }
+    catch {
+        // Non-fatal
+    }
+}
+function validateFormat(format) {
+    return format === 'markdown' || format === 'json';
+}
+function validateLifecycle(lifecycle) {
+    return ['ephemeral', 'session', 'wu', 'project'].includes(lifecycle);
+}
+async function main() {
+    const args = createWUParser({
+        name: 'mem-export',
+        description: 'Export memory nodes as markdown or JSON',
+        options: [
+            WU_OPTIONS.wu,
+            CLI_OPTIONS.type,
+            CLI_OPTIONS.lifecycle,
+            CLI_OPTIONS.format,
+            CLI_OPTIONS.baseDir,
+            CLI_OPTIONS.quiet,
+        ],
+        required: [],
+    });
+    const baseDir = args.baseDir || process.cwd();
+    const format = args.format || 'markdown';
+    const startedAt = new Date().toISOString();
+    const startTime = Date.now();
+    if (!validateFormat(format)) {
+        console.error(`${LOG_PREFIX} Error: Invalid format "${format}". Use "markdown" or "json".`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (args.type && !MEMORY_NODE_TYPES.includes(args.type)) {
+        console.error(`${LOG_PREFIX} Error: Invalid type "${args.type}". Valid types: ${MEMORY_NODE_TYPES.join(', ')}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (args.lifecycle && !validateLifecycle(args.lifecycle)) {
+        console.error(`${LOG_PREFIX} Error: Invalid lifecycle "${args.lifecycle}". Valid values: ephemeral, session, wu, project`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let error = null;
+    let output = '';
+    try {
+        const result = await exportMemory(baseDir, {
+            wuId: args.wu,
+            type: args.type,
+            lifecycle: args.lifecycle,
+            format,
+        });
+        output = result.output;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+    }
+    const durationMs = Date.now() - startTime;
+    await writeAuditLog(baseDir, {
+        tool: TOOL_NAME,
+        status: error ? 'failed' : 'success',
+        startedAt,
+        completedAt: new Date().toISOString(),
+        durationMs,
+        input: {
+            baseDir,
+            wuId: args.wu ?? null,
+            type: args.type ?? null,
+            lifecycle: args.lifecycle ?? null,
+            format,
+        },
+        error,
+    });
+    if (error) {
+        console.error(`${LOG_PREFIX} Error: ${error}`);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (!args.quiet) {
+        console.log(`${LOG_PREFIX} Export (${format})`);
+        console.log('');
+    }
+    process.stdout.write(output);
+    if (!output.endsWith('\n')) {
+        process.stdout.write('\n');
+    }
+}
+main().catch((err) => {
+    console.error(`${LOG_PREFIX} Unexpected error:`, err);
+    process.exit(EXIT_CODES.ERROR);
+});

package/dist/mem-inbox.d.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * Memory Inbox CLI (WU-1474)
+ *
+ * Read coordination signals from other agents for real-time awareness
+ * of parallel agent progress. Filter by lane, WU, or time range.
+ * Supports watch mode for continuous monitoring.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * WU-2202: Added dependency validation before operations to prevent silent
+ * failures when node_modules is corrupted or incomplete.
+ *
+ * Usage:
+ *   pnpm mem:inbox [--lane <name>] [--wu <id>] [--since <time>] [--watch]
+ *
+ * @see {@link tools/lib/mem-signal-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-inbox.test.mjs} - Tests
+ */
+/**
+ * Format signal count for --count flag output
+ * WU-2401: Lightweight polling for orchestrators
+ *
+ * @param {number} count - Number of unread signals
+ * @returns {string} Formatted count string
+ */
+export declare function formatCount(count: any): string;
+/**
+ * Parse relative time string to Date object
+ * WU-1849: Replaced custom regex with ms package
+ *
+ * @param {string} timeStr - Time string like "1h", "30m", "2d", or ISO date
+ * @returns {Date} Parsed date
+ */
+export declare function parseTimeString(timeStr: any): Date;

package/dist/mem-init.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Memory Init CLI (WU-1464)
+ *
+ * Initialize memory layer in the repository.
+ * Creates .lumenflow/memory/ directory with memory.jsonl and config.yaml.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * Usage:
+ *   pnpm mem:init [--base-dir <path>] [--quiet]
+ *
+ * @see {@link tools/lib/mem-init-core.mjs} - Core logic
+ */
+export {};

package/dist/mem-ready.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Memory Ready CLI (WU-1468)
+ *
+ * Deterministic ready-work query for "what next?" oracle.
+ * Returns unblocked open nodes, ordered by priority then createdAt.
+ *
+ * Usage:
+ *   pnpm mem:ready --wu WU-1234 [--type <type>] [--format <json|human>] [--quiet]
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * @see {@link tools/lib/mem-ready-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-ready.test.mjs} - Tests
+ */
+export {};

package/dist/mem-signal.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Memory Signal CLI (WU-1473)
+ *
+ * Send coordination signals between parallel agents for sub-100ms
+ * multi-agent swarm coordination without git sync latency.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * Usage:
+ *   pnpm mem:signal 'message' [--wu <id>] [--lane <name>] [--quiet]
+ *
+ * @see {@link tools/lib/mem-signal-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-signal.test.mjs} - Tests
+ */
+export {};

package/dist/mem-start.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Memory Start CLI (WU-1466)
+ *
+ * Create a session node linked to a WU.
+ * Called by wu:claim enhancement for context restoration after /clear.
+ *
+ * Includes audit logging to .lumenflow/telemetry/tools.ndjson.
+ *
+ * Usage:
+ *   pnpm mem:start --wu WU-1234 [--agent-type <type>] [--context-tier <tier>] [--quiet]
+ *
+ * @see {@link tools/lib/mem-start-core.mjs} - Core logic
+ * @see {@link tools/__tests__/mem-start.test.mjs} - Tests
+ */
+export {};