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

package/dist/bin.js

@@ -17,11 +17,17 @@ var __export = (target, all) => {
 // src/daemon-client.ts
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ContextEngine, createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
-import { loadProjectInfo, NOIR_VERSION } from "@noir-ai/core";
+import {
+  loadProjectInfo,
+  NOIR_VERSION,
+  readWorkspaceMarker,
+  workspaceStoreDbPath
+} from "@noir-ai/core";
 import {
   ensureDaemonRunning,
   pidAlive,
   readDaemonRecord,
+  readWorkspaceDaemonRecord,
   resolveGateConfig
 } from "@noir-ai/daemon";
 import { createMemoryEngine } from "@noir-ai/memory";
@@ -235,6 +241,91 @@ async function withInProcessRead(opts, fn) {
     });
   }
 }
+function workspaceRoutingTarget(root) {
+  const name = readWorkspaceMarker(root);
+  if (name === null) return null;
+  try {
+    return { name, projectId: loadProjectInfo(root).id };
+  } catch {
+    return null;
+  }
+}
+async function probeWorkspaceDaemon(routing) {
+  const rec = readWorkspaceDaemonRecord(routing.name);
+  if (rec === null || !pidAlive(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_VERSION },
+      { 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"() {
@@ -771,12 +862,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 as loadProjectInfo2,
+  readWorkspaceMarker as readWorkspaceMarker2,
+  readWorkspaceRegistry,
+  removeWorkspaceMember,
+  upsertWorkspaceMember,
+  workspaceHomeDir,
+  writeWorkspaceMarker
+} from "@noir-ai/core";
+import {
+  clearWorkspaceDaemonRecord,
+  ensureWorkspaceDaemonRunning,
+  pidAlive as pidAlive2,
+  readWorkspaceDaemonRecord as readWorkspaceDaemonRecord2,
+  spawnDetachedWorkspaceDaemon
+} from "@noir-ai/daemon";
+function loadProjectOrFail(opts) {
+  try {
+    return loadProjectInfo2(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 = readWorkspaceDaemonRecord2(n);
+        return rec !== null && pidAlive2(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 ?? readWorkspaceMarker2(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 = readWorkspaceDaemonRecord2(name);
+  const running = rec !== null && pidAlive2(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 = readWorkspaceMarker2(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 ?? readWorkspaceMarker2(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 = readWorkspaceDaemonRecord2(name);
+  if (rec === null || !pidAlive2(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 as loadProjectInfo2 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo3 } from "@noir-ai/core";
 import {
   clearDaemonRecord,
   ensureDaemonRunning as ensureDaemonRunning2,
-  pidAlive as pidAlive2,
+  pidAlive as pidAlive3,
   readDaemonRecord as readDaemonRecord2,
   spawnDetachedDaemon
 } from "@noir-ai/daemon";
@@ -788,7 +1193,7 @@ function formatUptime(sec) {
 }
 function resolveCallerProjectId() {
   try {
-    return loadProjectInfo2(process.cwd()).id;
+    return loadProjectInfo3(process.cwd()).id;
   } catch {
     return void 0;
   }
@@ -809,9 +1214,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 = loadProjectInfo2(process.cwd());
+    project = loadProjectInfo3(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -842,7 +1256,7 @@ async function daemonStart(opts) {
   }
   if (opts.detach === true) {
     const existing = readDaemonRecord2();
-    if (existing && pidAlive2(existing.pid) && await isHealthy(existing.port, existing.pid, project.id)) {
+    if (existing && pidAlive3(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 } })}
@@ -941,7 +1355,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 && pidAlive2(rec.pid) && await isHealthy(rec.port, rec.pid, rec.projectId === void 0 ? void 0 : callerProject);
+  const healthy = !wrongProject && pidAlive3(rec.pid) && await isHealthy(rec.port, rec.pid, rec.projectId === void 0 ? void 0 : callerProject);
   if (healthy) {
     try {
       process.kill(rec.pid, "SIGTERM");
@@ -987,7 +1401,7 @@ async function daemonStatus(opts) {
       opts
     );
   }
-  if (!pidAlive2(rec.pid)) {
+  if (!pidAlive3(rec.pid)) {
     clearDaemonRecord();
     fail(EXIT.DAEMON_DOWN, "Noir daemon is not running (stale record removed).", opts);
   }
@@ -1045,27 +1459,28 @@ var init_daemon = __esm({
     "use strict";
     init_daemon_client();
     init_output();
+    init_workspace();
     MODE = "foreground";
   }
 });
 
 // src/commands/doctor.ts
 import { spawnSync } from "child_process";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { dirname, join, relative } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { dirname, join as join2, relative } from "path";
 import { fileURLToPath } from "url";
-import { resolveAdapter } from "@noir-ai/adapters";
+import { resolveAdapter as resolveAdapter2 } from "@noir-ai/adapters";
 import {
   detectActiveMethod,
   latestVersionFromCache,
-  loadProjectInfo as loadProjectInfo3,
+  loadProjectInfo as loadProjectInfo4,
   NOIR_VERSION as NOIR_VERSION2,
   paths,
   readInstallRecord,
   readUpdateCache
 } 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 {
@@ -1102,7 +1517,7 @@ async function checkRuntime(checks) {
 }
 function checkConfig(root) {
   const configPath = paths.config(root);
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return {
       project: void 0,
       result: {
@@ -1113,7 +1528,7 @@ function checkConfig(root) {
     };
   }
   try {
-    const project = loadProjectInfo3(root);
+    const project = loadProjectInfo4(root);
     return {
       project,
       result: {
@@ -1139,7 +1554,7 @@ async function checkDaemon(checks) {
     });
     return;
   }
-  if (!pidAlive3(rec.pid)) {
+  if (!pidAlive4(rec.pid)) {
     checks.push({
       name: "daemon",
       status: "warn",
@@ -1194,7 +1609,7 @@ async function checkStore(checks, project, root) {
     return;
   }
   const dbPath = paths.storeDb(root, project.id);
-  if (!existsSync(dbPath)) {
+  if (!existsSync2(dbPath)) {
     checks.push({
       name: "store",
       status: "warn",
@@ -1223,7 +1638,7 @@ async function checkStore(checks, project, root) {
   }
 }
 function checkNoirEnv(checks, root) {
-  const path = join(paths.noirDir(root), ".env");
+  const path = join2(paths.noirDir(root), ".env");
   let st;
   try {
     st = statSync(path);
@@ -1333,7 +1748,7 @@ function checkRulesMdBudget(checks, root, project) {
     return null;
   }
   const rulesPath = paths.rulesMd(root);
-  if (!existsSync(rulesPath)) {
+  if (!existsSync2(rulesPath)) {
     checks.push({
       name: "rules budget",
       status: "ok",
@@ -1343,7 +1758,7 @@ function checkRulesMdBudget(checks, root, project) {
   }
   let content;
   try {
-    content = readFileSync(rulesPath, "utf8");
+    content = readFileSync2(rulesPath, "utf8");
   } catch (e) {
     checks.push({
       name: "rules budget",
@@ -1387,7 +1802,7 @@ function checkHostArtifacts(checks, root, project) {
     return null;
   }
   const host = project.config.host;
-  const adapter = resolveAdapter(host);
+  const adapter = resolveAdapter2(host);
   const ectx = { root };
   const expected = [];
   const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
@@ -1397,7 +1812,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) => !existsSync(joinRoot(root, p)));
+  const missing = expected.filter((p) => !existsSync2(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 });
@@ -1414,7 +1829,7 @@ function checkNestedNoir(checks, root) {
     ".noir/.npmignore",
     ".noir/.prettierignore"
   ];
-  const found = candidates.filter((rel) => existsSync(join(root, rel)));
+  const found = candidates.filter((rel) => existsSync2(join2(root, rel)));
   const detected = found.length > 0;
   checks.push({
     name: "nested .noir",
@@ -1427,11 +1842,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 = join(root, rel);
-    if (!existsSync(abs)) continue;
+    const abs = join2(root, rel);
+    if (!existsSync2(abs)) continue;
     let text;
     try {
-      text = readFileSync(abs, "utf8");
+      text = readFileSync2(abs, "utf8");
     } catch {
       continue;
     }
@@ -1488,13 +1903,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 = join(here, "package.json");
-    if (existsSync(pkgPath)) {
+    const pkgPath = join2(here, "package.json");
+    if (existsSync2(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
         if (pkg.name === "@noir-ai/cli") {
           const packagesDir = dirname(here);
-          if (existsSync(join(dirname(packagesDir), "pnpm-workspace.yaml"))) {
+          if (existsSync2(join2(dirname(packagesDir), "pnpm-workspace.yaml"))) {
             return packagesDir;
           }
           return null;
@@ -1539,7 +1954,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",
@@ -1552,11 +1967,11 @@ function checkPublish(checks, packagesDir, opts = {}) {
   let checked = 0;
   let cliDir = null;
   for (const name of entries) {
-    const pkgPath = join(packagesDir, name, "package.json");
-    if (!existsSync(pkgPath)) continue;
+    const pkgPath = join2(packagesDir, name, "package.json");
+    if (!existsSync2(pkgPath)) continue;
     let pkg;
     try {
-      pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
     } catch (e) {
       issues.push(`${name}/package.json: unparseable (${msg(e)})`);
       checked++;
@@ -1578,7 +1993,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 = join(packagesDir, name);
+      cliDir = join2(packagesDir, name);
     }
   }
   let packNote = "";
@@ -1720,13 +2135,13 @@ __export(install_exports, {
   installManagedNode: () => installManagedNode
 });
 import { chmodSync, mkdirSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import {
-  atomicWriteFile,
+  atomicWriteFile as atomicWriteFile2,
   detectActiveMethod as detectActiveMethod2,
   detectInstallMethods,
   ensureShimExecutable,
-  loadProjectInfo as loadProjectInfo4,
+  loadProjectInfo as loadProjectInfo5,
   MANAGED_NODE_VERSION,
   NOIR_VERSION as NOIR_VERSION3,
   noirHome,
@@ -1772,8 +2187,8 @@ function buildMigrationPlan(opts) {
 async function installManagedNode(opts) {
   const spec = opts.version ?? opts.channel ?? "latest";
   const home2 = noirHome();
-  const cliDir = join2(home2, "cli");
-  const binDir = join2(home2, "bin");
+  const cliDir = join3(home2, "cli");
+  const binDir = join3(home2, "bin");
   mkdirSync(cliDir, { recursive: true });
   mkdirSync(binDir, { recursive: true });
   let runtime;
@@ -1799,17 +2214,17 @@ async function installManagedNode(opts) {
   if (code !== 0) {
     return { ok: false, version: null, error: `npm install failed: ${stderr.slice(0, 300)}` };
   }
-  const shim = join2(binDir, "noir");
+  const shim = join3(binDir, "noir");
   const shimBody = `#!/usr/bin/env bash
-"${nodeBin}" "${join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js")}" "$@"
+"${nodeBin}" "${join3(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,
-      join2(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js"),
+      join3(cliDir, "lib", "node_modules", "@noir-ai", "cli", "dist", "bin.js"),
       "--version"
     ],
     { env: opts.env, timeoutMs: 3e4 }
@@ -1865,7 +2280,7 @@ async function install(opts = {}) {
   const installedRecord = readInstallRecord2();
   let minVersion = "1.6.0";
   try {
-    minVersion = loadProjectInfo4(process.cwd()).config.update.minVersion;
+    minVersion = loadProjectInfo5(process.cwd()).config.update.minVersion;
   } catch {
   }
   const plan = buildMigrationPlan({
@@ -1942,7 +2357,7 @@ import {
   detectActiveMethod as detectActiveMethod3,
   ensureShimExecutable as ensureShimExecutable2,
   fetchLatestVersion,
-  loadProjectInfo as loadProjectInfo5,
+  loadProjectInfo as loadProjectInfo6,
   readInstallRecord as readInstallRecord3,
   readUpdateCache as readUpdateCache2,
   runManagerCmd as runManagerCmd2,
@@ -2022,7 +2437,7 @@ async function update(opts = {}) {
   fetchSpin.succeed(`Latest: ${latest}`);
   let minVersion = DEFAULT_UPDATE_CONFIG.minVersion;
   try {
-    minVersion = loadProjectInfo5(process.cwd()).config.update.minVersion;
+    minVersion = loadProjectInfo6(process.cwd()).config.update.minVersion;
   } catch {
   }
   const target = buildUpdateTarget({
@@ -2172,7 +2587,7 @@ var init_update = __esm({
 });
 
 // src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo6, NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo7, NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
 async function tryTool(caller, name, args) {
   try {
     return await caller.callTool(name, args);
@@ -2293,7 +2708,7 @@ function renderHuman2(p, opts) {
 async function gatherStatusPayload(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);
   }
@@ -2323,7 +2738,7 @@ async function status(opts) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo6(process.cwd());
+        const info2 = loadProjectInfo7(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -2352,7 +2767,7 @@ var init_status = __esm({
 // src/commands/task.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { writeFileSync } from "fs";
-import { loadProjectInfo as loadProjectInfo7, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo8, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
 import {
   PHASES,
   TASK_CLASSES,
@@ -2365,7 +2780,7 @@ function skillFor(phase) {
 }
 function writeDoneArtifacts(opts, taskId) {
   try {
-    const project = loadProjectInfo7(process.cwd());
+    const project = loadProjectInfo8(process.cwd());
     const conflict = { conflictPolicy: "preserve", interactive: false };
     writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
     const nextN = nextArtifactSequence(project.root, "adr");
@@ -2688,7 +3103,7 @@ function runCheck(cmd) {
 async function taskVerify(opts) {
   let project;
   try {
-    project = loadProjectInfo7(process.cwd());
+    project = loadProjectInfo8(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -2894,13 +3309,13 @@ var init_task = __esm({
 
 // src/commands/handoff.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import {
   defaultHandoffBlock,
   hostLaunchDirective,
-  resolveAdapter as resolveAdapter2
+  resolveAdapter as resolveAdapter3
 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo8, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo9, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
 function heading(name, id) {
   return `# Noir handoff \u2014 ${name} (${id})`;
 }
@@ -2996,7 +3411,7 @@ function toHostPayload(p) {
 }
 function resolveDirective(root, p) {
   const ctx = { root };
-  const adapter = resolveAdapter2(p.host);
+  const adapter = resolveAdapter3(p.host);
   const hostPayload = toHostPayload(p);
   if (typeof adapter.emitHandoff === "function") {
     return adapter.emitHandoff(ctx, hostPayload);
@@ -3039,7 +3454,7 @@ async function probeOnly(opts) {
 async function handoff(opts) {
   let project;
   try {
-    project = loadProjectInfo8(process.cwd());
+    project = loadProjectInfo9(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -3071,7 +3486,7 @@ async function handoff(opts) {
   if (opts.write === true) {
     const md = renderMarkdown(full);
     const path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync2(join3(project.root, NOIR_DIR, "handoff"), { recursive: true });
+    mkdirSync2(join4(project.root, NOIR_DIR, "handoff"), { recursive: true });
     writeFileSync2(path, md, "utf8");
     info(`handoff written to ${path}`, opts);
   }
@@ -3403,14 +3818,14 @@ import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
 import {
   detectActiveMethod as detectActiveMethod4,
   latestVersionFromCache as latestVersionFromCache2,
-  loadProjectInfo as loadProjectInfo9,
+  loadProjectInfo as loadProjectInfo10,
   NOIR_VERSION as NOIR_VERSION5,
   readInstallRecord as readInstallRecord4,
   readUpdateCache as readUpdateCache3
 } from "@noir-ai/core";
 function tryProject() {
   try {
-    const info2 = loadProjectInfo9(process.cwd());
+    const info2 = loadProjectInfo10(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -3573,7 +3988,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo9(process.cwd());
+        const info2 = loadProjectInfo10(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -3635,6 +4050,27 @@ var init_home = __esm({
 });
 
 // src/commands/memory.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
+function resolveWorkspace() {
+  const routing = workspaceRoutingTarget(process.cwd());
+  if (routing === null) return null;
+  try {
+    return { routing, project: loadProjectInfo11(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);
@@ -3673,6 +4109,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);
@@ -3734,7 +4203,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 ?? {};
@@ -3778,7 +4247,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 readFileSync3(opts.file, "utf8");
+    } catch {
+      fail(EXIT.USAGE, `memory capture could not read --file ${opts.file}`, opts);
+    }
+  }
+  if (!process.stdin.isTTY) {
+    try {
+      return readFileSync3(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);
@@ -3833,7 +4393,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);
@@ -3847,11 +4407,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
     );
   }
@@ -3860,7 +4420,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
@@ -4379,10 +4939,10 @@ var init_orchestrator = __esm({
 });
 
 // src/run-profiles.ts
-import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo12 } from "@noir-ai/core";
 function loadRunConfig(root) {
   try {
-    return loadProjectInfo10(root).config;
+    return loadProjectInfo12(root).config;
   } catch {
     return null;
   }
@@ -4436,7 +4996,7 @@ var init_run_profiles = __esm({
 
 // src/commands/run.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
 import { parseConfig } from "@noir-ai/core";
 function formatUsage(u) {
@@ -4530,8 +5090,8 @@ function mergeEnv(base, overlay) {
 }
 function writeTranscript(host, lines) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const dir = join4(process.cwd(), ".noir", "transcripts");
-  const file = join4(dir, `${host}-${ts}.jsonl`);
+  const dir = join5(process.cwd(), ".noir", "transcripts");
+  const file = join5(dir, `${host}-${ts}.jsonl`);
   try {
     mkdirSync3(dir, { recursive: true, mode: 448 });
     writeFileSync3(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
@@ -4550,8 +5110,8 @@ var init_run = __esm({
 });
 
 // src/commands/skills.ts
-import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
@@ -4619,11 +5179,11 @@ async function skillsSync(opts) {
   const root = process.cwd();
   let project;
   try {
-    project = loadProjectInfo11(root);
+    project = loadProjectInfo13(root);
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
-  const adapter = resolveAdapter3(project.config.host);
+  const adapter = resolveAdapter4(project.config.host);
   if (!adapter.skillsDir) {
     const data2 = {
       emitted: [],
@@ -4895,8 +5455,8 @@ var init_conflict = __esm({
 });
 
 // src/dedup-write.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
 import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
 async function checkWritePathDedup(root, res, opts) {
   const result = { found: [], conflicts: [] };
@@ -4907,10 +5467,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 = join5(root, proposedRel);
+    const proposedAbs = join6(root, proposedRel);
     let proposedText;
     try {
-      proposedText = readFileSync2(proposedAbs, "utf8");
+      proposedText = readFileSync4(proposedAbs, "utf8");
     } catch {
       continue;
     }
@@ -4954,7 +5514,7 @@ async function checkWritePathDedup(root, res, opts) {
 `
       );
     }
-    const matchedText = safeRead(join5(root, matchedRel));
+    const matchedText = safeRead(join6(root, matchedRel));
     result.conflicts.push({
       path: proposedRel,
       mode: "artifact",
@@ -5038,21 +5598,21 @@ async function promptDedupAction(root, proposedRel, matchedRel, proposedText, si
   if (clack.isCancel(choice)) return "preserve";
   if (choice === "skip") {
     try {
-      rmSync(join5(root, proposedRel), { force: true });
+      rmSync(join6(root, proposedRel), { force: true });
     } catch {
     }
     return "preserve";
   } else if (choice === "replace") {
     try {
-      writeFileSync4(join5(root, matchedRel), proposedText, "utf8");
+      writeFileSync4(join6(root, matchedRel), proposedText, "utf8");
     } catch {
     }
     return "replace";
   } else if (choice === "mirror") {
     try {
-      const existing = readFileSync2(join5(root, matchedRel), "utf8");
+      const existing = readFileSync4(join6(root, matchedRel), "utf8");
       writeFileSync4(
-        join5(root, matchedRel),
+        join6(root, matchedRel),
         `${existing}
 
 <!-- mirrored from ${proposedRel} -->
@@ -5070,11 +5630,11 @@ function emptyCache() {
   return { version: DEDUP_CACHE_VERSION, model: "", entries: {} };
 }
 function cachePath(root) {
-  return join5(root, ".noir", "dedup-cache.json");
+  return join6(root, ".noir", "dedup-cache.json");
 }
 function loadCache(root) {
   try {
-    const raw = readFileSync2(cachePath(root), "utf8");
+    const raw = readFileSync4(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();
@@ -5089,7 +5649,7 @@ function loadCache(root) {
 }
 function saveCache(root, cache) {
   try {
-    mkdirSync4(join5(root, ".noir"), { recursive: true });
+    mkdirSync4(join6(root, ".noir"), { recursive: true });
     writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
   } catch {
   }
@@ -5106,7 +5666,7 @@ function makeCachedEmbed(cache, embed) {
 }
 function safeRead(abs) {
   try {
-    return readFileSync2(abs, "utf8");
+    return readFileSync4(abs, "utf8");
   } catch {
     return void 0;
   }
@@ -5144,8 +5704,8 @@ var init_dedup_write = __esm({
 });
 
 // src/init.ts
-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 } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
 async function init(root, opts) {
@@ -5174,7 +5734,7 @@ async function init(root, opts) {
   await emitHostSkills(root, host, conflictOpts, interactive);
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo12(root);
+    projectInfo = loadProjectInfo14(root);
   } catch {
     projectInfo = void 0;
   }
@@ -5205,7 +5765,7 @@ function reportPlannedWrites(res) {
   }
 }
 async function emitHostSkills(root, host, conflictOpts, interactive) {
-  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
@@ -5261,11 +5821,11 @@ var init_init = __esm({
 });
 
 // src/serve.ts
-import { applyNoirEnv, loadProjectInfo as loadProjectInfo13 } from "@noir-ai/core";
+import { applyNoirEnv, loadProjectInfo as loadProjectInfo15 } from "@noir-ai/core";
 import { ensureDaemonRunning as ensureDaemonRunning3, startStdioServer } from "@noir-ai/daemon";
 async function serve(opts) {
   applyNoirEnv(process.cwd());
-  const project = loadProjectInfo13(process.cwd());
+  const project = loadProjectInfo15(process.cwd());
   if (opts.stdio) {
     await startStdioServer({ project, transport: "stdio", daemon: false });
     return;
@@ -5299,8 +5859,8 @@ __export(create_exports, {
   create: () => create
 });
 import { resolve } from "path";
-import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo14 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo16 } 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) {
@@ -5326,7 +5886,7 @@ async function create(dir, opts) {
     return res;
   }
   if (res.noop) return res;
-  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
@@ -5351,7 +5911,7 @@ async function create(dir, opts) {
   }
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo14(root);
+    projectInfo = loadProjectInfo16(root);
   } catch {
     projectInfo = void 0;
   }
@@ -5377,9 +5937,9 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import { existsSync as existsSync2 } from "fs";
-import { resolveAdapter as resolveAdapter6 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo15, paths as paths2 } from "@noir-ai/core";
+import { existsSync as existsSync3 } from "fs";
+import { resolveAdapter as resolveAdapter7 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo17, paths as paths2 } 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 = {}) {
@@ -5388,7 +5948,7 @@ async function sync(root, opts = {}) {
   const conflictOpts = buildConflictOpts({ force: opts.force, interactive });
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo15(root);
+    projectInfo = loadProjectInfo17(root);
   } catch {
     projectInfo = void 0;
   }
@@ -5410,7 +5970,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 = resolveAdapter6(host);
+  const adapter = resolveAdapter7(host);
   const skillsDir = adapter.skillsDir?.({ root });
   if (skillsDir === void 0) {
     process.stderr.write(`host '${host}' has no skill emitter; skipping skills
@@ -5446,9 +6006,9 @@ async function sync(root, opts = {}) {
 }
 function resolveSyncHost(root, opts) {
   if (opts.host !== void 0) return opts.host;
-  if (!existsSync2(paths2.config(root))) return "claude";
+  if (!existsSync3(paths2.config(root))) return "claude";
   try {
-    return loadProjectInfo15(root).config.host;
+    return loadProjectInfo17(root).config.host;
   } catch {
     return "claude";
   }
@@ -5682,30 +6242,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",
@@ -5801,10 +6406,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");
@@ -6097,6 +6715,7 @@ var init_bin = __esm({
     init_skills();
     init_status();
     init_task();
+    init_workspace();
     init_init();
     init_output();
     init_run_profiles();