@noir-ai/cli 1.12.0-beta.1 → 1.13.0-beta.1

package/dist/index.js

@@ -540,12 +540,326 @@ var init_context = __esm({
   }
 });
 
+// src/workspace-mcp.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { resolveAdapter } from "@noir-ai/adapters";
+import { atomicWriteFile, resolveNoirCommand } from "@noir-ai/core";
+function mcpPathFor(root, host) {
+  return resolveAdapter(host).mcpConfigPath?.({ root }) ?? join(root, ".mcp.json");
+}
+function readJson(path) {
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function loadExisting(path, opts) {
+  let existing;
+  try {
+    existing = readJson(path);
+  } catch {
+    if (opts.force !== true) {
+      fail(
+        EXIT.ERROR,
+        `Refusing to rewrite ${path}: it is not valid JSON (add --force to overwrite).`,
+        opts
+      );
+    }
+    existing = null;
+  }
+  if (existing !== null && !isNoirEmitted(existing.mcpServers) && opts.force !== true) {
+    fail(
+      EXIT.ERROR,
+      `Refusing to rewrite ${path}: it does not look like a Noir-emitted config (add --force to overwrite).`,
+      opts
+    );
+  }
+  return existing;
+}
+function isNoirEmitted(mcpServers) {
+  const noir = mcpServers?.noir;
+  if (!noir) return false;
+  if (typeof noir.command === "string") return true;
+  return noir.type === "http";
+}
+function writeWorkspaceHttpEntry(root, host, url, projectId, opts) {
+  const path = mcpPathFor(root, host);
+  const existing = loadExisting(path, opts);
+  const next = {
+    ...existing ?? {},
+    mcpServers: {
+      ...existing?.mcpServers ?? {},
+      noir: { type: "http", url: `${url}?p=${projectId}` }
+    }
+  };
+  atomicWriteFile(path, `${JSON.stringify(next, null, 2)}
+`);
+}
+function writeStdioEntry(root, host, opts) {
+  const path = mcpPathFor(root, host);
+  const existing = loadExisting(path, opts);
+  const noir = { command: resolveNoirCommand(), args: ["mcp", "serve", "--stdio"] };
+  const next = { ...existing ?? {}, mcpServers: { ...existing?.mcpServers ?? {}, noir } };
+  atomicWriteFile(path, `${JSON.stringify(next, null, 2)}
+`);
+}
+var init_workspace_mcp = __esm({
+  "src/workspace-mcp.ts"() {
+    "use strict";
+    init_output();
+  }
+});
+
+// src/commands/workspace.ts
+import { readdirSync } from "fs";
+import {
+  clearWorkspaceMarker,
+  ensureWorkspaceRegistry,
+  isValidWorkspaceName,
+  isWorkspaceMember,
+  loadProjectInfo,
+  readWorkspaceMarker,
+  readWorkspaceRegistry,
+  removeWorkspaceMember,
+  upsertWorkspaceMember,
+  workspaceHomeDir,
+  writeWorkspaceMarker
+} from "@noir-ai/core";
+import {
+  clearWorkspaceDaemonRecord,
+  ensureWorkspaceDaemonRunning,
+  pidAlive,
+  readWorkspaceDaemonRecord,
+  spawnDetachedWorkspaceDaemon
+} from "@noir-ai/daemon";
+function loadProjectOrFail(opts) {
+  try {
+    return loadProjectInfo(process.cwd());
+  } catch {
+    fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
+  }
+}
+function finishJoin(project, name, url, opts) {
+  writeWorkspaceMarker(project.root, name);
+  writeWorkspaceHttpEntry(project.root, project.config.host, url, project.id, opts);
+}
+async function daemonStartWorkspace(opts) {
+  const project = loadProjectOrFail(opts);
+  if (!isValidWorkspaceName(opts.name)) {
+    fail(
+      EXIT.USAGE,
+      `invalid workspace name ${JSON.stringify(opts.name)} (lowercase letters, digits, and dashes).`,
+      opts
+    );
+  }
+  upsertWorkspaceMember(ensureWorkspaceRegistry(opts.name), {
+    projectId: project.id,
+    root: project.root,
+    joinedAt: Date.now()
+  });
+  if (opts.detachChild === true) {
+    const ensured2 = await ensureWorkspaceDaemonRunning({
+      name: opts.name,
+      project,
+      idleTimeoutSec: project.config.workspace.idleTimeoutSec
+    });
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: { mode: "detached" } })}
+`);
+      return;
+    }
+    info("noir workspace daemon: detached foreground. Ctrl+C to stop.", opts);
+    log(`workspace daemon listening at ${ensured2.url}`, opts);
+    return;
+  }
+  if (opts.detach === true) {
+    const spawned = await spawnDetachedWorkspaceDaemon({ name: opts.name, project });
+    finishJoin(project, opts.name, `http://127.0.0.1:${spawned.port}/mcp`, opts);
+    if (opts.json === true) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, data: { mode: "detached", pid: spawned.pid, port: spawned.port } })}
+`
+      );
+      return;
+    }
+    info(
+      `workspace "${opts.name}" daemon started (pid ${spawned.pid}, port ${spawned.port}).`,
+      opts
+    );
+    return;
+  }
+  const ensured = await ensureWorkspaceDaemonRunning({
+    name: opts.name,
+    project,
+    idleTimeoutSec: project.config.workspace.idleTimeoutSec
+  });
+  finishJoin(project, opts.name, ensured.url, opts);
+  if (opts.json === true) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, data: { url: ensured.url, port: ensured.port, reused: !ensured.started } })}
+`
+    );
+    return;
+  }
+  info("noir workspace daemon: foreground mode. Ctrl+C to stop.", opts);
+  log(`workspace daemon listening at ${ensured.url}`, opts);
+}
+async function daemonJoin(opts) {
+  const project = loadProjectOrFail(opts);
+  if (!isValidWorkspaceName(opts.name)) {
+    fail(EXIT.USAGE, `invalid workspace name ${JSON.stringify(opts.name)}.`, opts);
+  }
+  const reg = readWorkspaceRegistry(opts.name);
+  if (!reg) {
+    fail(
+      EXIT.ERROR,
+      `workspace ${JSON.stringify(opts.name)} not found \u2014 start it from a member repo with \`noir daemon start --workspace ${opts.name}\`.`,
+      opts
+    );
+  }
+  const ensured = await ensureWorkspaceDaemonRunning({
+    name: opts.name,
+    project,
+    idleTimeoutSec: project.config.workspace.idleTimeoutSec
+  });
+  upsertWorkspaceMember(reg, { projectId: project.id, root: project.root, joinedAt: Date.now() });
+  finishJoin(project, opts.name, ensured.url, opts);
+  if (opts.json === true) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, data: { joined: true, url: ensured.url, port: ensured.port } })}
+`
+    );
+    return;
+  }
+  info(`joined workspace ${JSON.stringify(opts.name)} (${ensured.url}).`, opts);
+}
+async function workspaceList(opts) {
+  let names = [];
+  try {
+    names = readdirSync(workspaceHomeDir(), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    names = [];
+  }
+  const rows = names.map((n) => {
+    const reg = readWorkspaceRegistry(n);
+    return {
+      name: n,
+      members: reg?.members.length ?? 0,
+      // A record file whose pid is dead (daemon killed without cleanup) must not
+      // read as "running" — mirror the pidAlive liveness `workspace status` uses.
+      running: (() => {
+        const rec = readWorkspaceDaemonRecord(n);
+        return rec !== null && pidAlive(rec.pid);
+      })()
+    };
+  });
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: { workspaces: rows } })}
+`);
+    return;
+  }
+  if (rows.length === 0) {
+    info("No workspaces yet.", opts);
+    return;
+  }
+  for (const r of rows) {
+    log(`${r.name} \u2014 ${r.members} member(s)${r.running ? ", running" : ""}`, opts);
+  }
+}
+async function workspaceStatus(opts) {
+  const name = opts.name ?? readWorkspaceMarker(process.cwd()) ?? void 0;
+  if (name === void 0) {
+    fail(EXIT.USAGE, "workspace status requires a name (or run from a joined repo).", opts);
+  }
+  if (!isValidWorkspaceName(name)) {
+    fail(EXIT.USAGE, `invalid workspace name ${JSON.stringify(name)}.`, opts);
+  }
+  const reg = readWorkspaceRegistry(name);
+  const rec = readWorkspaceDaemonRecord(name);
+  const running = rec !== null && pidAlive(rec.pid);
+  const data = {
+    name,
+    members: reg?.members.map((m) => m.projectId) ?? [],
+    running,
+    ...rec ? { pid: rec.pid, port: rec.port } : {}
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data })}
+`);
+    return;
+  }
+  log(
+    `workspace ${name}: ${running ? `running (pid ${rec?.pid}, port ${rec?.port})` : "not running"}`,
+    opts
+  );
+  for (const m of data.members) log(`  member: ${m}`, opts);
+}
+async function workspaceLeave(opts) {
+  const project = loadProjectOrFail(opts);
+  const name = readWorkspaceMarker(project.root);
+  if (name === null) {
+    fail(EXIT.USAGE, "this repo is not joined to a workspace.", opts);
+  }
+  writeStdioEntry(project.root, project.config.host, opts);
+  const reg = readWorkspaceRegistry(name);
+  if (reg && isWorkspaceMember(reg, project.id)) {
+    removeWorkspaceMember(reg, project.id);
+  }
+  clearWorkspaceMarker(project.root);
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: { left: name } })}
+`);
+    return;
+  }
+  info(`left workspace ${JSON.stringify(name)}.`, opts);
+}
+async function workspaceStop(opts) {
+  const name = opts.name ?? readWorkspaceMarker(process.cwd()) ?? void 0;
+  if (name === void 0) {
+    fail(EXIT.USAGE, "workspace stop requires a name (or run from a joined repo).", opts);
+  }
+  if (!isValidWorkspaceName(name)) {
+    fail(EXIT.USAGE, `invalid workspace name ${JSON.stringify(name)}.`, opts);
+  }
+  const rec = readWorkspaceDaemonRecord(name);
+  if (rec === null || !pidAlive(rec.pid)) {
+    if (opts.json === true) {
+      process.stdout.write(
+        `${JSON.stringify({ ok: true, data: { running: false, stopped: false } })}
+`
+      );
+      return;
+    }
+    info("workspace daemon is not running.", opts);
+    return;
+  }
+  try {
+    process.kill(rec.pid, "SIGTERM");
+  } catch {
+  }
+  clearWorkspaceDaemonRecord(name);
+  if (opts.json === true) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, data: { running: false, stopped: true, pid: rec.pid } })}
+`
+    );
+    return;
+  }
+  info(`stopped workspace daemon (pid ${rec.pid}).`, opts);
+}
+var init_workspace = __esm({
+  "src/commands/workspace.ts"() {
+    "use strict";
+    init_output();
+    init_workspace_mcp();
+  }
+});
+
 // src/commands/daemon.ts
-import { loadProjectInfo } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo2 } from "@noir-ai/core";
 import {
   clearDaemonRecord,
   ensureDaemonRunning,
-  pidAlive,
+  pidAlive as pidAlive2,
   readDaemonRecord,
   spawnDetachedDaemon
 } from "@noir-ai/daemon";
@@ -557,7 +871,7 @@ function formatUptime(sec) {
 }
 function resolveCallerProjectId() {
   try {
-    return loadProjectInfo(process.cwd()).id;
+    return loadProjectInfo2(process.cwd()).id;
   } catch {
     return void 0;
   }
@@ -578,9 +892,18 @@ async function isHealthy(port, expectedPid, expectedProjectId) {
   }
 }
 async function daemonStart(opts) {
+  if (opts.workspace !== void 0) {
+    await daemonStartWorkspace({
+      ...opts,
+      name: opts.workspace,
+      ...opts.detach === true ? { detach: true } : {},
+      ...opts.detachChild === true ? { detachChild: true } : {}
+    });
+    return;
+  }
   let project;
   try {
-    project = loadProjectInfo(process.cwd());
+    project = loadProjectInfo2(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -611,7 +934,7 @@ async function daemonStart(opts) {
   }
   if (opts.detach === true) {
     const existing = readDaemonRecord();
-    if (existing && pidAlive(existing.pid) && await isHealthy(existing.port, existing.pid, project.id)) {
+    if (existing && pidAlive2(existing.pid) && await isHealthy(existing.port, existing.pid, project.id)) {
       if (opts.json === true) {
         process.stdout.write(
           `${JSON.stringify({ ok: true, data: { mode: "detached", reused: true } })}
@@ -710,7 +1033,7 @@ async function daemonStop(opts) {
   let errMsg2;
   const callerProject = resolveCallerProjectId();
   const wrongProject = rec.projectId !== void 0 && callerProject !== void 0 && rec.projectId !== callerProject;
-  const healthy = !wrongProject && pidAlive(rec.pid) && await isHealthy(rec.port, rec.pid, rec.projectId === void 0 ? void 0 : callerProject);
+  const healthy = !wrongProject && pidAlive2(rec.pid) && await isHealthy(rec.port, rec.pid, rec.projectId === void 0 ? void 0 : callerProject);
   if (healthy) {
     try {
       process.kill(rec.pid, "SIGTERM");
@@ -756,7 +1079,7 @@ async function daemonStatus(opts) {
       opts
     );
   }
-  if (!pidAlive(rec.pid)) {
+  if (!pidAlive2(rec.pid)) {
     clearDaemonRecord();
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
   }
@@ -814,6 +1137,7 @@ var init_daemon = __esm({
     "use strict";
     init_daemon_client();
     init_output();
+    init_workspace();
     MODE = "foreground";
   }
 });
@@ -826,13 +1150,13 @@ __export(install_exports, {
   installManagedNode: () => installManagedNode
 });
 import { chmodSync, mkdirSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import {
-  atomicWriteFile,
+  atomicWriteFile as atomicWriteFile2,
   detectActiveMethod,
   detectInstallMethods,
   ensureShimExecutable,
-  loadProjectInfo as loadProjectInfo2,
+  loadProjectInfo as loadProjectInfo3,
   MANAGED_NODE_VERSION,
   NOIR_VERSION,
   noirHome,
@@ -878,8 +1202,8 @@ function buildMigrationPlan(opts) {
 async function installManagedNode(opts) {
   const spec = opts.version ?? opts.channel ?? "latest";
   const home2 = noirHome();
-  const cliDir = join(home2, "cli");
-  const binDir = join(home2, "bin");
+  const cliDir = join2(home2, "cli");
+  const binDir = join2(home2, "bin");
   mkdirSync(cliDir, { recursive: true });
   mkdirSync(binDir, { recursive: true });
   let runtime;
@@ -905,17 +1229,17 @@ async function installManagedNode(opts) {
   if (code !== 0) {
     return { ok: false, version: null, error: `npm install failed: ${stderr.slice(0, 300)}` };
   }
-  const shim = join(binDir, "noir");
+  const shim = join2(binDir, "noir");
   const shimBody = `#!/usr/bin/env bash
-"${nodeBin}" "${join(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js")}" "$@"
+"${nodeBin}" "${join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js")}" "$@"
 `;
-  atomicWriteFile(shim, shimBody);
+  atomicWriteFile2(shim, shimBody);
   chmodSync(shim, 493);
   ensureShimExecutable();
   const ver = await runManagerCmd(
     [
       nodeBin,
-      join(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js"),
+      join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js"),
       "--version"
     ],
     { env: opts.env, timeoutMs: 3e4 }
@@ -971,7 +1295,7 @@ async function install(opts = {}) {
   const installedRecord = readInstallRecord();
   let minVersion = "1.6.0";
   try {
-    minVersion = loadProjectInfo2(process.cwd()).config.update.minVersion;
+    minVersion = loadProjectInfo3(process.cwd()).config.update.minVersion;
   } catch {
   }
   const plan = buildMigrationPlan({
@@ -1048,7 +1372,7 @@ import {
   detectActiveMethod as detectActiveMethod2,
   ensureShimExecutable as ensureShimExecutable2,
   fetchLatestVersion,
-  loadProjectInfo as loadProjectInfo3,
+  loadProjectInfo as loadProjectInfo4,
   readInstallRecord as readInstallRecord2,
   readUpdateCache,
   runManagerCmd as runManagerCmd2,
@@ -1128,7 +1452,7 @@ async function update(opts = {}) {
   fetchSpin.succeed(`Latest: ${latest}`);
   let minVersion = DEFAULT_UPDATE_CONFIG.minVersion;
   try {
-    minVersion = loadProjectInfo3(process.cwd()).config.update.minVersion;
+    minVersion = loadProjectInfo4(process.cwd()).config.update.minVersion;
   } catch {
   }
   const target = buildUpdateTarget({
@@ -1278,7 +1602,7 @@ var init_update = __esm({
 });
 
 // src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo4, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo5, NOIR_VERSION as NOIR_VERSION2 } from "@noir-ai/core";
 async function tryTool(caller, name, args) {
   try {
     return await caller.callTool(name, args);
@@ -1399,7 +1723,7 @@ function renderHuman(p, opts) {
 async function gatherStatusPayload(opts) {
   let project;
   try {
-    project = loadProjectInfo4(process.cwd());
+    project = loadProjectInfo5(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -1429,7 +1753,7 @@ async function status(opts) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo4(process.cwd());
+        const info2 = loadProjectInfo5(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -1458,7 +1782,7 @@ var init_status = __esm({
 // src/commands/task.ts
 import { spawnSync } from "child_process";
 import { writeFileSync } from "fs";
-import { loadProjectInfo as loadProjectInfo5, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo6, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
 import {
   PHASES,
   TASK_CLASSES,
@@ -1471,7 +1795,7 @@ function skillFor(phase) {
 }
 function writeDoneArtifacts(opts, taskId) {
   try {
-    const project = loadProjectInfo5(process.cwd());
+    const project = loadProjectInfo6(process.cwd());
     const conflict = { conflictPolicy: "preserve", interactive: false };
     writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
     const nextN = nextArtifactSequence(project.root, "adr");
@@ -1794,7 +2118,7 @@ function runCheck(cmd) {
 async function taskVerify(opts) {
   let project;
   try {
-    project = loadProjectInfo5(process.cwd());
+    project = loadProjectInfo6(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -2000,13 +2324,13 @@ var init_task = __esm({
 
 // src/commands/handoff.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import {
   defaultHandoffBlock,
   hostLaunchDirective,
-  resolveAdapter
+  resolveAdapter as resolveAdapter2
 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo6, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo7, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
 function heading(name, id) {
   return `# Noir handoff \u2014 ${name} (${id})`;
 }
@@ -2102,7 +2426,7 @@ function toHostPayload(p) {
 }
 function resolveDirective(root, p) {
   const ctx = { root };
-  const adapter = resolveAdapter(p.host);
+  const adapter = resolveAdapter2(p.host);
   const hostPayload = toHostPayload(p);
   if (typeof adapter.emitHandoff === "function") {
     return adapter.emitHandoff(ctx, hostPayload);
@@ -2145,7 +2469,7 @@ async function probeOnly(opts) {
 async function handoff(opts) {
   let project;
   try {
-    project = loadProjectInfo6(process.cwd());
+    project = loadProjectInfo7(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -2177,7 +2501,7 @@ async function handoff(opts) {
   if (opts.write === true) {
     const md = renderMarkdown(full);
     const path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync2(join2(project.root, NOIR_DIR, "handoff"), { recursive: true });
+    mkdirSync2(join3(project.root, NOIR_DIR, "handoff"), { recursive: true });
     writeFileSync2(path, md, "utf8");
     info(`handoff written to ${path}`, opts);
   }
@@ -2509,14 +2833,14 @@ import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
 import {
   detectActiveMethod as detectActiveMethod3,
   latestVersionFromCache,
-  loadProjectInfo as loadProjectInfo7,
+  loadProjectInfo as loadProjectInfo8,
   NOIR_VERSION as NOIR_VERSION3,
   readInstallRecord as readInstallRecord3,
   readUpdateCache as readUpdateCache2
 } from "@noir-ai/core";
 function tryProject() {
   try {
-    const info2 = loadProjectInfo7(process.cwd());
+    const info2 = loadProjectInfo8(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -2679,7 +3003,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo7(process.cwd());
+        const info2 = loadProjectInfo8(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -2741,6 +3065,27 @@ var init_home = __esm({
 });
 
 // src/commands/memory.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
+function resolveWorkspace() {
+  const routing = workspaceRoutingTarget(process.cwd());
+  if (routing === null) return null;
+  try {
+    return { routing, project: loadProjectInfo9(process.cwd()) };
+  } catch {
+    return null;
+  }
+}
+async function callMemory(opts, name, args = {}) {
+  const ws = resolveWorkspace();
+  if (ws === null) return callDaemonTool(opts, name, args);
+  return withWorkspaceDaemon(opts, ws.routing, (caller) => caller.callTool(name, args));
+}
+async function withMemoryDaemon(opts, fn) {
+  const ws = resolveWorkspace();
+  if (ws === null) return withDaemon(opts, fn);
+  return withWorkspaceDaemon(opts, ws.routing, fn);
+}
 function parseLimit2(raw, label, opts) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
@@ -2779,6 +3124,39 @@ function stamp(ts) {
 }
 async function memoryRecall(opts) {
   const limit = parseLimit2(opts.limit, "memory recall", opts);
+  const ws = resolveWorkspace();
+  if (ws !== null) {
+    const probe2 = await probeWorkspaceDaemon(ws.routing);
+    if (!probe2.running) {
+      await withWorkspaceMemoryRead(opts, ws.routing, ws.project, async (memory) => {
+        const { hits: hits3, degraded, mode } = await memory.recallWithMeta(opts.query, {
+          ...limit === void 0 ? {} : { limit }
+        });
+        const data3 = { query: opts.query, hits: hits3, degraded, mode };
+        if (opts.json === true) {
+          process.stdout.write(`${JSON.stringify({ ok: true, data: data3 })}
+`);
+          return;
+        }
+        renderRecall(data3.query, data3.hits, data3.degraded, opts);
+      });
+      return;
+    }
+    const res2 = await callMemory(opts, "memory_recall", {
+      query: opts.query,
+      ...limit === void 0 ? {} : { limit }
+    });
+    if (res2.ok !== true) failTool2("memory recall", res2, opts);
+    const hits2 = Array.isArray(res2.results) ? res2.results.map(toHit2) : [];
+    const data2 = { query: opts.query, hits: hits2, degraded: res2.degraded === true };
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
+`);
+      return;
+    }
+    renderRecall(data2.query, hits2, data2.degraded, opts);
+    return;
+  }
   let probe;
   try {
     probe = await probeDaemon(opts);
@@ -2840,7 +3218,7 @@ async function memorySave(opts) {
   const args = { content };
   if (typeof opts.type === "string" && opts.type.length > 0) args.type = opts.type;
   if (files !== void 0) args.files = files;
-  const res = await callDaemonTool(opts, "memory_save", args);
+  const res = await callMemory(opts, "memory_save", args);
   if (res.ok !== true) failTool2("memory save", res, opts);
   const id = typeof res.id === "string" ? res.id : "";
   const observation = res.observation ?? {};
@@ -2884,7 +3262,98 @@ function renderObservation(obs, opts) {
   if (typeof content === "string") log(`
 ${content}`, opts);
 }
+async function memoryCapture(opts) {
+  const content = await resolveCaptureContent(opts);
+  const args = { content };
+  if (typeof opts.eventType === "string" && opts.eventType.length > 0)
+    args.eventType = opts.eventType;
+  const res = await callMemory(opts, "memory_capture", args);
+  if (res.ok !== true) failTool2("memory capture", res, opts);
+  const id = typeof res.id === "string" ? res.id : "";
+  const observation = res.observation ?? {};
+  if (opts.json === true) {
+    process.stdout.write(`${JSON.stringify({ ok: true, data: { id, observation } })}
+`);
+    return;
+  }
+  log(`Captured memory ${id}.`, opts);
+  renderObservation(observation, opts);
+}
+async function resolveCaptureContent(opts) {
+  if (typeof opts.content === "string" && opts.content.length > 0) return opts.content;
+  if (typeof opts.file === "string" && opts.file.length > 0) {
+    try {
+      return readFileSync2(opts.file, "utf8");
+    } catch {
+      fail(EXIT.USAGE, `memory capture could not read --file ${opts.file}`, opts);
+    }
+  }
+  if (!process.stdin.isTTY) {
+    try {
+      return readFileSync2(0, "utf8");
+    } catch {
+      fail(
+        EXIT.USAGE,
+        "memory capture could not read piped stdin \u2014 pass --content <text> or --file <path>.",
+        opts
+      );
+    }
+  }
+  if (!isInteractive(opts)) {
+    fail(
+      EXIT.USAGE,
+      "memory capture requires --content <text> or --file <path> (or piped stdin).",
+      opts
+    );
+  }
+  const clack = await import("@clack/prompts");
+  const value = await clack.text({ message: "Captured memory content:" });
+  if (clack.isCancel(value)) {
+    clack.cancel("Cancelled.");
+    fail(EXIT.CANCELLED, "cancelled", opts);
+  }
+  return String(value);
+}
 async function memorySessions(opts) {
+  const ws = resolveWorkspace();
+  if (ws !== null) {
+    const probe2 = await probeWorkspaceDaemon(ws.routing);
+    if (!probe2.running) {
+      await withWorkspaceMemoryRead(opts, ws.routing, ws.project, async (memory) => {
+        const sessions3 = memory.sessions().map((s) => ({
+          id: s.id,
+          count: s.count,
+          lastTs: s.lastTs
+        }));
+        const data3 = { sessions: sessions3 };
+        if (opts.json === true) {
+          process.stdout.write(`${JSON.stringify({ ok: true, data: data3 })}
+`);
+          return;
+        }
+        renderSessions(sessions3, opts);
+      });
+      return;
+    }
+    const res2 = await callMemory(opts, "memory_sessions");
+    if (res2.ok !== true) failTool2("memory sessions", res2, opts);
+    const sessions2 = Array.isArray(res2.sessions) ? res2.sessions.map((raw) => {
+      const s = raw ?? {};
+      return {
+        id: typeof s.id === "string" ? s.id : "",
+        count: typeof s.count === "number" ? s.count : 0,
+        lastTs: typeof s.lastTs === "number" ? s.lastTs : 0
+      };
+    }) : [];
+    const data2 = { sessions: sessions2 };
+    if (opts.json === true) {
+      process.stdout.write(`${JSON.stringify({ ok: true, data: data2 })}
+`);
+      return;
+    }
+    renderSessions(sessions2, opts);
+    return;
+  }
   let probe;
   try {
     probe = await probeDaemon(opts);
@@ -2939,7 +3408,7 @@ async function memoryForget(opts) {
   if (opts.ids.length === 0) {
     fail(EXIT.USAGE, "memory forget requires at least one <id>", opts);
   }
-  const res = await callDaemonTool(opts, "memory_forget", {
+  const res = await callMemory(opts, "memory_forget", {
     ids: opts.ids
   });
   if (res.ok !== true) failTool2("memory forget", res, opts);
@@ -2953,11 +3422,11 @@ async function memoryForget(opts) {
   log(`Forgot ${deleted} observation${deleted === 1 ? "" : "s"}.`, opts);
 }
 async function memoryConsolidate(opts) {
-  const exposed = await withDaemon(opts, async (caller) => caller.listTools());
+  const exposed = await withMemoryDaemon(opts, async (caller) => caller.listTools());
   if (!exposed.includes("memory_consolidate")) {
     fail(
       EXIT.ERROR,
-      "memory consolidate: the daemon does not expose the memory_consolidate tool. Enable it in .noir/config under memory.consolidation (enabled: true + a provider + model), then restart the daemon.",
+      resolveWorkspace() !== null ? "memory consolidate is not supported on shared workspaces (the workspace memory store has no consolidation model)." : "memory consolidate: the daemon does not expose the memory_consolidate tool. Enable it in .noir/config under memory.consolidation (enabled: true + a provider + model), then restart the daemon.",
       opts
     );
   }
@@ -2966,7 +3435,7 @@ async function memoryConsolidate(opts) {
   const args = {};
   if (types !== void 0) args.types = types;
   if (limit !== void 0) args.limit = limit;
-  const res = await callDaemonTool(
+  const res = await callMemory(
     opts,
     "memory_consolidate",
     args
@@ -3485,10 +3954,10 @@ var init_orchestrator = __esm({
 });
 
 // src/run-profiles.ts
-import { loadProjectInfo as loadProjectInfo8 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
 function loadRunConfig(root) {
   try {
-    return loadProjectInfo8(root).config;
+    return loadProjectInfo10(root).config;
   } catch {
     return null;
   }
@@ -3542,7 +4011,7 @@ var init_run_profiles = __esm({
 
 // src/commands/run.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
 import { parseConfig } from "@noir-ai/core";
 function formatUsage(u) {
@@ -3636,8 +4105,8 @@ function mergeEnv(base, overlay) {
 }
 function writeTranscript(host, lines) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dir = join3(process.cwd(), ".noir", "transcripts");
-  const file = join3(dir, `${host}-${ts}.jsonl`);
+  const dir = join4(process.cwd(), ".noir", "transcripts");
+  const file = join4(dir, `${host}-${ts}.jsonl`);
   try {
     mkdirSync3(dir, { recursive: true, mode: 448 });
     writeFileSync3(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
@@ -3656,8 +4125,8 @@ var init_run = __esm({
 });
 
 // src/commands/skills.ts
-import { resolveAdapter as resolveAdapter2 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
@@ -3725,11 +4194,11 @@ async function skillsSync(opts) {
   const root = process.cwd();
   let project;
   try {
-    project = loadProjectInfo9(root);
+    project = loadProjectInfo11(root);
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
-  const adapter = resolveAdapter2(project.config.host);
+  const adapter = resolveAdapter3(project.config.host);
   if (!adapter.skillsDir) {
     const data2 = {
       emitted: [],
@@ -4001,8 +4470,8 @@ var init_conflict = __esm({
 });
 
 // src/dedup-write.ts
-import { mkdirSync as mkdirSync4, readFileSync, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
 async function checkWritePathDedup(root, res, opts) {
   const result = { found: [], conflicts: [] };
@@ -4013,10 +4482,10 @@ async function checkWritePathDedup(root, res, opts) {
   if (embed === void 0) return result;
   const cachedEmbed = makeCachedEmbed(cache, embed);
   for (const proposedRel of writtenHostFiles) {
-    const proposedAbs = join4(root, proposedRel);
+    const proposedAbs = join5(root, proposedRel);
     let proposedText;
     try {
-      proposedText = readFileSync(proposedAbs, "utf8");
+      proposedText = readFileSync3(proposedAbs, "utf8");
     } catch {
       continue;
     }
@@ -4060,7 +4529,7 @@ async function checkWritePathDedup(root, res, opts) {
 `
       );
     }
-    const matchedText = safeRead(join4(root, matchedRel));
+    const matchedText = safeRead(join5(root, matchedRel));
     result.conflicts.push({
       path: proposedRel,
       mode: "artifact",
@@ -4144,21 +4613,21 @@ async function promptDedupAction(root, proposedRel, matchedRel, proposedText, si
   if (clack.isCancel(choice)) return "preserve";
   if (choice === "skip") {
     try {
-      rmSync(join4(root, proposedRel), { force: true });
+      rmSync(join5(root, proposedRel), { force: true });
     } catch {
     }
     return "preserve";
   } else if (choice === "replace") {
     try {
-      writeFileSync4(join4(root, matchedRel), proposedText, "utf8");
+      writeFileSync4(join5(root, matchedRel), proposedText, "utf8");
     } catch {
     }
     return "replace";
   } else if (choice === "mirror") {
     try {
-      const existing = readFileSync(join4(root, matchedRel), "utf8");
+      const existing = readFileSync3(join5(root, matchedRel), "utf8");
       writeFileSync4(
-        join4(root, matchedRel),
+        join5(root, matchedRel),
         `${existing}
 
 <!-- mirrored from ${proposedRel} -->
@@ -4176,11 +4645,11 @@ function emptyCache() {
   return { version: DEDUP_CACHE_VERSION, model: "", entries: {} };
 }
 function cachePath(root) {
-  return join4(root, ".noir", "dedup-cache.json");
+  return join5(root, ".noir", "dedup-cache.json");
 }
 function loadCache(root) {
   try {
-    const raw = readFileSync(cachePath(root), "utf8");
+    const raw = readFileSync3(cachePath(root), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== DEDUP_CACHE_VERSION) return emptyCache();
     if (typeof parsed.entries !== "object" || parsed.entries === null) return emptyCache();
@@ -4195,7 +4664,7 @@ function loadCache(root) {
 }
 function saveCache(root, cache) {
   try {
-    mkdirSync4(join4(root, ".noir"), { recursive: true });
+    mkdirSync4(join5(root, ".noir"), { recursive: true });
     writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
   } catch {
   }
@@ -4212,7 +4681,7 @@ function makeCachedEmbed(cache, embed) {
 }
 function safeRead(abs) {
   try {
-    return readFileSync(abs, "utf8");
+    return readFileSync3(abs, "utf8");
   } catch {
     return void 0;
   }
@@ -4250,8 +4719,8 @@ var init_dedup_write = __esm({
 });
 
 // src/init.ts
-import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
 import { scaffold } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
 async function init(root, opts) {
@@ -4280,7 +4749,7 @@ async function init(root, opts) {
   await emitHostSkills(root, host, conflictOpts, interactive);
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo10(root);
+    projectInfo = loadProjectInfo12(root);
   } catch {
     projectInfo = void 0;
   }
@@ -4311,7 +4780,7 @@ function reportPlannedWrites(res) {
   }
 }
 async function emitHostSkills(root, host, conflictOpts, interactive) {
-  const adapter = resolveAdapter3(host);
+  const adapter = resolveAdapter4(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
     process.stderr.write(`host '${host}' has no skill emitter; skipping skills
@@ -4367,11 +4836,11 @@ var init_init = __esm({
 });
 
 // src/serve.ts
-import { applyNoirEnv, loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
+import { applyNoirEnv, loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
 import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
 async function serve(opts) {
   applyNoirEnv(process.cwd());
-  const project = loadProjectInfo11(process.cwd());
+  const project = loadProjectInfo13(process.cwd());
   if (opts.stdio) {
     await startStdioServer({ project, transport: "stdio", daemon: false });
     return;
@@ -4405,8 +4874,8 @@ __export(create_exports, {
   create: () => create
 });
 import { resolve } from "path";
-import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo14 } from "@noir-ai/core";
 import { scaffold as scaffold2 } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir3 } from "@noir-ai/skills";
 async function create(dir, opts) {
@@ -4432,7 +4901,7 @@ async function create(dir, opts) {
     return res;
   }
   if (res.noop) return res;
-  const adapter = resolveAdapter4(host);
+  const adapter = resolveAdapter5(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
     process.stderr.write(`host '${host}' has no skill emitter; skipping skills
@@ -4457,7 +4926,7 @@ async function create(dir, opts) {
   }
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo12(root);
+    projectInfo = loadProjectInfo14(root);
   } catch {
     projectInfo = void 0;
   }
@@ -4483,9 +4952,9 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import { existsSync } from "fs";
-import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo13, paths } from "@noir-ai/core";
+import { existsSync as existsSync2 } from "fs";
+import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo15, paths } from "@noir-ai/core";
 import { scaffold as scaffold3 } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir4 } from "@noir-ai/skills";
 async function sync(root, opts = {}) {
@@ -4494,7 +4963,7 @@ async function sync(root, opts = {}) {
   const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo13(root);
+    projectInfo = loadProjectInfo15(root);
   } catch {
     projectInfo = void 0;
   }
@@ -4516,7 +4985,7 @@ async function sync(root, opts = {}) {
   if (res.written.length === 0 && res.identical.length > 0) {
     process.stderr.write("Nothing to sync (Noir-managed files are up to date).\n");
   }
-  const adapter = resolveAdapter5(host);
+  const adapter = resolveAdapter6(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
     process.stderr.write(`host '${host}' has no skill emitter; skipping skills
@@ -4552,9 +5021,9 @@ async function sync(root, opts = {}) {
 }
 function resolveSyncHost(root, opts) {
   if (opts.host !== void 0) return opts.host;
-  if (!existsSync(paths.config(root))) return "claude";
+  if (!existsSync2(paths.config(root))) return "claude";
   try {
-    return loadProjectInfo13(root).config.host;
+    return loadProjectInfo15(root).config.host;
   } catch {
     return "claude";
   }
@@ -4785,30 +5254,75 @@ function createProgram() {
     throw new NoirCliError(EXIT.USAGE, "Usage: noir mcp serve [--stdio]");
   });
   const daemonGrp = program2.command("daemon").description("control the Noir daemon");
-  daemonGrp.command("start").description("start the Noir daemon (foreground, or background with --detach)").option("--detach", "run the daemon in the background and exit").addOption(
+  daemonGrp.command("start").description("start the Noir daemon (foreground, or background with --detach)").option("--detach", "run the daemon in the background and exit").option("--workspace <name>", "start a shared cross-repo workspace daemon instead").option("--force", "overwrite a non-Noir .mcp.json entry (--workspace only)").addOption(
     new Option("--_detached-child", "reserved: detached daemon child (internal)").hideHelp()
   ).action(async (...args) => {
     const cmd = trailingCmd(args);
     const g = cmd.optsWithGlobals();
     const detach = g.detach === true;
     const detachChild = g._detachedChild === true;
+    const workspace = typeof g.workspace === "string" ? g.workspace : void 0;
     await daemonStart({
       ...toCliOptions(g),
       ...detach ? { detach } : {},
-      ...detachChild ? { detachChild } : {}
+      ...detachChild ? { detachChild } : {},
+      ...workspace !== void 0 ? { workspace } : {},
+      ...g.force === true ? { force: true } : {}
     });
   });
+  daemonGrp.command("join").description("join a shared workspace from this repo").argument("<name>", "workspace name").option("--force", "overwrite a non-Noir .mcp.json entry").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const name = typeof args[0] === "string" ? args[0] : "";
+    await daemonJoin({ ...toCliOptions(g), name, ...g.force === true ? { force: true } : {} });
+  });
   daemonGrp.command("stop").description("stop the Noir daemon").action(async (...args) => {
     await daemonStop(toCliOptions(trailingCmd(args).optsWithGlobals()));
   });
   daemonGrp.command("status").description("report daemon pid/uptime/mode (exit 4 if not running)").action(async (...args) => {
     await daemonStatus(toCliOptions(trailingCmd(args).optsWithGlobals()));
   });
-  daemonGrp.command("restart").description("stop then start the daemon").action(async (...args) => {
-    await daemonRestart(toCliOptions(trailingCmd(args).optsWithGlobals()));
+  daemonGrp.command("restart").description("stop then start the daemon").option("--detach", "run the daemon in the background and exit").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    await daemonRestart({
+      ...toCliOptions(g),
+      ...g.detach === true ? { detach: true } : {}
+    });
   });
   daemonGrp.action(() => {
-    throw new NoirCliError(EXIT.USAGE, "Usage: noir daemon start|stop|status|restart");
+    throw new NoirCliError(EXIT.USAGE, "Usage: noir daemon start|join|stop|status|restart");
+  });
+  const workspaceGrp = program2.command("workspace").description("shared cross-repo workspaces");
+  workspaceGrp.command("list").description("list workspaces on this machine").action(async (...args) => {
+    await workspaceList(toCliOptions(trailingCmd(args).optsWithGlobals()));
+  });
+  workspaceGrp.command("status").description("members + daemon liveness for a workspace").argument("[name]", "workspace name (defaults to this repo's joined workspace)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const name = typeof args[0] === "string" && args[0].length > 0 ? args[0] : void 0;
+    await workspaceStatus({
+      ...toCliOptions(cmd.optsWithGlobals()),
+      ...name !== void 0 ? { name } : {}
+    });
+  });
+  workspaceGrp.command("leave").description("leave the workspace this repo joined (restore stdio)").option("--force", "overwrite a non-Noir .mcp.json entry").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    await workspaceLeave({
+      ...toCliOptions(g),
+      ...g.force === true ? { force: true } : {}
+    });
+  });
+  workspaceGrp.command("stop").description("stop a workspace daemon (membership retained)").argument("[name]", "workspace name (defaults to this repo's joined workspace)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const name = typeof args[0] === "string" && args[0].length > 0 ? args[0] : void 0;
+    await workspaceStop({
+      ...toCliOptions(cmd.optsWithGlobals()),
+      ...name !== void 0 ? { name } : {}
+    });
+  });
+  workspaceGrp.action(() => {
+    throw new NoirCliError(EXIT.USAGE, "Usage: noir workspace list|status|leave|stop");
   });
   program2.command("doctor").description("environment + project health").option(
     "--dedup",
@@ -4904,10 +5418,23 @@ function createProgram() {
       ...limit === void 0 ? {} : { limit }
     });
   });
+  memoryGrp.command("capture").description("distill a transcript/notes file (or stdin) into a memory (manual)").argument("[file]", "transcript/notes file (or pipe stdin)").option("--content <text>", "inline distilled content").option("--event-type <type>", "capture hook label (defaults to Stop)").action(async (...args) => {
+    const cmd = trailingCmd(args);
+    const g = cmd.optsWithGlobals();
+    const file = typeof args[0] === "string" && args[0].length > 0 ? args[0] : void 0;
+    const content = typeof g.content === "string" ? g.content : void 0;
+    const eventType = typeof g.eventType === "string" ? g.eventType : void 0;
+    await memoryCapture({
+      ...toCliOptions(g),
+      ...file === void 0 ? {} : { file },
+      ...content === void 0 ? {} : { content },
+      ...eventType === void 0 ? {} : { eventType }
+    });
+  });
   memoryGrp.action(() => {
     throw new NoirCliError(
       EXIT.USAGE,
-      "Usage: noir memory recall|save|sessions|forget|consolidate"
+      "Usage: noir memory recall|save|capture|sessions|forget|consolidate"
     );
   });
   const skillsGrp = program2.command("skills").description("builtin skills");
@@ -5201,6 +5728,7 @@ var init_bin = __esm({
     init_skills();
     init_status();
     init_task();
+    init_workspace();
     init_init();
     init_output();
     init_run_profiles();
@@ -5240,11 +5768,17 @@ var init_bin = __esm({
 // src/daemon-client.ts
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ContextEngine, createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
-import { loadProjectInfo as loadProjectInfo14, NOIR_VERSION as NOIR_VERSION5 } from "@noir-ai/core";
+import {
+  loadProjectInfo as loadProjectInfo16,
+  NOIR_VERSION as NOIR_VERSION5,
+  readWorkspaceMarker as readWorkspaceMarker2,
+  workspaceStoreDbPath
+} from "@noir-ai/core";
 import {
   ensureDaemonRunning as ensureDaemonRunning3,
-  pidAlive as pidAlive2,
+  pidAlive as pidAlive3,
   readDaemonRecord as readDaemonRecord2,
+  readWorkspaceDaemonRecord as readWorkspaceDaemonRecord2,
   resolveGateConfig
 } from "@noir-ai/daemon";
 import { createMemoryEngine } from "@noir-ai/memory";
@@ -5271,7 +5805,7 @@ async function probeDaemon(opts = {}) {
     if (opts.verbose) process.stderr.write("noir: daemon probe: no daemon record\n");
     return { running: false };
   }
-  if (!pidAlive2(rec.pid)) {
+  if (!pidAlive3(rec.pid)) {
     if (opts.verbose) process.stderr.write(`noir: daemon probe: pid ${rec.pid} not alive
 `);
     return { running: false };
@@ -5289,7 +5823,7 @@ async function probeDaemon(opts = {}) {
     const pidOk = typeof body?.pid === "number" && body.pid === rec.pid;
     const expectedProject = opts.project?.id ?? (() => {
       try {
-        return loadProjectInfo14(process.cwd()).id;
+        return loadProjectInfo16(process.cwd()).id;
       } catch {
         return void 0;
       }
@@ -5319,7 +5853,7 @@ async function probeDaemon(opts = {}) {
 async function resolveDaemon(opts) {
   let project;
   try {
-    project = opts.project ?? loadProjectInfo14(process.cwd());
+    project = opts.project ?? loadProjectInfo16(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -5415,7 +5949,7 @@ async function callDaemonTool(opts, name, args = {}) {
 async function withInProcessRead(opts, fn) {
   let project;
   try {
-    project = opts.project ?? loadProjectInfo14(process.cwd());
+    project = opts.project ?? loadProjectInfo16(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -5458,6 +5992,91 @@ async function withInProcessRead(opts, fn) {
     });
   }
 }
+function workspaceRoutingTarget(root) {
+  const name = readWorkspaceMarker2(root);
+  if (name === null) return null;
+  try {
+    return { name, projectId: loadProjectInfo16(root).id };
+  } catch {
+    return null;
+  }
+}
+async function probeWorkspaceDaemon(routing) {
+  const rec = readWorkspaceDaemonRecord2(routing.name);
+  if (rec === null || !pidAlive3(rec.pid)) return { running: false };
+  try {
+    const res = await fetch(`http://127.0.0.1:${rec.port}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+    if (!res.ok) return { running: false };
+    const body = await res.json().catch(() => null);
+    if (body?.ok !== true || body.workspace !== routing.name || body.pid !== rec.pid) {
+      return { running: false };
+    }
+    return { running: true, pid: rec.pid, port: rec.port };
+  } catch {
+    return { running: false };
+  }
+}
+async function withWorkspaceDaemon(opts, routing, fn) {
+  const probe = await probeWorkspaceDaemon(routing);
+  if (!probe.running || probe.port === void 0) {
+    fail(
+      EXIT.DAEMON_DOWN,
+      `workspace ${JSON.stringify(routing.name)} daemon is not running \u2014 start it with \`noir daemon start --workspace ${routing.name}\` (or run \`noir workspace status\`).`,
+      opts
+    );
+  }
+  const url = `http://127.0.0.1:${probe.port}/mcp?p=${routing.projectId}`;
+  let client;
+  try {
+    client = new Client(
+      { name: "noir-cli", version: NOIR_VERSION5 },
+      { versionNegotiation: { mode: "auto" } }
+    );
+    const connected = client;
+    await connectClient(connected, url, opts);
+    return await fn(buildCaller(connected, opts));
+  } finally {
+    if (client) {
+      await client.close().catch(() => {
+      });
+    }
+  }
+}
+async function withWorkspaceMemoryRead(opts, routing, project, fn) {
+  let store;
+  try {
+    store = await openStore({
+      projectId: `ws-${routing.name}`,
+      root: project.root,
+      dbPath: workspaceStoreDbPath(routing.name),
+      readonly: true
+    });
+  } catch (err) {
+    fail(
+      EXIT.DAEMON_DOWN,
+      `workspace ${JSON.stringify(routing.name)} store is unavailable (${err instanceof Error ? err.message : String(err)}) \u2014 start its daemon with \`noir daemon start --workspace ${routing.name}\` (or run \`noir workspace status\`).`,
+      opts
+    );
+  }
+  const embedderCfg = resolveEmbedderConfig(project.config.context);
+  const embed = createEmbedFn(embedderCfg).embed;
+  const memory = createMemoryEngine({
+    store,
+    root: project.root,
+    projectId: `ws-${routing.name}`,
+    embed,
+    storeDegraded: true,
+    softForget: true
+  });
+  try {
+    return await fn(memory);
+  } finally {
+    await store.close().catch(() => {
+    });
+  }
+}
 var DAEMON_DOWN_HINT, PROBE_TIMEOUT_MS;
 var init_daemon_client = __esm({
   "src/daemon-client.ts"() {
@@ -5470,21 +6089,21 @@ var init_daemon_client = __esm({
 
 // src/commands/doctor.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { dirname, join as join5, relative } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
+import { dirname, join as join6, relative } from "path";
 import { fileURLToPath } from "url";
-import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
+import { resolveAdapter as resolveAdapter7 } from "@noir-ai/adapters";
 import {
   detectActiveMethod as detectActiveMethod4,
   latestVersionFromCache as latestVersionFromCache2,
-  loadProjectInfo as loadProjectInfo15,
+  loadProjectInfo as loadProjectInfo17,
   NOIR_VERSION as NOIR_VERSION6,
   paths as paths2,
   readInstallRecord as readInstallRecord4,
   readUpdateCache as readUpdateCache3
 } from "@noir-ai/core";
 import { CURRENT_SCAFFOLD_VERSION, readScaffoldVersion } from "@noir-ai/create";
-import { pidAlive as pidAlive3, readDaemonRecord as readDaemonRecord3 } from "@noir-ai/daemon";
+import { pidAlive as pidAlive4, readDaemonRecord as readDaemonRecord3 } from "@noir-ai/daemon";
 import { resolveModelConfig } from "@noir-ai/model";
 async function probeOnnx() {
   try {
@@ -5521,7 +6140,7 @@ async function checkRuntime(checks) {
 }
 function checkConfig(root) {
   const configPath = paths2.config(root);
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     return {
       project: void 0,
       result: {
@@ -5532,7 +6151,7 @@ function checkConfig(root) {
     };
   }
   try {
-    const project = loadProjectInfo15(root);
+    const project = loadProjectInfo17(root);
     return {
       project,
       result: {
@@ -5558,7 +6177,7 @@ async function checkDaemon(checks) {
     });
     return;
   }
-  if (!pidAlive3(rec.pid)) {
+  if (!pidAlive4(rec.pid)) {
     checks.push({
       name: "daemon",
       status: "warn",
@@ -5613,7 +6232,7 @@ async function checkStore(checks, project, root) {
     return;
   }
   const dbPath = paths2.storeDb(root, project.id);
-  if (!existsSync2(dbPath)) {
+  if (!existsSync3(dbPath)) {
     checks.push({
       name: "store",
       status: "warn",
@@ -5642,7 +6261,7 @@ async function checkStore(checks, project, root) {
   }
 }
 function checkNoirEnv(checks, root) {
-  const path = join5(paths2.noirDir(root), ".env");
+  const path = join6(paths2.noirDir(root), ".env");
   let st;
   try {
     st = statSync(path);
@@ -5752,7 +6371,7 @@ function checkRulesMdBudget(checks, root, project) {
     return null;
   }
   const rulesPath = paths2.rulesMd(root);
-  if (!existsSync2(rulesPath)) {
+  if (!existsSync3(rulesPath)) {
     checks.push({
       name: "rules budget",
       status: "ok",
@@ -5762,7 +6381,7 @@ function checkRulesMdBudget(checks, root, project) {
   }
   let content;
   try {
-    content = readFileSync2(rulesPath, "utf8");
+    content = readFileSync4(rulesPath, "utf8");
   } catch (e) {
     checks.push({
       name: "rules budget",
@@ -5806,7 +6425,7 @@ function checkHostArtifacts(checks, root, project) {
     return null;
   }
   const host = project.config.host;
-  const adapter = resolveAdapter6(host);
+  const adapter = resolveAdapter7(host);
   const ectx = { root };
   const expected = [];
   const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
@@ -5816,7 +6435,7 @@ function checkHostArtifacts(checks, root, project) {
   if (host === "claude") expected.push("CLAUDE.md");
   else if (host === "gemini") expected.push("GEMINI.md");
   expected.push(relOr(adapter.mcpConfigPath?.(ectx) ?? ".mcp.json", root));
-  const missing = expected.filter((p) => !existsSync2(joinRoot(root, p)));
+  const missing = expected.filter((p) => !existsSync3(joinRoot(root, p)));
   const status2 = missing.length === 0 ? "ok" : "warn";
   const detail = missing.length === 0 ? `host=${host} \xB7 all ${expected.length} primary artifacts present` : `host=${host} \xB7 missing ${missing.join(", ")} (run \`noir sync\` to restore)`;
   checks.push({ name: "host artifacts", status: status2, detail });
@@ -5833,7 +6452,7 @@ function checkNestedNoir(checks, root) {
     ".noir/.npmignore",
     ".noir/.prettierignore"
   ];
-  const found = candidates.filter((rel) => existsSync2(join5(root, rel)));
+  const found = candidates.filter((rel) => existsSync3(join6(root, rel)));
   const detected = found.length > 0;
   checks.push({
     name: "nested .noir",
@@ -5846,11 +6465,11 @@ function collectDedupCandidates(root) {
   const rels = ["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"];
   const out = [];
   for (const rel of rels) {
-    const abs = join5(root, rel);
-    if (!existsSync2(abs)) continue;
+    const abs = join6(root, rel);
+    if (!existsSync3(abs)) continue;
     let text;
     try {
-      text = readFileSync2(abs, "utf8");
+      text = readFileSync4(abs, "utf8");
     } catch {
       continue;
     }
@@ -5907,13 +6526,13 @@ async function checkSemanticDupDoctor(checks, root, project, opts = {}) {
 function resolveWorkspacePackagesDir() {
   let here = dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 8; i++) {
-    const pkgPath = join5(here, "package.json");
-    if (existsSync2(pkgPath)) {
+    const pkgPath = join6(here, "package.json");
+    if (existsSync3(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
         if (pkg.name === "@noir-ai/cli") {
           const packagesDir = dirname(here);
-          if (existsSync2(join5(dirname(packagesDir), "pnpm-workspace.yaml"))) {
+          if (existsSync3(join6(dirname(packagesDir), "pnpm-workspace.yaml"))) {
             return packagesDir;
           }
           return null;
@@ -5958,7 +6577,7 @@ function checkPublish(checks, packagesDir, opts = {}) {
   }
   let entries = [];
   try {
-    entries = readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    entries = readdirSync2(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch (e) {
     checks.push({
       name: "publish",
@@ -5971,11 +6590,11 @@ function checkPublish(checks, packagesDir, opts = {}) {
   let checked = 0;
   let cliDir = null;
   for (const name of entries) {
-    const pkgPath = join5(packagesDir, name, "package.json");
-    if (!existsSync2(pkgPath)) continue;
+    const pkgPath = join6(packagesDir, name, "package.json");
+    if (!existsSync3(pkgPath)) continue;
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
     } catch (e) {
       issues.push(`${name}/package.json: unparseable (${msg(e)})`);
       checked++;
@@ -5997,7 +6616,7 @@ function checkPublish(checks, packagesDir, opts = {}) {
       if (pkg.bin == null || typeof pkg.bin === "object" && Object.keys(pkg.bin).length === 0) {
         issues.push(`${name}/package.json: bin missing (cli package must declare a bin)`);
       }
-      cliDir = join5(packagesDir, name);
+      cliDir = join6(packagesDir, name);
     }
   }
   let packNote = "";