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

package/dist/tui/{chunk-J77RHAWG.js → chunk-KMLSJRYV.js}

@@ -28,16 +28,22 @@ import {
 } from "./chunk-ESZTOQEC.js";
 
 // src/commands/status.ts
-import { loadProjectInfo as loadProjectInfo11, NOIR_VERSION as NOIR_VERSION5 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo13, NOIR_VERSION as NOIR_VERSION5 } from "@noir-ai/core";
 
 // src/daemon-client.ts
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ContextEngine, createEmbedFn, resolveEmbedderConfig } from "@noir-ai/context";
-import { loadProjectInfo as loadProjectInfo10, NOIR_VERSION as NOIR_VERSION4 } from "@noir-ai/core";
+import {
+  loadProjectInfo as loadProjectInfo12,
+  NOIR_VERSION as NOIR_VERSION4,
+  readWorkspaceMarker as readWorkspaceMarker2,
+  workspaceStoreDbPath
+} from "@noir-ai/core";
 import {
   ensureDaemonRunning as ensureDaemonRunning3,
-  pidAlive as pidAlive3,
+  pidAlive as pidAlive4,
   readDaemonRecord as readDaemonRecord3,
+  readWorkspaceDaemonRecord as readWorkspaceDaemonRecord2,
   resolveGateConfig
 } from "@noir-ai/daemon";
 import { createMemoryEngine } from "@noir-ai/memory";
@@ -217,14 +223,319 @@ function renderStatus(data, opts) {
 }
 
 // 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";
+
+// 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";
+
+// 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)}
+`);
+}
+
+// src/commands/workspace.ts
+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);
+}
+
+// src/commands/daemon.ts
 var MODE = "foreground";
 function formatUptime(sec) {
   if (!Number.isFinite(sec) || sec < 0) return "unknown";
@@ -234,7 +545,7 @@ function formatUptime(sec) {
 }
 function resolveCallerProjectId() {
   try {
-    return loadProjectInfo(process.cwd()).id;
+    return loadProjectInfo2(process.cwd()).id;
   } catch {
     return void 0;
   }
@@ -255,9 +566,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);
   }
@@ -288,7 +608,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 } })}
@@ -387,7 +707,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");
@@ -433,7 +753,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);
   }
@@ -488,21 +808,21 @@ async function daemonRestart(opts) {
 
 // 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 loadProjectInfo2,
+  loadProjectInfo as loadProjectInfo3,
   NOIR_VERSION,
   paths,
   readInstallRecord,
   readUpdateCache
 } from "@noir-ai/core";
 import { CURRENT_SCAFFOLD_VERSION, readScaffoldVersion } from "@noir-ai/create";
-import { pidAlive as pidAlive2, readDaemonRecord as readDaemonRecord2 } from "@noir-ai/daemon";
+import { pidAlive as pidAlive3, readDaemonRecord as readDaemonRecord2 } from "@noir-ai/daemon";
 import { resolveModelConfig } from "@noir-ai/model";
 async function probeOnnx() {
   try {
@@ -539,7 +859,7 @@ async function checkRuntime(checks) {
 }
 function checkConfig(root) {
   const configPath = paths.config(root);
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return {
       project: void 0,
       result: {
@@ -550,7 +870,7 @@ function checkConfig(root) {
     };
   }
   try {
-    const project = loadProjectInfo2(root);
+    const project = loadProjectInfo3(root);
     return {
       project,
       result: {
@@ -576,7 +896,7 @@ async function checkDaemon(checks) {
     });
     return;
   }
-  if (!pidAlive2(rec.pid)) {
+  if (!pidAlive3(rec.pid)) {
     checks.push({
       name: "daemon",
       status: "warn",
@@ -631,7 +951,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",
@@ -660,7 +980,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);
@@ -770,7 +1090,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",
@@ -780,7 +1100,7 @@ function checkRulesMdBudget(checks, root, project) {
   }
   let content;
   try {
-    content = readFileSync(rulesPath, "utf8");
+    content = readFileSync2(rulesPath, "utf8");
   } catch (e) {
     checks.push({
       name: "rules budget",
@@ -824,7 +1144,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";
@@ -834,7 +1154,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 });
@@ -851,7 +1171,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",
@@ -864,11 +1184,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;
     }
@@ -925,13 +1245,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;
@@ -977,7 +1297,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",
@@ -990,11 +1310,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++;
@@ -1016,7 +1336,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 = "";
@@ -1142,18 +1462,18 @@ async function doctor(opts = {}) {
 
 // src/commands/handoff.ts
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import {
   defaultHandoffBlock,
   hostLaunchDirective,
-  resolveAdapter as resolveAdapter2
+  resolveAdapter as resolveAdapter3
 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo4, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo5, NOIR_DIR, resolveArtifactPath } from "@noir-ai/core";
 
 // src/commands/task.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { writeFileSync } from "fs";
-import { loadProjectInfo as loadProjectInfo3, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo4, nextArtifactSequence, sha256Hex } from "@noir-ai/core";
 import {
   PHASES,
   TASK_CLASSES,
@@ -1177,7 +1497,7 @@ function skillFor(phase) {
 }
 function writeDoneArtifacts(opts, taskId) {
   try {
-    const project = loadProjectInfo3(process.cwd());
+    const project = loadProjectInfo4(process.cwd());
     const conflict = { conflictPolicy: "preserve", interactive: false };
     writeChangelogStub(project.root, `- ${taskId}: completed (verify gate passed)`, conflict);
     const nextN = nextArtifactSequence(project.root, "adr");
@@ -1501,7 +1821,7 @@ function runCheck(cmd) {
 async function taskVerify(opts) {
   let project;
   try {
-    project = loadProjectInfo3(process.cwd());
+    project = loadProjectInfo4(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -1781,7 +2101,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);
@@ -1824,7 +2144,7 @@ async function probeOnly(opts) {
 async function handoff(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);
   }
@@ -1856,7 +2176,7 @@ async function handoff(opts) {
   if (opts.write === true) {
     const md = renderMarkdown(full);
     const path = handoffFilePath(project.root, task?.taskId, project.id);
-    mkdirSync(join2(project.root, NOIR_DIR, "handoff"), { recursive: true });
+    mkdirSync(join3(project.root, NOIR_DIR, "handoff"), { recursive: true });
     writeFileSync2(path, md, "utf8");
     info(`handoff written to ${path}`, opts);
   }
@@ -1873,7 +2193,7 @@ import { hostLaunchDirective as hostLaunchDirective2 } from "@noir-ai/adapters";
 import {
   detectActiveMethod as detectActiveMethod2,
   latestVersionFromCache as latestVersionFromCache2,
-  loadProjectInfo as loadProjectInfo5,
+  loadProjectInfo as loadProjectInfo6,
   NOIR_VERSION as NOIR_VERSION2,
   readInstallRecord as readInstallRecord2,
   readUpdateCache as readUpdateCache2
@@ -2167,7 +2487,7 @@ async function resolveSections(commands) {
 // src/commands/home.ts
 function tryProject() {
   try {
-    const info2 = loadProjectInfo5(process.cwd());
+    const info2 = loadProjectInfo6(process.cwd());
     return { id: info2.id, name: info2.name, host: info2.config.host };
   } catch {
     return null;
@@ -2331,7 +2651,7 @@ async function runMenu(opts, deps) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo5(process.cwd());
+        const info2 = loadProjectInfo6(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -2380,6 +2700,27 @@ ${COMMANDS_HINT}
 }
 
 // src/commands/memory.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { loadProjectInfo as loadProjectInfo7 } from "@noir-ai/core";
+function resolveWorkspace() {
+  const routing = workspaceRoutingTarget(process.cwd());
+  if (routing === null) return null;
+  try {
+    return { routing, project: loadProjectInfo7(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);
@@ -2418,6 +2759,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);
@@ -2479,7 +2853,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 ?? {};
@@ -2523,7 +2897,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);
@@ -2578,7 +3043,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);
@@ -2592,11 +3057,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
     );
   }
@@ -2605,7 +3070,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
@@ -2738,7 +3203,7 @@ async function release(opts) {
 
 // src/commands/run.ts
 import { mkdirSync as mkdirSync2, 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";
 
@@ -3104,10 +3569,10 @@ async function shellFallback(binary, args, opts, resolve, reject, originalErr) {
 }
 
 // src/run-profiles.ts
-import { loadProjectInfo as loadProjectInfo6 } from "@noir-ai/core";
+import { loadProjectInfo as loadProjectInfo8 } from "@noir-ai/core";
 function loadRunConfig(root) {
   try {
-    return loadProjectInfo6(root).config;
+    return loadProjectInfo8(root).config;
   } catch {
     return null;
   }
@@ -3246,8 +3711,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 {
     mkdirSync2(dir, { recursive: true, mode: 448 });
     writeFileSync3(file, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, { mode: 384 });
@@ -3258,8 +3723,8 @@ function writeTranscript(host, lines) {
 }
 
 // src/commands/skills.ts
-import { resolveAdapter as resolveAdapter3 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo7 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
 import {
   buildRegistry,
   discoverAll,
@@ -3355,11 +3820,11 @@ async function skillsSync(opts) {
   const root = process.cwd();
   let project;
   try {
-    project = loadProjectInfo7(root);
+    project = loadProjectInfo9(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: [],
@@ -3488,8 +3953,8 @@ async function skillsRegistry(opts) {
 }
 
 // src/init.ts
-import { resolveAdapter as resolveAdapter4 } from "@noir-ai/adapters";
-import { loadProjectInfo as loadProjectInfo8 } from "@noir-ai/core";
+import { resolveAdapter as resolveAdapter5 } from "@noir-ai/adapters";
+import { loadProjectInfo as loadProjectInfo10 } from "@noir-ai/core";
 import { scaffold } from "@noir-ai/create";
 import { emitSkillsToDir as emitSkillsToDir2 } from "@noir-ai/skills";
 
@@ -3595,8 +4060,8 @@ function labelFor(resolution) {
 }
 
 // src/dedup-write.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 import { sha256Hex as sha256Hex2, sha256Hex12 } from "@noir-ai/core";
 var HOST_CONTEXT_RELS = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".noir/rules/RULES.md"]);
 var ACTION_THRESHOLD = 0.95;
@@ -3612,10 +4077,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 = readFileSync2(proposedAbs, "utf8");
+      proposedText = readFileSync4(proposedAbs, "utf8");
     } catch {
       continue;
     }
@@ -3659,7 +4124,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",
@@ -3743,21 +4208,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 = readFileSync2(join4(root, matchedRel), "utf8");
+      const existing = readFileSync4(join5(root, matchedRel), "utf8");
       writeFileSync4(
-        join4(root, matchedRel),
+        join5(root, matchedRel),
         `${existing}
 
 <!-- mirrored from ${proposedRel} -->
@@ -3775,11 +4240,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 = 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();
@@ -3794,7 +4259,7 @@ function loadCache(root) {
 }
 function saveCache(root, cache) {
   try {
-    mkdirSync3(join4(root, ".noir"), { recursive: true });
+    mkdirSync3(join5(root, ".noir"), { recursive: true });
     writeFileSync4(cachePath(root), JSON.stringify(cache), "utf8");
   } catch {
   }
@@ -3811,7 +4276,7 @@ function makeCachedEmbed(cache, embed) {
 }
 function safeRead(abs) {
   try {
-    return readFileSync2(abs, "utf8");
+    return readFileSync4(abs, "utf8");
   } catch {
     return void 0;
   }
@@ -3862,7 +4327,7 @@ async function init(root, opts) {
   await emitHostSkills(root, host, conflictOpts, interactive);
   let projectInfo;
   try {
-    projectInfo = loadProjectInfo8(root);
+    projectInfo = loadProjectInfo10(root);
   } catch {
     projectInfo = void 0;
   }
@@ -3893,7 +4358,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
@@ -3941,11 +4406,11 @@ function assertLocalhostUrl(raw) {
 }
 
 // src/serve.ts
-import { applyNoirEnv, loadProjectInfo as loadProjectInfo9 } from "@noir-ai/core";
+import { applyNoirEnv, loadProjectInfo as loadProjectInfo11 } from "@noir-ai/core";
 import { ensureDaemonRunning as ensureDaemonRunning2, startStdioServer } from "@noir-ai/daemon";
 async function serve(opts) {
   applyNoirEnv(process.cwd());
-  const project = loadProjectInfo9(process.cwd());
+  const project = loadProjectInfo11(process.cwd());
   if (opts.stdio) {
     await startStdioServer({ project, transport: "stdio", daemon: false });
     return;
@@ -4118,7 +4583,7 @@ function createProgram() {
       const force = opts.force === true;
       const host = parseHost(opts.host);
       const dryRun = opts.dryRun === true || opts.preview === true;
-      const { create } = await import("./create-BTYLBVV6.js");
+      const { create } = await import("./create-HYFBTBLR.js");
       const result = await create(dir, {
         transport,
         url: opts.url,
@@ -4157,7 +4622,7 @@ function createProgram() {
     ).choices(SUPPORTED_HOSTS2)
   ).action(
     async (opts, cmd) => {
-      const { sync } = await import("./sync-LRHPJ5VV.js");
+      const { sync } = await import("./sync-QDOJ7INZ.js");
       const host = parseHost(opts.host);
       const force = opts.force === true;
       const merge = opts.merge === true;
@@ -4183,30 +4648,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",
@@ -4302,10 +4812,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");
@@ -4636,7 +5159,7 @@ async function probeDaemon(opts = {}) {
     if (opts.verbose) process.stderr.write("noir: daemon probe: no daemon record\n");
     return { running: false };
   }
-  if (!pidAlive3(rec.pid)) {
+  if (!pidAlive4(rec.pid)) {
     if (opts.verbose) process.stderr.write(`noir: daemon probe: pid ${rec.pid} not alive
 `);
     return { running: false };
@@ -4654,7 +5177,7 @@ async function probeDaemon(opts = {}) {
     const pidOk = typeof body?.pid === "number" && body.pid === rec.pid;
     const expectedProject = opts.project?.id ?? (() => {
       try {
-        return loadProjectInfo10(process.cwd()).id;
+        return loadProjectInfo12(process.cwd()).id;
       } catch {
         return void 0;
       }
@@ -4684,7 +5207,7 @@ async function probeDaemon(opts = {}) {
 async function resolveDaemon(opts) {
   let project;
   try {
-    project = opts.project ?? loadProjectInfo10(process.cwd());
+    project = opts.project ?? loadProjectInfo12(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -4780,7 +5303,7 @@ async function callDaemonTool(opts, name, args = {}) {
 async function withInProcessRead(opts, fn) {
   let project;
   try {
-    project = opts.project ?? loadProjectInfo10(process.cwd());
+    project = opts.project ?? loadProjectInfo12(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -4823,6 +5346,91 @@ async function withInProcessRead(opts, fn) {
     });
   }
 }
+function workspaceRoutingTarget(root) {
+  const name = readWorkspaceMarker2(root);
+  if (name === null) return null;
+  try {
+    return { name, projectId: loadProjectInfo12(root).id };
+  } catch {
+    return null;
+  }
+}
+async function probeWorkspaceDaemon(routing) {
+  const rec = readWorkspaceDaemonRecord2(routing.name);
+  if (rec === null || !pidAlive4(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_VERSION4 },
+      { 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(() => {
+    });
+  }
+}
 
 // src/commands/status.ts
 async function tryTool(caller, name, args) {
@@ -4945,7 +5553,7 @@ function renderHuman2(p, opts) {
 async function gatherStatusPayload(opts) {
   let project;
   try {
-    project = loadProjectInfo11(process.cwd());
+    project = loadProjectInfo13(process.cwd());
   } catch {
     fail(EXIT.ERROR, "Noir is not initialized in this directory. Run `noir init` first.", opts);
   }
@@ -4975,7 +5583,7 @@ async function status(opts) {
     env: process.env,
     configUpdate: (() => {
       try {
-        const info2 = loadProjectInfo11(process.cwd());
+        const info2 = loadProjectInfo13(process.cwd());
         return info2.config.update ?? DEFAULT_UPDATE_CONFIG;
       } catch {
         return DEFAULT_UPDATE_CONFIG;
@@ -5007,4 +5615,4 @@ export {
   assertTransportUrl,
   buildPaletteCommandsForTui
 };
-//# sourceMappingURL=chunk-J77RHAWG.js.map
+//# sourceMappingURL=chunk-KMLSJRYV.js.map