@kendoo.agentdesk/agentdesk 0.25.2 → 0.27.0

package/CHANGELOG.md

@@ -8,7 +8,7 @@ All user-facing changes to AgentDesk. Each entry is tagged:
 
 Internal refactors, infrastructure changes, and architectural notes are not listed here.
 
-## [Unreleased]
+## [0.27.0] — 2026-07-06
 
 ### Added
 - `[UI]` Private-session sharing flow. When someone visits a session URL they don't own, they now see a friendly "Shh… this one's private" page with a one-click "Request access" button instead of a blank error. The session owner sees pending requests in a new header inbox and can grant viewer access for just that session or the whole project. Viewer-granted sessions show up in the teammate's sidebar tagged as a viewer.
@@ -16,6 +16,9 @@ Internal refactors, infrastructure changes, and architectural notes are not list
 ### Changed
 - `[Both]` Security improvements and hardening. No action required.
 
+### Fixed
+- `[CLI]` The daemon no longer shows projects from other accounts after switching logins on the same machine. Project registrations are now tied to the account that created them, and the daemon cross-checks the server's per-account project list on startup. Projects from before this fix are matched to your account automatically on the next daemon start.
+
 ## [0.22.0] — 2026-05-23
 
 ### Changed

package/README.md

@@ -123,6 +123,7 @@ agentdesk team <TASK-ID>               Run a team session on an existing task
 agentdesk team -d "..."                Describe what you want — task created automatically
 agentdesk <agent> -d "..."             Run a single agent (jane, dennis, sam, bart, vera, luna, mark, nora)
 agentdesk daemon                       Start daemon for remote sessions
+agentdesk security-check [-d <dir>]    Multi-surface security audit (server / CLI / UI / prompts)
 agentdesk update                       Update to the latest version
 ```
 

package/bin/agentdesk.mjs

@@ -74,6 +74,7 @@ if (!command || command === "help" || command === "--help") {
     agentdesk team -d "..."                Create a task and run a session
     agentdesk <agent> -d "..."             Run a single agent (jane, dennis, sam, bart, vera, luna, mark, nora)
     agentdesk daemon                       Start daemon for remote sessions
+    agentdesk security-check [-d <dir>]    Multi-surface security audit (server / CLI / UI / prompts)
     agentdesk update                       Update to the latest version
 
   Options:
@@ -207,6 +208,13 @@ else if (command === "daemon") {
   await runDaemon();
 }
 
+else if (command === "security-check") {
+  const { runSecurityCheck, parseSecurityCheckArgs } = await import("../cli/security-check.mjs");
+  const opts = parseSecurityCheckArgs(args.slice(1));
+  const code = await runSecurityCheck(opts);
+  process.exit(code);
+}
+
 else if (command === "update") {
   const { execSync } = await import("child_process");
   const currentVersion = pkg.version;

package/cli/daemon.mjs

@@ -8,12 +8,12 @@ import { randomUUID } from "crypto";
 import WebSocket from "ws";
 import { detectProject } from "./detect.mjs";
 import { loadConfig } from "./config.mjs";
-import { getStoredApiKey } from "./login.mjs";
+import { getStoredApiKey, ensureAccountIdentity } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 import { buildPrompt } from "./prompt.mjs";
 import { createStreamParser } from "./stream-parser.mjs";
 import { runOrchestrator, runPhasedOrchestrator } from "./orchestrator.mjs";
-import { getRegisteredProjects, registerLocalProject } from "./projects.mjs";
+import { getRegisteredProjects, registerLocalProject, claimLocalProjects } from "./projects.mjs";
 import { buildTrackerUrl } from "./tracker-url.mjs";
 import { fileURLToPath } from "url";
 import { dirname } from "path";
@@ -150,46 +150,100 @@ export async function runDaemon() {
     process.exit(1);
   }
 
-  // 2. Load registered projects — local registry first, then server fallback
+  // 2. Load registered projects, scoped to the logged-in account (AD-64).
+  // The local registry is machine-global — it accumulates projects from
+  // every account ever used on this machine — so the server's per-account
+  // project list is the authority on what this account may see.
   const agentdeskServer = process.env.AGENTDESK_SERVER || "https://agentdesk.live";
-  let allProjects = getRegisteredProjects();
+  const creds = await ensureAccountIdentity();
+  const accountId = creds?.accountId || null;
 
-  // Fallback: fetch from server if local registry is empty (pre-0.7.0 projects)
-  if (allProjects.length === 0) {
-    try {
-      const res = await fetch(`${agentdeskServer}/api/projects`, {
-        headers: { "x-api-key": apiKey },
-        signal: AbortSignal.timeout(5000),
-      });
-      if (res.ok) {
-        const serverProjects = await res.json();
-        if (Array.isArray(serverProjects) && serverProjects.length > 0) {
-          console.log(`  ${dim}Syncing ${serverProjects.length} project(s) from server...${reset}`);
-          for (const sp of serverProjects) {
+  let serverIds = null;
+  try {
+    const res = await fetch(`${agentdeskServer}/api/projects`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (res.ok) {
+      const serverProjects = await res.json();
+      if (Array.isArray(serverProjects)) {
+        serverIds = new Set(serverProjects.map(sp => sp.id || sp.name));
+
+        // Untagged local entries with no server row — either they predate
+        // server-side registration or were initialized under another login.
+        // Offer them to the server: it accepts free ids and silently no-ops
+        // ids owned by another account (AD-23), so re-fetching the list
+        // tells us which ones are actually ours.
+        const unclaimed = getRegisteredProjects().filter(p =>
+          !p.accountId && !serverIds.has(p.id) &&
+          existsSync(p.path) && existsSync(join(p.path, ".agentdesk.json")));
+        if (unclaimed.length > 0) {
+          for (const p of unclaimed) {
+            try {
+              await fetch(`${agentdeskServer}/api/projects`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "x-api-key": apiKey },
+                body: JSON.stringify({ id: p.id, name: p.name, path: p.path }),
+                signal: AbortSignal.timeout(5000),
+              });
+            } catch {}
+          }
+          try {
+            const recheck = await fetch(`${agentdeskServer}/api/projects`, {
+              headers: { "x-api-key": apiKey },
+              signal: AbortSignal.timeout(5000),
+            });
+            if (recheck.ok) {
+              const confirmed = await recheck.json();
+              if (Array.isArray(confirmed)) {
+                serverIds = new Set(confirmed.map(sp => sp.id || sp.name));
+              }
+            }
+          } catch {}
+          for (const p of unclaimed) {
+            if (!serverIds.has(p.id)) {
+              console.log(`  ${yellow}Skipping ${p.name}${reset} ${dim}— registered to a different AgentDesk account${reset}`);
+            }
+          }
+        }
+
+        // Claim legacy untagged local entries the server confirmed as ours
+        claimLocalProjects([...serverIds], accountId);
+
+        // Sync server projects missing from the local registry (pre-0.7.0
+        // setups, or projects initialized on another machine)
+        const localIds = new Set(getRegisteredProjects().map(p => p.id));
+        const missing = serverProjects.filter(sp => !localIds.has(sp.id || sp.name));
+        if (missing.length > 0) {
+          console.log(`  ${dim}Syncing ${missing.length} project(s) from server...${reset}`);
+          for (const sp of missing) {
             const projectName = sp.id || sp.name;
             // If server has a valid path, use it
             if (sp.path && existsSync(sp.path)) {
-              registerLocalProject(projectName, sp.name, sp.path);
+              registerLocalProject(projectName, sp.name, sp.path, accountId);
               continue;
             }
             // Server has empty path — try to find the project locally
             const found = findProjectLocally(projectName);
             if (found) {
               console.log(`  ${dim}Found ${projectName} at ${found}${reset}`);
-              registerLocalProject(projectName, sp.name, found);
+              registerLocalProject(projectName, sp.name, found, accountId);
             } else {
               console.log(`  ${yellow}Could not find ${projectName} locally.${reset} Run ${cyan}agentdesk init${reset} in its directory.`);
             }
           }
-          allProjects = getRegisteredProjects();
         }
       }
-    } catch {
-      // Server not reachable — continue with local only
     }
+  } catch {
+    // Server not reachable — fall back to account-tagged local entries
   }
 
-  const projects = allProjects.filter(p => {
+  const projects = getRegisteredProjects(accountId).filter(p => {
+    // Server reachable → it is authoritative: hide entries it doesn't own,
+    // even legacy untagged ones (they may belong to another account).
+    // Offline → tagged + untagged entries from getRegisteredProjects().
+    if (serverIds && !serverIds.has(p.id) && !(accountId && p.accountId === accountId)) return false;
     if (!existsSync(p.path)) return false;
     if (!existsSync(join(p.path, ".agentdesk.json"))) return false;
     return true;

package/cli/init.mjs

@@ -20,7 +20,7 @@
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 import { loadConfig, pushConfig } from "./config.mjs";
-import { getStoredApiKey } from "./login.mjs";
+import { getStoredApiKey, ensureAccountIdentity } from "./login.mjs";
 import { registerLocalProject } from "./projects.mjs";
 import { checkTrackerPermissions } from "./tracker-check.mjs";
 import { autoMatchProject } from "./bootstrap.mjs";
@@ -535,7 +535,10 @@ async function runWizard({ cwd, apiKey, mode, projectKey }) {
     }
   }
 
-  registerLocalProject(computedKey, projectName, currentCwd);
+  // AD-64: tag the registry entry with the account so the daemon can scope
+  // its project list per login.
+  const accountId = (await ensureAccountIdentity())?.accountId || null;
+  registerLocalProject(computedKey, projectName, currentCwd, accountId);
 
   console.log("");
   const cmdPrefix = trackerTeamOrProjectId || computedKey.toUpperCase();

package/cli/login.mjs

@@ -17,13 +17,42 @@ function getEnvApiKey() {
 }
 
 export function getStoredApiKey() {
+  return getStoredCredentials()?.apiKey || null;
+}
+
+export function getStoredCredentials() {
   if (!existsSync(CREDENTIALS_PATH)) return null;
   try {
-    const creds = JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
-    return creds.apiKey || null;
+    return JSON.parse(readFileSync(CREDENTIALS_PATH, "utf-8"));
+  } catch { return null; }
+}
+
+// AD-64: resolve which account an API key belongs to, so local project
+// registry entries can be scoped per account.
+async function fetchAccountIdentity(apiKey) {
+  try {
+    const res = await fetch(`${AGENTDESK_SERVER}/api/me`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return null;
+    const me = await res.json();
+    return me?.id ? { accountId: me.id, email: me.email || null } : null;
   } catch { return null; }
 }
 
+// Backfill accountId into credentials saved by pre-AD-64 versions.
+// Returns the (possibly updated) credentials object.
+export async function ensureAccountIdentity() {
+  const creds = getStoredCredentials();
+  if (!creds?.apiKey || creds.accountId) return creds;
+  const identity = await fetchAccountIdentity(creds.apiKey);
+  if (!identity) return creds;
+  const updated = { ...creds, ...identity };
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(updated, null, 2), { mode: 0o600 });
+  return updated;
+}
+
 export async function runLogin() {
   console.log("");
   console.log("  AgentDesk — Login");
@@ -120,7 +149,16 @@ export async function runLogin() {
         console.log("    agentdesk team TASK-123");
         console.log("");
 
-        setTimeout(() => { server.close(); process.exit(0); }, 500);
+        // AD-64: attach the account identity so the project registry can be
+        // scoped per account. Best-effort — login still succeeds without it.
+        fetchAccountIdentity(apiKey)
+          .then(identity => {
+            if (identity) {
+              writeFileSync(CREDENTIALS_PATH, JSON.stringify({ apiKey, name, ...identity, savedAt: Date.now() }, null, 2), { mode: 0o600 });
+            }
+          })
+          .catch(() => {})
+          .finally(() => { server.close(); process.exit(0); });
       } else {
         res.writeHead(400, { "Content-Type": "text/html" });
         res.end("<html><body><h2>Login failed. No API key received.</h2></body></html>");

package/cli/projects.mjs

@@ -1,4 +1,9 @@
 // Local project registry — tracks which projects have been initialized with `agentdesk init`
+//
+// AD-64: entries are tagged with the accountId they were registered under so
+// the daemon can scope its project list to the logged-in account. Entries
+// written by older versions have no accountId ("untagged") — the daemon
+// claims them for the active account when the server confirms ownership.
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -6,7 +11,7 @@ import { join } from "path";
 const CONFIG_DIR = join(process.env.HOME || process.env.USERPROFILE, ".agentdesk");
 const PROJECTS_PATH = join(CONFIG_DIR, "projects.json");
 
-export function getRegisteredProjects() {
+function readRegistry() {
   try {
     if (!existsSync(PROJECTS_PATH)) return [];
     const data = JSON.parse(readFileSync(PROJECTS_PATH, "utf-8"));
@@ -16,10 +21,28 @@ export function getRegisteredProjects() {
   }
 }
 
-export function registerLocalProject(id, name, path) {
-  const projects = getRegisteredProjects();
+function writeRegistry(projects) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  }
+  writeFileSync(PROJECTS_PATH, JSON.stringify({ projects }, null, 2) + "\n", { mode: 0o600 });
+}
+
+// accountId: return only that account's entries plus legacy untagged ones
+// (callers that can reach the server should claimLocalProjects() first so
+// untagged entries get resolved rather than leaking across accounts).
+export function getRegisteredProjects(accountId) {
+  const projects = readRegistry();
+  if (!accountId) return projects;
+  return projects.filter(p => !p.accountId || p.accountId === accountId);
+}
+
+export function registerLocalProject(id, name, path, accountId) {
+  const projects = readRegistry();
   const existing = projects.findIndex(p => p.id === id);
   const entry = { id, name, path, registeredAt: Date.now() };
+  if (accountId) entry.accountId = accountId;
+  else if (existing >= 0 && projects[existing].accountId) entry.accountId = projects[existing].accountId;
 
   if (existing >= 0) {
     projects[existing] = entry;
@@ -27,8 +50,20 @@ export function registerLocalProject(id, name, path) {
     projects.push(entry);
   }
 
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  writeRegistry(projects);
+}
+
+// Tag untagged entries whose ids the server confirmed belong to accountId.
+export function claimLocalProjects(ids, accountId) {
+  if (!accountId || !ids?.length) return;
+  const idSet = new Set(ids);
+  const projects = readRegistry();
+  let changed = false;
+  for (const p of projects) {
+    if (!p.accountId && idSet.has(p.id)) {
+      p.accountId = accountId;
+      changed = true;
+    }
   }
-  writeFileSync(PROJECTS_PATH, JSON.stringify({ projects }, null, 2) + "\n", { mode: 0o600 });
+  if (changed) writeRegistry(projects);
 }

package/cli/security-check.mjs

@@ -0,0 +1,187 @@
+// `agentdesk security-check` — runs a multi-surface security audit on a
+// codebase by spawning a Claude process scoped to the target directory.
+//
+// The audit pattern: identify which surfaces exist (server / CLI / UI /
+// prompts), spawn parallel investigators per surface via Claude's Agent
+// tool, return one triaged punch list (Critical / High / Medium / Low)
+// with file:line citations and concrete fix recommendations.
+//
+// This is a batch full-codebase audit, NOT a PR/diff review. For diff
+// review use Claude Code's built-in `/security-review` skill instead.
+
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+
+const PROMPT = `You are running a multi-surface security audit on the codebase in the current working directory.
+
+Goal: produce one triaged punch list of security findings (Critical / High / Medium / Low) with file:line citations and concrete fix recommendations.
+
+Step 1 — Survey what's here:
+- Server-shaped dirs: server/, api/, backend/, services/, plus *.py / *.go / *.rs / *.mjs / *.ts that look like HTTP/WS server entrypoints.
+- CLI-shaped dirs: bin/, cli/, cmd/, top-level scripts.
+- UI-shaped dirs: src/, app/, web/, frontend/, components/, index.html.
+- Prompts / config inlined into LLM calls: prompts/, .claude/, CLAUDE.md, MCP configs, agent skill files.
+
+Tell the user which surfaces you'll cover before launching investigators. Skip any that don't exist.
+
+Step 2 — Spawn parallel investigators (one per existing surface) via the Agent tool with subagent_type "general-purpose". Send them in a single message with multiple tool calls so they run concurrently.
+
+Each investigator gets the surface path and a focused checklist:
+
+Server / API — auth bypass (missing auth gates, JWT weaknesses, CSRF, session fixation), authorization / IDOR on every :id route, input validation / injection (SQL via string concat, command injection, path traversal, SSRF, eval, prototype pollution), credential handling (encryption mode, IV reuse, key derivation, leak surfaces), rate limiting on auth endpoints, WebSocket auth (auth-by-message is non-standard), dependency vulns, secret exposure, error handling that leaks stack traces.
+
+CLI / daemon — command injection (every exec/execSync template-literal sink), path traversal in fs.writeFile / path.join, sandbox claims vs implementation (denylists are usually wrong), credential exposure (tokens in logs/argv/errors/temp files), URL parsing SSRF, prompt-injection vectors when CLI feeds external content into an LLM, daemon-push abuse (signed? confirmation required?), config/credential precedence bugs.
+
+UI / frontend / prompts — XSS in any dangerouslySetInnerHTML or markdown render of user-controlled content (agent output is untrusted), JWT/secrets in localStorage, bundled VITE_/NEXT_PUBLIC env vars in the public bundle, CSRF / SameSite, open redirect / clickjacking / missing frame-ancestors, <a href> without scheme allowlist (javascript: URLs run same-origin), prompt-injection robustness (untrusted-data delimiters? hard system rule against following directives in user content?), dependency vulns, CSP / security headers.
+
+Each investigator returns a triaged list (Critical / High / Medium / Low) with file:line citations and concrete fix recommendations. Cap their responses at ~700 words; tell them to prioritize ruthlessly.
+
+Step 3 — Synthesize:
+- Group findings by severity (not by surface — the user wants the queue, not the org chart).
+- Look for chains where a Medium reaches a Critical — note them.
+- Identify the 2-3 structural patterns driving the findings (e.g., "untrusted data treated as trusted across boundaries", "sandbox claim doesn't match implementation"). These root causes are more useful than per-line fixes.
+- Propose a triage plan in dependency order (which fixes ship together, what order minimizes the exposure window).
+
+Step 4 — Present:
+
+# Security audit — <project name> — <date>
+
+## Headline numbers
+- N Critical (exploitable as-is)
+- N High (real risk, needs a chain or specific condition)
+- N Medium (defense-in-depth gaps)
+- N Low (hardening opportunities)
+
+## The N things to fix this week
+<top items with file:line + why-exploitable + concrete fix>
+
+## Full punch list (compact)
+### CRITICAL
+- file.ext:LL — short description. Why exploitable: ... Suggested fix: ...
+### HIGH ...
+### MEDIUM ...
+### LOW ...
+
+## The pattern
+<2-3 sentence root-cause analysis>
+
+## Suggested triage plan
+<ordered plan with rough day-by-day>
+
+Important:
+- Do NOT fix anything. Audit and report only.
+- Be honest about scope — a real audit is days. This one pass produces a focused triage list.
+- For any CHANGELOG entry referencing security work, use NEUTRAL phrasing ("Security improvements. No action required.") — never name the bug class on public release notes.
+`;
+
+function colorize() {
+  const isTTY = process.stdout.isTTY;
+  const c = (code) => (s) => isTTY ? `\x1b[${code}m${s}\x1b[0m` : s;
+  return { dim: c(2), green: c(32), cyan: c(36), yellow: c(33), red: c(31) };
+}
+
+export async function runSecurityCheck({ cwd, out }) {
+  const { dim, green, cyan, yellow, red } = colorize();
+  const targetDir = resolve(cwd || process.cwd());
+  if (!existsSync(targetDir)) {
+    console.error(`${red("Directory not found:")} ${targetDir}`);
+    return 1;
+  }
+
+  // Default output path: .agentdesk/security-audit-<timestamp>.md inside the audited project.
+  const stamp = new Date().toISOString().replace(/[:T]/g, "-").slice(0, 16);
+  const outPath = resolve(out || join(targetDir, ".agentdesk", `security-audit-${stamp}.md`));
+  mkdirSync(join(outPath, ".."), { recursive: true });
+
+  console.log("");
+  console.log(`  ${green("agentdesk security-check")}`);
+  console.log(`  ${dim("Target:")} ${targetDir}`);
+  console.log(`  ${dim("Report:")} ${outPath}`);
+  console.log("");
+  console.log(`  ${dim("Spawning Claude with the audit prompt. This typically takes 5–15 minutes.")}`);
+  console.log(`  ${dim("Output streams to your terminal AND lands in the report file when done.")}`);
+  console.log("");
+
+  // Spawn `claude -p <prompt>` against the target directory. The prompt tells
+  // Claude to use its Agent tool to fan out to parallel investigators.
+  const child = spawn("claude", ["-p", PROMPT, "--permission-mode", "acceptEdits"], {
+    cwd: targetDir,
+    stdio: ["inherit", "pipe", "inherit"],
+    env: process.env,
+  });
+
+  let captured = "";
+  child.stdout.on("data", (buf) => {
+    const chunk = buf.toString();
+    captured += chunk;
+    process.stdout.write(chunk);
+  });
+
+  return new Promise((resolveExit) => {
+    child.on("error", (err) => {
+      console.error(`\n  ${red("Failed to spawn claude:")} ${err.message}`);
+      console.error(`  ${dim("Is the Claude Code CLI installed and on your PATH? https://claude.ai/code")}`);
+      resolveExit(1);
+    });
+    child.on("close", (code) => {
+      try {
+        const header = [
+          `# Security audit — ${targetDir.split("/").pop()}`,
+          `Generated: ${new Date().toISOString()}`,
+          `Target: \`${targetDir}\``,
+          `Tool: agentdesk security-check`,
+          ``,
+          `---`,
+          ``,
+        ].join("\n");
+        writeFileSync(outPath, header + captured);
+        console.log("");
+        console.log(`  ${green("Report written:")} ${outPath}`);
+        if (code !== 0) {
+          console.log(`  ${yellow("Claude exited with code")} ${code}${dim(" — report may be partial.")}`);
+        }
+      } catch (err) {
+        console.error(`\n  ${red("Failed to write report:")} ${err.message}`);
+      }
+      resolveExit(code === null ? 1 : code);
+    });
+  });
+}
+
+export function parseSecurityCheckArgs(args) {
+  let cwd = null;
+  let out = null;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "--cwd" || args[i] === "-d") && args[i + 1]) {
+      cwd = args[++i];
+    } else if (args[i] === "--out" && args[i + 1]) {
+      out = args[++i];
+    } else if (args[i] === "--help" || args[i] === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return { cwd, out };
+}
+
+function printHelp() {
+  console.log(`
+  agentdesk security-check — multi-surface security audit
+
+  Usage:
+    agentdesk security-check                Audit the current directory
+    agentdesk security-check -d <dir>       Audit a different directory
+    agentdesk security-check --out <file>   Custom report output path
+
+  Spawns a Claude process scoped to the target directory. Claude surveys
+  the codebase, fans out to parallel investigators (server / CLI / UI /
+  prompts), and returns a triaged punch list with file:line citations.
+
+  Output:
+    Streams to your terminal as Claude works, and saves a copy to:
+    <target>/.agentdesk/security-audit-<timestamp>.md (by default)
+
+  Requires the Claude Code CLI on your PATH. https://claude.ai/code
+`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kendoo.agentdesk/agentdesk",
-  "version": "0.25.2",
+  "version": "0.27.0",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {
@@ -22,7 +22,7 @@
     "server": "node server/index.mjs",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "node --test tests/server.test.mjs tests/agents.test.mjs tests/homepage.test.mjs tests/sessionUtils.test.mjs tests/tracker-url.test.mjs tests/session-preflight.test.mjs tests/access.test.mjs tests/project-ownership.test.mjs tests/random-hex.test.mjs",
+    "test": "node --test tests/server.test.mjs tests/agents.test.mjs tests/homepage.test.mjs tests/sessionUtils.test.mjs tests/tracker-url.test.mjs tests/session-preflight.test.mjs tests/access.test.mjs tests/project-ownership.test.mjs tests/random-hex.test.mjs tests/projects-registry.test.mjs",
     "lint:changelog": "node scripts/lint-changelog.mjs",
     "prepublishOnly": "node scripts/lint-changelog.mjs"
   },