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

package/commands/init.mjs

@@ -353,7 +353,6 @@ export async function initCommand(args) {
   try {
     await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
     ensureAwGitignore(AW_HOME);
-    mkdirSync(join(GLOBAL_AW_DIR, 'memory'), { recursive: true });
     s.stop('Registry cloned');
   } catch (e) {
     s.stop(chalk.red('Clone failed'));
@@ -382,6 +381,9 @@ export async function initCommand(args) {
     }
   }
 
+  // Create memory dir after symlink so GLOBAL_AW_DIR resolves correctly
+  mkdirSync(join(GLOBAL_AW_DIR, 'memory'), { recursive: true });
+
   // Create sync config — default to 'platform' when no namespace specified
   const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
   if (folderName) {

package/commands/memory.mjs

@@ -6,10 +6,32 @@ import { homedir } from 'node:os';
 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 { callMemoryTool, computeAncestry, resolveStoreNamespace, resolveReadPaths } from '../memory-bridge.mjs';
 import { syncMemories } from '../memory-sync.mjs';
-import { REGISTRY_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, ORG_SCOPE_NAMESPACE } from '../constants.mjs';
 import { getQueueStats } from '../memory-queue.mjs';
+import * as config from '../config.mjs';
+
+/** Load .sync-config.json from the registry directory. */
+function loadCfg() {
+  const registryDir = join(homedir(), '.aw', REGISTRY_DIR);
+  return config.load(registryDir) || {};
+}
+
+/**
+ * Validate that an explicit namespace is within the user's ancestry chain.
+ * Returns true if valid, false if not.
+ */
+function validateNamespaceAccess(cfg, explicitNs) {
+  const includes = cfg.include || [];
+  // Build full ancestry from the user's include paths
+  const validPaths = includes.length > 0
+    ? computeAncestry(includes)
+    : [cfg.namespace || ORG_SCOPE_NAMESPACE];
+  // Always allow the org root
+  if (!validPaths.includes(ORG_SCOPE_NAMESPACE)) validPaths.push(ORG_SCOPE_NAMESPACE);
+  return validPaths.includes(explicitNs);
+}
 
 // ── legacy import ─────────────────────────────────────────────────────
 
@@ -155,18 +177,34 @@ async function memoryStore(args) {
 
   fmt.intro('aw memory store');
 
+  const cfg = loadCfg();
+  const explicitNs = args['--namespace'] || null;
+
+  // Validate explicit namespace is within ancestry chain
+  if (explicitNs && !validateNamespaceAccess(cfg, explicitNs)) {
+    fmt.cancel(`Namespace "${explicitNs}" is not in your ancestry chain. Your include paths: ${(cfg.include || []).join(', ') || '(none)'}`);
+    return;
+  }
+
+  // Resolve store namespace via layered defaults
+  const storeNs = resolveStoreNamespace(cfg, explicitNs);
+
   const params = { content };
   if (args['--type'])      params.type = args['--type'];
-  if (args['--namespace']) params.namespace = args['--namespace'];
+  if (storeNs)             params.namespace = storeNs;
   if (args['--layer'])     params.layer = args['--layer'];
   if (args['--overlay'])   params.overlay = args['--overlay'].split(',').map(s => s.trim());
   if (args['--angle'])     params.angle = args['--angle'].split(',').map(s => s.trim());
   if (args['--tags'])      params.tags = args['--tags'].split(',').map(s => s.trim());
 
+  // Build call opts
+  const callOpts = {};
+  if (storeNs) callOpts.storeNamespace = storeNs;
+
   const s = fmt.spinner();
   s.start('Storing memory...');
   try {
-    const result = await callMemoryTool('memory_curated_store', params);
+    const result = await callMemoryTool('memory_curated_store', params, callOpts);
     s.stop('Memory stored');
 
     const data = result?.result ?? result;
@@ -203,17 +241,29 @@ async function memorySearch(args) {
 
   fmt.intro('aw memory search');
 
+  const cfg = loadCfg();
+  const explicitNs = args['--namespace'] || null;
+
+  // Resolve read paths via layered defaults
+  const readPaths = resolveReadPaths(cfg, explicitNs);
+
   const params = { query };
-  if (args['--namespace']) params.namespace = args['--namespace'];
+  if (explicitNs)          params.namespace = explicitNs;
   if (args['--limit'])     params.limit = parseInt(args['--limit'], 10);
   if (args['--layer'])     params.layer = args['--layer'];
   if (args['--overlay'])   params.overlay = args['--overlay'];
   if (args['--angle'])     params.angle = args['--angle'];
 
+  // Override namespace paths header when explicit ns is provided
+  const callOpts = {};
+  if (explicitNs) {
+    callOpts.namespacePaths = readPaths.join(',');
+  }
+
   const s = fmt.spinner();
   s.start('Searching memories...');
   try {
-    const result = await callMemoryTool('memory_search', params);
+    const result = await callMemoryTool('memory_search', params, callOpts);
     s.stop('Search complete');
 
     const memories = Array.isArray(result) ? result : (result?.memories ?? result?.results ?? []);
@@ -259,18 +309,30 @@ async function memoryPack(args) {
 
   fmt.intro('aw memory pack');
 
+  const cfg = loadCfg();
+  const explicitNs = args['--namespace'] || null;
+
+  // Resolve read paths via layered defaults (same as search)
+  const readPaths = resolveReadPaths(cfg, explicitNs);
+
   const params = { query };
-  if (args['--namespace']) params.namespace = args['--namespace'];
+  if (explicitNs)          params.namespace = explicitNs;
   if (args['--budget'])    params.token_budget = parseInt(args['--budget'], 10);
   else                     params.token_budget = 3500;
   if (args['--layer'])     params.layer = args['--layer'];
   if (args['--overlay'])   params.overlay = args['--overlay'];
   if (args['--angle'])     params.angle = args['--angle'];
 
+  // Override namespace paths header when explicit ns is provided
+  const callOpts = {};
+  if (explicitNs) {
+    callOpts.namespacePaths = readPaths.join(',');
+  }
+
   const s = fmt.spinner();
   s.start('Building memory pack...');
   try {
-    const result = await callMemoryTool('memory_pack', params);
+    const result = await callMemoryTool('memory_pack', params, callOpts);
     s.stop('Pack ready');
 
     const pack = result?.pack ?? result?.content ?? result;
@@ -1261,3 +1323,6 @@ function memoryHelp() {
 
   console.log(help);
 }
+
+// ── test-only exports ────────────────────────────────────────────────
+export const _test = { rateMemoryQuality, getQualityIssue, buildPromoteContent, normalizeForGrouping, formatTimeAgo };

package/constants.mjs

@@ -37,3 +37,6 @@ export const AW_CO_AUTHOR = `Co-Authored-By: ${AW_BOT_NAME} <${AW_BOT_EMAIL}>`;
 
 /** MCP base URL for memory and other tool calls — override with AW_MCP_URL env var */
 export const MCP_BASE_URL = process.env.AW_MCP_URL || 'http://localhost:3100/agentic-workspace/mcp';
+
+/** Default org-level namespace — always included in ancestry */
+export const ORG_SCOPE_NAMESPACE = 'platform';

package/ecc.mjs

@@ -9,7 +9,7 @@ import * as fmt from "./fmt.mjs";
 
 const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
 const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
-const AW_ECC_TAG = "v1.4.1";
+const AW_ECC_TAG = "v1.4.3";
 
 const MARKETPLACE_NAME = "aw-marketplace";
 const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;

package/memory-bridge.mjs

@@ -2,7 +2,7 @@
 
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
-import { MCP_BASE_URL, AW_HOME, REGISTRY_DIR } from './constants.mjs';
+import { MCP_BASE_URL, AW_HOME, REGISTRY_DIR, ORG_SCOPE_NAMESPACE } from './constants.mjs';
 import * as config from './config.mjs';
 import { enqueue, flushQueue } from './memory-queue.mjs';
 
@@ -24,9 +24,21 @@ function resolveHeaders() {
     'Accept': 'application/json, text/event-stream',
   };
 
-  // Resolve namespace from .sync-config.json → X-Namespace header
+  // Resolve namespace paths from .sync-config.json
   const registryDir = join(AW_HOME, REGISTRY_DIR);
   const cfg = config.load(registryDir);
+
+  // Send ALL initialized namespace paths (from include[]) + platform
+  const paths = [...(cfg?.include || [])];
+  if (!paths.some(p => p === ORG_SCOPE_NAMESPACE || p.startsWith(ORG_SCOPE_NAMESPACE + '/'))) {
+    paths.push(ORG_SCOPE_NAMESPACE);
+  }
+  headers['X-Namespace-Paths'] = paths.join(',');
+
+  // Send GitHub username
+  headers['X-Github-User'] = cfg?.user || '';
+
+  // Keep X-Namespace for backwards compat
   if (cfg?.namespace) {
     headers['X-Namespace'] = cfg.namespace;
   }
@@ -56,6 +68,57 @@ function resolveGhToken() {
   return null;
 }
 
+/**
+ * Compute the full ancestry chain for a set of namespace paths.
+ * E.g. ['platform/scheduling/calendars'] → ['platform/scheduling/calendars', 'platform/scheduling', 'platform']
+ */
+export function computeAncestry(paths) {
+  const result = new Set();
+  for (const path of paths) {
+    const segments = path.split('/');
+    for (let i = segments.length; i >= 1; i--) {
+      result.add(segments.slice(0, i).join('/'));
+    }
+  }
+  result.add(ORG_SCOPE_NAMESPACE);
+  return [...result];
+}
+
+/**
+ * Resolve the store namespace using layered defaults.
+ * Layer 1: Explicit (from --namespace flag)
+ * Layer 2: Single include path
+ * Layer 3: Multi include — return null (curation picks)
+ * Layer 4: Fallback to cfg.namespace or 'platform'
+ */
+export function resolveStoreNamespace(cfg, explicitNs) {
+  // Layer 1: Explicit
+  if (explicitNs) return explicitNs;
+  // Layer 2: Single include
+  const includes = cfg?.include || [];
+  if (includes.length === 1) return includes[0];
+  // Layer 3: Multi include — return null (curation picks)
+  if (includes.length > 1) return null;
+  // Layer 4: Fallback
+  return cfg?.namespace || ORG_SCOPE_NAMESPACE;
+}
+
+/**
+ * Resolve read namespace paths using layered defaults.
+ * Returns a full ancestry chain for the resolved paths.
+ */
+export function resolveReadPaths(cfg, explicitNs) {
+  // Layer 1: Explicit
+  if (explicitNs) return computeAncestry([explicitNs]);
+  // Layer 2: Single include
+  const includes = cfg?.include || [];
+  if (includes.length === 1) return computeAncestry(includes);
+  // Layer 3: Multi include
+  if (includes.length > 1) return computeAncestry(includes);
+  // Layer 4: Fallback
+  return [ORG_SCOPE_NAMESPACE];
+}
+
 /** Write operations that can be queued when MCP is unreachable. */
 const WRITE_OPS = new Set([
   'memory_store',
@@ -112,11 +175,14 @@ async function tryFlushQueue() {
  * - On success, flushes any queued operations
  * @param {string} toolName — MCP tool name (e.g. 'memory_curated_store', 'memory_search')
  * @param {object} params  — Tool arguments
+ * @param {object} [opts]  — Optional overrides
+ * @param {string} [opts.storeNamespace] — If set, adds X-Store-Namespace header
+ * @param {string} [opts.namespacePaths] — If set, overrides X-Namespace-Paths header
  * @returns {Promise<object>} Parsed tool result (or synthetic {queued:true})
  */
-export async function callMemoryTool(toolName, params) {
+export async function callMemoryTool(toolName, params, opts = {}) {
   try {
-    const result = await _callMemoryToolRaw(toolName, params);
+    const result = await _callMemoryToolRaw(toolName, params, opts);
     // MCP is reachable — flush any queued items in the background
     tryFlushQueue();
     return result;
@@ -133,12 +199,20 @@ export async function callMemoryTool(toolName, params) {
  * Raw MCP transport — JSON-RPC 2.0 over Streamable HTTP.
  * @param {string} toolName
  * @param {object} params
+ * @param {object} [opts]
  * @returns {Promise<object>}
  */
-async function _callMemoryToolRaw(toolName, params) {
+async function _callMemoryToolRaw(toolName, params, opts = {}) {
+  const headers = { ...resolveHeaders() };
+  if (opts.storeNamespace) {
+    headers['X-Store-Namespace'] = opts.storeNamespace;
+  }
+  if (opts.namespacePaths) {
+    headers['X-Namespace-Paths'] = opts.namespacePaths;
+  }
   const response = await fetch(MCP_BASE_URL, {
     method: 'POST',
-    headers: resolveHeaders(),
+    headers,
     body: JSON.stringify({
       jsonrpc: '2.0',
       id: _rpcId++,

package/memory-queue.mjs

@@ -4,8 +4,8 @@ import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } fr
 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');
+/** Queue file path: ~/.aw/memory-queue.jsonl (resolved lazily for testability) */
+function getQueuePath() { return 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;
@@ -16,7 +16,8 @@ const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
  * @param {object} payload — Tool arguments
  */
 export function enqueue(op, payload) {
-  const dir = dirname(QUEUE_PATH);
+  const queuePath = getQueuePath();
+  const dir = dirname(queuePath);
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -28,7 +29,7 @@ export function enqueue(op, payload) {
     attempt: 0,
   };
 
-  appendFileSync(QUEUE_PATH, JSON.stringify(entry) + '\n', 'utf8');
+  appendFileSync(queuePath, JSON.stringify(entry) + '\n', 'utf8');
 }
 
 /**
@@ -39,11 +40,12 @@ export function enqueue(op, payload) {
  * @returns {Promise<{processed: number, failed: number, discarded: number}>}
  */
 export async function flushQueue(sender) {
-  if (!existsSync(QUEUE_PATH)) {
+  const queuePath = getQueuePath();
+  if (!existsSync(queuePath)) {
     return { processed: 0, failed: 0, discarded: 0 };
   }
 
-  const raw = readFileSync(QUEUE_PATH, 'utf8').trim();
+  const raw = readFileSync(queuePath, 'utf8').trim();
   if (!raw) {
     return { processed: 0, failed: 0, discarded: 0 };
   }
@@ -85,9 +87,9 @@ export async function flushQueue(sender) {
   // 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');
+    writeFileSync(queuePath, data, 'utf8');
   } else {
-    writeFileSync(QUEUE_PATH, '', 'utf8');
+    writeFileSync(queuePath, '', 'utf8');
   }
 
   return { processed, failed, discarded };
@@ -98,11 +100,12 @@ export async function flushQueue(sender) {
  * @returns {{pending: number, oldest: string|null, newest: string|null}}
  */
 export function getQueueStats() {
-  if (!existsSync(QUEUE_PATH)) {
+  const queuePath = getQueuePath();
+  if (!existsSync(queuePath)) {
     return { pending: 0, oldest: null, newest: null };
   }
 
-  const raw = readFileSync(QUEUE_PATH, 'utf8').trim();
+  const raw = readFileSync(queuePath, 'utf8').trim();
   if (!raw) {
     return { pending: 0, oldest: null, newest: null };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.37-beta.44",
+  "version": "0.1.37-beta.46",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -45,7 +45,7 @@
   "license": "MIT",
   "scripts": {
     "test": "yarn test:vitest && yarn test:node",
-    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs",
+    "test:vitest": "vitest run --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs tests/memory-queue.test.mjs tests/memory-sync.test.mjs tests/memory-bridge.test.mjs",
     "test:node": "node tests/run-node-tests.mjs",
     "test:watch": "vitest --reporter=verbose tests/commands tests/mcp.test.mjs tests/telemetry.test.mjs",
     "preuninstall": "node bin.js nuke 2>/dev/null || true"