@ghl-ai/aw 0.1.37-beta.43 → 0.1.37-beta.44

package/commands/memory.mjs

@@ -1,16 +1,132 @@
 // commands/memory.mjs — `aw memory [store|search|pack|stats|validate|invalidate|sync|audit|review|promote]`
 
 import { join } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, writeFileSync, readdirSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { confirm, isCancel } from '@clack/prompts';
+import { confirm, isCancel, text } from '@clack/prompts';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { callMemoryTool } from '../memory-bridge.mjs';
 import { syncMemories } from '../memory-sync.mjs';
 import { REGISTRY_DIR } from '../constants.mjs';
+import { getQueueStats } from '../memory-queue.mjs';
+
+// ── legacy import ─────────────────────────────────────────────────────
+
+/**
+ * One-time import of learned skills from ~/.claude/skills/learned/*.md
+ * into the memory system. Runs silently if nothing to import.
+ */
+async function checkAndRunLegacyImport() {
+  const awDir = join(homedir(), '.aw');
+  const flagFile = join(awDir, 'memory-migrated');
+
+  // Already migrated — bail immediately
+  if (existsSync(flagFile)) return;
+
+  const skillsDir = join(homedir(), '.claude', 'skills', 'learned');
+
+  // No skills directory — mark as migrated and bail
+  if (!existsSync(skillsDir)) {
+    mkdirSync(awDir, { recursive: true });
+    writeFileSync(flagFile, JSON.stringify({ migrated_at: new Date().toISOString(), count: 0, skipped: 0 }, null, 2));
+    return;
+  }
+
+  let files;
+  try {
+    files = readdirSync(skillsDir).filter(f => f.endsWith('.md'));
+  } catch {
+    return; // Can't read directory — skip silently
+  }
+
+  // No .md files found — mark as migrated and bail
+  if (files.length === 0) {
+    mkdirSync(awDir, { recursive: true });
+    writeFileSync(flagFile, JSON.stringify({ migrated_at: new Date().toISOString(), count: 0, skipped: 0 }, null, 2));
+    return;
+  }
+
+  const s = fmt.spinner();
+  s.start(`Importing learned skills... 0/${files.length}`);
+
+  let imported = 0;
+  let skipped = 0;
+
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    try {
+      const raw = readFileSync(join(skillsDir, file), 'utf8');
+
+      // Parse YAML frontmatter
+      const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+      let description = '';
+      let body = '';
+
+      if (fmMatch) {
+        const frontmatter = fmMatch[1];
+        body = fmMatch[2].trim();
+
+        // Extract name and description from frontmatter
+        for (const line of frontmatter.split('\n')) {
+          const kvMatch = line.match(/^(\w+):\s*(.+)$/);
+          if (kvMatch) {
+            const [, key, value] = kvMatch;
+            if (key === 'description') {
+              description = value.replace(/^["']|["']$/g, '').trim();
+            } else if (key === 'name' && !description) {
+              description = value.replace(/^["']|["']$/g, '').trim();
+            }
+          }
+        }
+      } else {
+        // No frontmatter — use entire content as body
+        body = raw.trim();
+      }
+
+      // Build content: description + body, truncated to 1000 chars
+      const content = ((description ? description + '\n\n' : '') + body).slice(0, 1000);
+
+      if (!content) {
+        skipped++;
+        continue;
+      }
+
+      await callMemoryTool('memory_store', {
+        content,
+        type: 'learning',
+        source: 'legacy-import',
+        curate: true,
+        confidence: 0.6,
+      });
+
+      imported++;
+    } catch (err) {
+      skipped++;
+      fmt.logWarn(`Skipped ${file}: ${err.message}`);
+    }
+
+    s.message = `Importing learned skills... ${i + 1}/${files.length}`;
+  }
+
+  s.stop(`Imported ${imported} learned skill${imported !== 1 ? 's' : ''}`);
+
+  if (imported > 0 || skipped > 0) {
+    fmt.logStep(`Imported ${imported} learned skills as memories${skipped > 0 ? ` (${skipped} skipped)` : ''}`);
+  }
+
+  // Write flag file
+  mkdirSync(awDir, { recursive: true });
+  writeFileSync(flagFile, JSON.stringify({
+    migrated_at: new Date().toISOString(),
+    count: imported,
+    skipped,
+  }, null, 2));
+}
 
 export async function memoryCommand(args) {
+  await checkAndRunLegacyImport();
+
   const sub = args._positional?.[0];
   switch (sub) {
     case 'store':      return memoryStore(args);
@@ -21,9 +137,10 @@ export async function memoryCommand(args) {
     case 'invalidate': return memoryInvalidate(args);
     case 'sync':       return memorySync(args);
     case 'audit':      return memoryAudit(args);
-    case 'review':     return memoryReview(args);
-    case 'promote':    return memoryPromote(args);
-    default:           return memoryHelp();
+    case 'review':         return memoryReview(args);
+    case 'promote':        return memoryPromote(args);
+    case 'scope-promote':  return memoryScopePromote(args);
+    default:               return memoryHelp();
   }
 }
 
@@ -219,6 +336,17 @@ async function memoryStats(args) {
     }
 
     fmt.logStep(`Total memories: ${chalk.bold(stats.total ?? 0)}`);
+
+    // Show offline queue stats if there are pending items
+    const queueStats = getQueueStats();
+    if (queueStats.pending > 0) {
+      const queueLines = [
+        `  ${chalk.yellow('Pending:'.padEnd(20))} ${queueStats.pending}`,
+        queueStats.oldest ? `  ${chalk.dim('Oldest:'.padEnd(20))} ${formatTimeAgo(queueStats.oldest)}` : null,
+      ].filter(Boolean).join('\n');
+      fmt.note(queueLines, 'Offline Queue');
+    }
+
     fmt.outro('Stats complete');
   } catch (err) {
     s.stop(chalk.red('Failed'));
@@ -226,6 +354,19 @@ async function memoryStats(args) {
   }
 }
 
+/** Format an ISO timestamp as a human-readable "time ago" string. */
+function formatTimeAgo(isoString) {
+  const diff = Date.now() - new Date(isoString).getTime();
+  const seconds = Math.floor(diff / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
 // ── validate ──────────────────────────────────────────────────────────
 
 async function memoryValidate(args) {
@@ -505,6 +646,7 @@ async function memoryReview(args) {
 
     let validated = 0;
     let invalidated = 0;
+    let reclassified = 0;
     let skipped = 0;
 
     for (let i = 0; i < needsReview.length; i++) {
@@ -531,6 +673,7 @@ async function memoryReview(args) {
         options: [
           { value: 'confirm', label: 'Confirm', hint: 'validate this memory' },
           { value: 'invalidate', label: 'Invalidate', hint: 'mark as invalid' },
+          { value: 'reclassify', label: 'Reclassify', hint: 'change layer/overlay/angle' },
           { value: 'skip', label: 'Skip', hint: 'move to next' },
           { value: 'quit', label: 'Quit review', hint: 'stop reviewing' },
         ],
@@ -552,6 +695,26 @@ async function memoryReview(args) {
         continue;
       }
 
+      if (action === 'reclassify') {
+        try {
+          const newClass = await promptReclassify(mem);
+          if (newClass) {
+            await callMemoryTool('memory_update', {
+              memory_id: mem.id,
+              ...newClass,
+            });
+            reclassified++;
+            fmt.logSuccess(`Memory ${mem.id.slice(0, 8)} reclassified → ${newClass.layer || '-'}/${(newClass.overlay || []).join(',')}/${(newClass.angle || []).join(',')}`);
+          } else {
+            skipped++;
+          }
+        } catch (err) {
+          fmt.logError(`Reclassify failed for ${mem.id.slice(0, 8)}: ${err.message}`);
+          skipped++;
+        }
+        continue;
+      }
+
       const feedbackType = action === 'confirm' ? 'validate' : 'invalidate';
 
       try {
@@ -575,9 +738,10 @@ async function memoryReview(args) {
     }
 
     const summaryLines = [
-      `  ${chalk.green('Validated:')}    ${validated}`,
-      `  ${chalk.red('Invalidated:')}  ${invalidated}`,
-      `  ${chalk.dim('Skipped:')}      ${skipped}`,
+      `  ${chalk.green('Validated:')}      ${validated}`,
+      `  ${chalk.red('Invalidated:')}    ${invalidated}`,
+      `  ${chalk.blue('Reclassified:')}   ${reclassified}`,
+      `  ${chalk.dim('Skipped:')}        ${skipped}`,
     ].join('\n');
     fmt.note(summaryLines, 'Review Summary');
     fmt.outro('Review complete');
@@ -822,6 +986,218 @@ function buildPromoteContent(pattern, projectName) {
   return parts.join(' ');
 }
 
+// ── reclassify helper ────────────────────────────────────────────────
+
+const VALID_LAYERS = ['org', 'dept', 'team', 'individual'];
+const VALID_OVERLAYS = ['product', 'feature', 'incident', 'journey', 'surface', 'service', 'general'];
+const VALID_ANGLES = ['business', 'market', 'product', 'ux', 'technical', 'operational', 'delivery'];
+
+/**
+ * Prompt the user to reclassify a memory's 3D coordinates.
+ * Returns { layer, overlay, angle } or null if cancelled.
+ */
+async function promptReclassify(mem) {
+  const newLayer = await fmt.select({
+    message: `Layer (current: ${mem.layer || 'unclassified'})`,
+    options: VALID_LAYERS.map(l => ({
+      value: l,
+      label: l,
+      hint: l === mem.layer ? 'current' : undefined,
+    })),
+    initialValue: mem.layer || 'team',
+  });
+  if (fmt.isCancel(newLayer)) return null;
+
+  let overlayInput;
+  try {
+    overlayInput = await text({
+      message: `Overlays (current: ${Array.isArray(mem.overlay) ? mem.overlay.join(',') : '-'})`,
+      placeholder: 'comma-separated: product,feature,incident,journey,surface,service,general',
+      initialValue: Array.isArray(mem.overlay) ? mem.overlay.join(',') : 'general',
+      validate: (v) => {
+        const parts = v.split(',').map(s => s.trim()).filter(Boolean);
+        if (parts.length === 0) return 'At least one overlay required';
+        if (parts.length > 3) return 'Max 3 overlays';
+        const invalid = parts.filter(p => !VALID_OVERLAYS.includes(p));
+        if (invalid.length) return `Invalid: ${invalid.join(', ')}. Valid: ${VALID_OVERLAYS.join(', ')}`;
+      },
+    });
+  } catch {
+    overlayInput = Array.isArray(mem.overlay) ? mem.overlay.join(',') : 'general';
+  }
+  if (isCancel(overlayInput)) return null;
+
+  let angleInput;
+  try {
+    angleInput = await text({
+      message: `Angles (current: ${Array.isArray(mem.angle) ? mem.angle.join(',') : '-'})`,
+      placeholder: 'comma-separated: business,market,product,ux,technical,operational,delivery',
+      initialValue: Array.isArray(mem.angle) ? mem.angle.join(',') : 'technical',
+      validate: (v) => {
+        const parts = v.split(',').map(s => s.trim()).filter(Boolean);
+        if (parts.length === 0) return 'At least one angle required';
+        if (parts.length > 2) return 'Max 2 angles';
+        const invalid = parts.filter(p => !VALID_ANGLES.includes(p));
+        if (invalid.length) return `Invalid: ${invalid.join(', ')}. Valid: ${VALID_ANGLES.join(', ')}`;
+      },
+    });
+  } catch {
+    angleInput = Array.isArray(mem.angle) ? mem.angle.join(',') : 'technical';
+  }
+  if (isCancel(angleInput)) return null;
+
+  return {
+    layer: newLayer,
+    overlay: overlayInput.split(',').map(s => s.trim()).filter(Boolean),
+    angle: angleInput.split(',').map(s => s.trim()).filter(Boolean),
+  };
+}
+
+// ── scope-promote ────────────────────────────────────────────────────
+
+/**
+ * Auto-promote memories observed in 2+ repos to namespace scope.
+ * PRD §4.3.1: personal → repo → namespace → global promotion flow.
+ */
+async function memoryScopePromote(args) {
+  fmt.intro('aw memory scope-promote');
+
+  const dryRun = args['--dry-run'] === true;
+  const minRepos = parseInt(args['--min-repos'] || '2', 10);
+
+  const s = fmt.spinner();
+  s.start('Fetching repo-scoped memories...');
+
+  try {
+    // Get all active memories with repo_slug set (repo-scoped)
+    const result = await callMemoryTool('memory_search', {
+      query: '*',
+      limit: 500,
+    });
+    const memories = Array.isArray(result) ? result : (result?.memories ?? result?.results ?? []);
+
+    if (memories.length === 0) {
+      s.stop('No memories found');
+      fmt.outro('Nothing to promote');
+      return;
+    }
+
+    // Group by content similarity key (first 100 chars normalized)
+    const contentGroups = new Map(); // normalizedContent → [{ mem, repo_slug }]
+
+    for (const mem of memories) {
+      if (!mem.repo_slug) continue; // Skip non-repo-scoped memories
+      if (mem.scope_level === 'global' || mem.scope_level === 'namespace') continue; // Already promoted
+
+      const key = normalizeForGrouping(mem.content || mem.text || '');
+      if (!key) continue;
+
+      if (!contentGroups.has(key)) contentGroups.set(key, []);
+      contentGroups.get(key).push({ mem, repo_slug: mem.repo_slug });
+    }
+
+    // Find memories that appear in minRepos+ different repos
+    const promotable = [];
+    for (const [key, entries] of contentGroups) {
+      const uniqueRepos = new Set(entries.map(e => e.repo_slug));
+      if (uniqueRepos.size >= minRepos) {
+        // Pick the highest-confidence version as the canonical one
+        const sorted = entries.sort((a, b) => (b.mem.confidence ?? 0) - (a.mem.confidence ?? 0));
+        promotable.push({
+          canonical: sorted[0].mem,
+          repos: [...uniqueRepos],
+          count: entries.length,
+        });
+      }
+    }
+
+    s.stop(`Found ${promotable.length} memor${promotable.length === 1 ? 'y' : 'ies'} in ${minRepos}+ repos`);
+
+    if (promotable.length === 0) {
+      fmt.logInfo(`No memories found in ${minRepos}+ different repos.`);
+      fmt.outro('Nothing to promote');
+      return;
+    }
+
+    // Display candidates
+    for (const p of promotable) {
+      const content = (p.canonical.content || '').slice(0, 100);
+      fmt.note(
+        `${chalk.dim('content:')} ${content}\n` +
+        `${chalk.dim('repos:')}   ${p.repos.join(', ')}\n` +
+        `${chalk.dim('conf:')}    ${p.canonical.confidence ?? '-'}`,
+        `${p.repos.length} repos, ${p.count} occurrences`,
+      );
+    }
+
+    if (dryRun) {
+      fmt.logInfo('Dry run — no changes made.');
+      fmt.outro(`${promotable.length} memories would be promoted to namespace scope`);
+      return;
+    }
+
+    // Confirm
+    if (!args['--yes'] && !args['-y']) {
+      try {
+        const shouldPromote = await confirm({
+          message: `Promote ${promotable.length} memor${promotable.length !== 1 ? 'ies' : 'y'} to namespace scope?`,
+        });
+        if (isCancel(shouldPromote) || !shouldPromote) {
+          fmt.outro('Promotion cancelled');
+          return;
+        }
+      } catch {
+        // Non-TTY — proceed
+      }
+    }
+
+    // Promote each by updating scope_level to 'namespace' and clearing repo_slug
+    const ps = fmt.spinner();
+    ps.start('Promoting to namespace scope...');
+
+    let promoted = 0;
+    let failed = 0;
+
+    for (const p of promotable) {
+      try {
+        await callMemoryTool('memory_update', {
+          memory_id: p.canonical.id,
+          scope_level: 'namespace',
+          repo_slug: null,
+        });
+        promoted++;
+      } catch (err) {
+        failed++;
+        fmt.logError(`Failed to promote ${(p.canonical.id || '').slice(0, 8)}: ${err.message}`);
+      }
+    }
+
+    ps.stop('Promotion complete');
+
+    const resultLines = [
+      `  ${chalk.green('Promoted:')}  ${promoted}`,
+      failed > 0 ? `  ${chalk.red('Failed:')}    ${failed}` : null,
+    ].filter(Boolean).join('\n');
+    fmt.note(resultLines, 'Scope Promote Summary');
+    fmt.outro(`${promoted} memor${promoted !== 1 ? 'ies' : 'y'} promoted to namespace scope`);
+  } catch (err) {
+    s.stop(chalk.red('Failed'));
+    fmt.cancel(`Scope promote failed: ${err.message}`);
+  }
+}
+
+/**
+ * Normalize memory content for grouping — lowercase, strip whitespace, truncate.
+ */
+function normalizeForGrouping(content) {
+  if (!content) return '';
+  return content
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 100);
+}
+
 // ── help ─────────────────────────────────────────────────────────────
 
 function memoryHelp() {
@@ -877,6 +1253,10 @@ function memoryHelp() {
     cmd('  --limit <n>', 'Observations to scan (default: 200)'),
     cmd('  --min <n>', 'Min occurrences to promote (default: 3)'),
     '',
+    cmd('aw memory scope-promote', 'Promote repo→namespace scope'),
+    cmd('  --min-repos <n>', 'Min repos to trigger (default: 2)'),
+    cmd('  --dry-run', 'Preview without changes'),
+    '',
   ].join('\n');
 
   console.log(help);

package/memory-bridge.mjs

@@ -4,6 +4,7 @@ import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { MCP_BASE_URL, AW_HOME, REGISTRY_DIR } from './constants.mjs';
 import * as config from './config.mjs';
+import { enqueue, flushQueue } from './memory-queue.mjs';
 
 let _rpcId = 1;
 
@@ -55,13 +56,86 @@ function resolveGhToken() {
   return null;
 }
 
+/** Write operations that can be queued when MCP is unreachable. */
+const WRITE_OPS = new Set([
+  'memory_store',
+  'memory_curated_store',
+  'memory_feedback',
+  'memory_update',
+  'memory_invalidate',
+]);
+
+/** Detect network-level errors (MCP unreachable). */
+function isNetworkError(err) {
+  if (!err) return false;
+  const msg = err.message || '';
+  const code = err.code || '';
+  return (
+    code === 'ECONNREFUSED' ||
+    code === 'ECONNRESET' ||
+    code === 'ENOTFOUND' ||
+    code === 'UND_ERR_CONNECT_TIMEOUT' ||
+    msg.includes('fetch failed') ||
+    msg.includes('network') ||
+    msg.includes('ECONNREFUSED') ||
+    msg.includes('ECONNRESET') ||
+    msg.includes('ENOTFOUND') ||
+    err.name === 'AbortError' ||
+    err.name === 'TimeoutError'
+  );
+}
+
+/** Flag to prevent recursive flush attempts. */
+let _flushing = false;
+
+/**
+ * Try to flush queued operations if MCP is reachable.
+ * Called at the start of every successful callMemoryTool invocation.
+ */
+async function tryFlushQueue() {
+  if (_flushing) return;
+  _flushing = true;
+  try {
+    await flushQueue(_callMemoryToolRaw);
+  } catch {
+    // Flush is best-effort — don't block the current operation
+  } finally {
+    _flushing = false;
+  }
+}
+
 /**
  * Call an MCP memory tool by name via JSON-RPC 2.0 (Streamable HTTP).
+ * Wraps the raw transport with offline queue support:
+ * - WRITE ops are enqueued when MCP is unreachable
+ * - READ ops propagate the error
+ * - On success, flushes any queued operations
  * @param {string} toolName — MCP tool name (e.g. 'memory_curated_store', 'memory_search')
  * @param {object} params  — Tool arguments
- * @returns {Promise<object>} Parsed tool result
+ * @returns {Promise<object>} Parsed tool result (or synthetic {queued:true})
  */
 export async function callMemoryTool(toolName, params) {
+  try {
+    const result = await _callMemoryToolRaw(toolName, params);
+    // MCP is reachable — flush any queued items in the background
+    tryFlushQueue();
+    return result;
+  } catch (err) {
+    if (isNetworkError(err) && WRITE_OPS.has(toolName)) {
+      enqueue(toolName, params);
+      return { queued: true, message: 'MCP unreachable — operation queued for retry' };
+    }
+    throw err;
+  }
+}
+
+/**
+ * Raw MCP transport — JSON-RPC 2.0 over Streamable HTTP.
+ * @param {string} toolName
+ * @param {object} params
+ * @returns {Promise<object>}
+ */
+async function _callMemoryToolRaw(toolName, params) {
   const response = await fetch(MCP_BASE_URL, {
     method: 'POST',
     headers: resolveHeaders(),

package/memory-queue.mjs

@@ -0,0 +1,128 @@
+// memory-queue.mjs — Offline queue for memory operations when MCP is unreachable
+
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { AW_HOME } from './constants.mjs';
+
+/** Queue file path: ~/.aw/memory-queue.jsonl */
+const QUEUE_PATH = join(AW_HOME, 'memory-queue.jsonl');
+
+/** Max age for queued items before they are discarded (7 days in ms) */
+const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+/**
+ * Append a write operation to the offline queue.
+ * @param {string} op   — MCP tool name (e.g. 'memory_store', 'memory_curated_store')
+ * @param {object} payload — Tool arguments
+ */
+export function enqueue(op, payload) {
+  const dir = dirname(QUEUE_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const entry = {
+    op,
+    payload,
+    queued_at: new Date().toISOString(),
+    attempt: 0,
+  };
+
+  appendFileSync(QUEUE_PATH, JSON.stringify(entry) + '\n', 'utf8');
+}
+
+/**
+ * Flush the offline queue — process each item via the provided sender function.
+ * Removes successfully processed items, retries failed ones (increments attempt),
+ * and discards items older than 7 days.
+ * @param {(toolName: string, params: object) => Promise<object>} sender — raw MCP call function
+ * @returns {Promise<{processed: number, failed: number, discarded: number}>}
+ */
+export async function flushQueue(sender) {
+  if (!existsSync(QUEUE_PATH)) {
+    return { processed: 0, failed: 0, discarded: 0 };
+  }
+
+  const raw = readFileSync(QUEUE_PATH, 'utf8').trim();
+  if (!raw) {
+    return { processed: 0, failed: 0, discarded: 0 };
+  }
+
+  const lines = raw.split('\n').filter(Boolean);
+  const remaining = [];
+  let processed = 0;
+  let failed = 0;
+  let discarded = 0;
+  const now = Date.now();
+
+  for (const line of lines) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      // Malformed line — discard
+      discarded++;
+      continue;
+    }
+
+    // Discard items older than 7 days
+    const age = now - new Date(entry.queued_at).getTime();
+    if (age > MAX_AGE_MS) {
+      discarded++;
+      continue;
+    }
+
+    try {
+      await sender(entry.op, entry.payload);
+      processed++;
+    } catch {
+      entry.attempt = (entry.attempt || 0) + 1;
+      remaining.push(entry);
+      failed++;
+    }
+  }
+
+  // Rewrite queue with only the remaining (failed) items
+  if (remaining.length > 0) {
+    const data = remaining.map(e => JSON.stringify(e)).join('\n') + '\n';
+    writeFileSync(QUEUE_PATH, data, 'utf8');
+  } else {
+    writeFileSync(QUEUE_PATH, '', 'utf8');
+  }
+
+  return { processed, failed, discarded };
+}
+
+/**
+ * Get queue statistics for display.
+ * @returns {{pending: number, oldest: string|null, newest: string|null}}
+ */
+export function getQueueStats() {
+  if (!existsSync(QUEUE_PATH)) {
+    return { pending: 0, oldest: null, newest: null };
+  }
+
+  const raw = readFileSync(QUEUE_PATH, 'utf8').trim();
+  if (!raw) {
+    return { pending: 0, oldest: null, newest: null };
+  }
+
+  const lines = raw.split('\n').filter(Boolean);
+  let oldest = null;
+  let newest = null;
+  let pending = 0;
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      pending++;
+      const ts = entry.queued_at;
+      if (!oldest || ts < oldest) oldest = ts;
+      if (!newest || ts > newest) newest = ts;
+    } catch {
+      // skip malformed
+    }
+  }
+
+  return { pending, oldest, newest };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.43",
+  "version": "0.1.37-beta.44",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -28,7 +28,8 @@
     "render-rules.mjs",
     "telemetry.mjs",
     "memory-bridge.mjs",
-    "memory-sync.mjs"
+    "memory-sync.mjs",
+    "memory-queue.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"