@kitsy/coop 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs13 from "fs";
-import path18 from "path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import fs15 from "fs";
+import path19 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
 // src/utils/aliases.ts
 import fs2 from "fs";
 import path2 from "path";
-import { parseIdeaFile, parseTaskFile as parseTaskFile2, parseYamlFile as parseYamlFile2, stringifyFrontmatter, writeTask, writeYamlFile as writeYamlFile2 } from "@kitsy/coop-core";
+import { parseIdeaFile, parseTaskFile as parseTaskFile2, parseYamlFile, stringifyFrontmatter, writeTask, writeYamlFile as writeYamlFile2 } from "@kitsy/coop-core";
 
 // src/utils/repo.ts
 import fs from "fs";
@@ -17,12 +17,29 @@ import os from "os";
 import path from "path";
 import { spawnSync } from "child_process";
 import crypto from "crypto";
-import { parseTaskFile, parseYamlFile, writeYamlFile } from "@kitsy/coop-core";
+import {
+  coop_project_config_path,
+  coop_workspace_config_path,
+  list_projects as listWorkspaceProjects,
+  parseTaskFile,
+  read_project_config,
+  read_workspace_config,
+  resolve_project,
+  write_workspace_config,
+  writeYamlFile
+} from "@kitsy/coop-core";
 var SEQ_MARKER = "COOPSEQTOKEN";
+function resolveCoopHome() {
+  const configured = process.env.COOP_HOME?.trim();
+  if (configured) {
+    return path.resolve(configured);
+  }
+  return path.join(os.homedir(), ".coop");
+}
 function resolveRepoRoot(start = process.cwd()) {
   let current = path.resolve(start);
   while (true) {
-    if (fs.existsSync(path.join(current, ".git"))) {
+    if (fs.existsSync(path.join(current, ".git")) || fs.existsSync(path.join(current, ".coop"))) {
       return current;
     }
     const parent = path.dirname(current);
@@ -32,21 +49,54 @@ function resolveRepoRoot(start = process.cwd()) {
     current = parent;
   }
 }
-function coopDir(root) {
+function resolveRequestedProject(argv = process.argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const current = argv[i]?.trim();
+    if (current === "--project" || current === "-p") {
+      const next = argv[i + 1]?.trim();
+      return next || void 0;
+    }
+    if (current?.startsWith("--project=")) {
+      return current.slice("--project=".length).trim() || void 0;
+    }
+  }
+  return void 0;
+}
+function coopWorkspaceDir(root) {
   return path.join(root, ".coop");
 }
-function ensureCoopInitialized(root) {
-  const dir = coopDir(root);
-  if (!fs.existsSync(dir)) {
-    throw new Error(`Missing .coop directory at ${dir}. Run 'coop init'.`);
+function coopDir(root, projectId = resolveRequestedProject()) {
+  return resolve_project(root, { project: projectId, require: true }).root;
+}
+function ensureCoopInitialized(root, projectId = resolveRequestedProject()) {
+  const workspaceDir = coopWorkspaceDir(root);
+  if (!fs.existsSync(workspaceDir)) {
+    throw new Error(`Missing .coop directory at ${workspaceDir}. Run 'coop init'.`);
+  }
+  const project = resolve_project(root, { project: projectId, require: true });
+  if (!fs.existsSync(project.root)) {
+    throw new Error(`Missing COOP project directory at ${project.root}. Run 'coop init'.`);
   }
-  return dir;
+  return project.root;
 }
-function coopConfigPath(root) {
-  return path.join(coopDir(root), "config.yml");
+function coopConfigPath(root, projectId = resolveRequestedProject()) {
+  return coop_project_config_path(ensureCoopInitialized(root, projectId));
 }
-function readCoopConfig(root) {
-  const configPath = coopConfigPath(root);
+function readWorkspaceConfig(root) {
+  return read_workspace_config(root);
+}
+function writeWorkspaceConfig(root, config) {
+  write_workspace_config(root, config);
+}
+function listProjects(root) {
+  return listWorkspaceProjects(root);
+}
+function resolveProject(root, projectId = resolveRequestedProject()) {
+  return resolve_project(root, { project: projectId, require: true });
+}
+function readCoopConfig(root, projectId = resolveRequestedProject()) {
+  const project = resolve_project(root, { project: projectId, require: false });
+  const configPath = coop_project_config_path(project.root);
   const repoName = path.basename(path.resolve(root));
   if (!fs.existsSync(configPath)) {
     return {
@@ -62,10 +112,10 @@ function readCoopConfig(root) {
       filePath: configPath
     };
   }
-  const config = parseYamlFile(configPath);
+  const config = read_project_config(project.root);
   const projectRaw = typeof config.project === "object" && config.project !== null ? config.project : {};
   const projectName = typeof projectRaw.name === "string" && projectRaw.name.trim().length > 0 ? projectRaw.name.trim() : repoName;
-  const projectId = typeof projectRaw.id === "string" && projectRaw.id.trim().length > 0 ? projectRaw.id.trim() : repoName;
+  const resolvedProjectId = typeof projectRaw.id === "string" && projectRaw.id.trim().length > 0 ? projectRaw.id.trim() : repoName;
   const projectAliases = Array.isArray(projectRaw.aliases) ? projectRaw.aliases.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
   const idPrefixesRaw = config.id_prefixes;
   const idPrefixes = typeof idPrefixesRaw === "object" && idPrefixesRaw !== null ? idPrefixesRaw : {};
@@ -86,7 +136,7 @@ function readCoopConfig(root) {
     idNamingTemplate,
     idSeqPadding,
     projectName: projectName || "COOP Workspace",
-    projectId: projectId || "workspace",
+    projectId: resolvedProjectId || "workspace",
     projectAliases,
     raw: config,
     filePath: configPath
@@ -151,15 +201,15 @@ function findTaskFileById(root, id) {
   const target = `${id}.md`.toLowerCase();
   const match = listTaskFiles(root).find((filePath) => path.basename(filePath).toLowerCase() === target);
   if (!match) {
-    throw new Error(`Task '${id}' not found in .coop/tasks.`);
+    throw new Error(`Task '${id}' not found in the active COOP project.`);
   }
   return match;
 }
 function todayIsoDate() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
-function normalizeIdPart(input, fallback, maxLength = 12) {
-  const normalized = input.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").replace(/-/g, "");
+function normalizeIdPart(input3, fallback, maxLength = 12) {
+  const normalized = input3.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").replace(/-/g, "");
   if (!normalized) return fallback;
   return normalized.slice(0, maxLength);
 }
@@ -195,8 +245,8 @@ function shortDateToken(now = /* @__PURE__ */ new Date()) {
 function randomToken() {
   return crypto.randomBytes(4).toString("hex").toUpperCase();
 }
-function sanitizeTemplateValue(input, fallback = "X") {
-  const normalized = input.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+function sanitizeTemplateValue(input3, fallback = "X") {
+  const normalized = input3.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
   return normalized || fallback;
 }
 function sequenceForPattern(existingIds, prefix, suffix) {
@@ -304,27 +354,27 @@ function generateConfiguredId(root, existingIds, context) {
 
 // src/utils/aliases.ts
 var ALIAS_PATTERN = /^[A-Z0-9]+(?:[.-][A-Z0-9]+)*$/;
-function toPosixPath(input) {
-  return input.replace(/\\/g, "/");
+function toPosixPath(input3) {
+  return input3.replace(/\\/g, "/");
 }
 function indexFilePath(root) {
   const { indexDataFormat } = readCoopConfig(root);
   const extension = indexDataFormat === "json" ? "json" : "yml";
-  return path2.join(root, ".coop", ".index", `aliases.${extension}`);
+  return path2.join(ensureCoopInitialized(root), ".index", `aliases.${extension}`);
 }
-function normalizeAliasValue(input) {
-  return input.trim().toUpperCase().replace(/_/g, ".").replace(/\.+/g, ".");
+function normalizeAliasValue(input3) {
+  return input3.trim().toUpperCase().replace(/_/g, ".").replace(/\.+/g, ".");
 }
-function normalizePatternValue(input) {
-  return input.trim().toUpperCase().replace(/_/g, ".");
+function normalizePatternValue(input3) {
+  return input3.trim().toUpperCase().replace(/_/g, ".");
 }
-function normalizeAlias(input) {
-  const normalized = normalizeAliasValue(input);
+function normalizeAlias(input3) {
+  const normalized = normalizeAliasValue(input3);
   if (!normalized) {
     throw new Error("Alias cannot be empty.");
   }
   if (!ALIAS_PATTERN.test(normalized)) {
-    throw new Error(`Invalid alias '${input}'. Use letters/numbers with '.' and '-'.`);
+    throw new Error(`Invalid alias '${input3}'. Use letters/numbers with '.' and '-'.`);
   }
   return normalized;
 }
@@ -376,7 +426,7 @@ function readIndexFile(root, aliasIndexPath) {
       const parsed = JSON.parse(fs2.readFileSync(aliasIndexPath, "utf8"));
       return parsed;
     }
-    return parseYamlFile2(aliasIndexPath);
+    return parseYamlFile(aliasIndexPath);
   } catch {
     return null;
   }
@@ -387,14 +437,14 @@ function writeIndexFile(root, data) {
   if (aliasIndexPath.endsWith(".json")) {
     fs2.writeFileSync(aliasIndexPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
-    const yamlPath = path2.join(root, ".coop", ".index", "aliases.yml");
+    const yamlPath = path2.join(ensureCoopInitialized(root), ".index", "aliases.yml");
     if (fs2.existsSync(yamlPath)) {
       fs2.rmSync(yamlPath, { force: true });
     }
     return;
   }
   writeYamlFile2(aliasIndexPath, data);
-  const jsonPath = path2.join(root, ".coop", ".index", "aliases.json");
+  const jsonPath = path2.join(ensureCoopInitialized(root), ".index", "aliases.json");
   if (fs2.existsSync(jsonPath)) {
     fs2.rmSync(jsonPath, { force: true });
   }
@@ -511,8 +561,8 @@ function updateTaskAliases(filePath, aliases) {
 function updateIdeaAliases(filePath, aliases) {
   const parsed = parseIdeaFile(filePath);
   const nextRaw = { ...parsed.raw, aliases };
-  const output = stringifyFrontmatter(nextRaw, parsed.body);
-  fs2.writeFileSync(filePath, output, "utf8");
+  const output3 = stringifyFrontmatter(nextRaw, parsed.body);
+  fs2.writeFileSync(filePath, output3, "utf8");
 }
 function resolveFilePath(root, target) {
   return path2.join(root, ...target.file.split("/"));
@@ -1054,14 +1104,14 @@ function updateIdeaLinkedTasks(filePath, idea, raw, body, linked) {
   };
   fs3.writeFileSync(filePath, stringifyFrontmatter2(nextRaw, body), "utf8");
 }
-function makeTaskDraft(input) {
+function makeTaskDraft(input3) {
   return {
-    title: input.title,
-    type: input.type,
-    status: input.status,
-    track: input.track,
-    priority: input.priority,
-    body: input.body
+    title: input3.title,
+    type: input3.type,
+    status: input3.status,
+    track: input3.track,
+    priority: input3.priority,
+    body: input3.body
   };
 }
 function registerCreateCommand(program) {
@@ -1412,10 +1462,10 @@ import {
 function normalize(value) {
   return value.trim().toLowerCase();
 }
-function resolveDelivery(graph, input) {
-  const direct = graph.deliveries.get(input);
+function resolveDelivery(graph, input3) {
+  const direct = graph.deliveries.get(input3);
   if (direct) return direct;
-  const target = normalize(input);
+  const target = normalize(input3);
   const byId = Array.from(graph.deliveries.values()).find((delivery) => normalize(delivery.id) === target);
   if (byId) return byId;
   const byName = Array.from(graph.deliveries.values()).filter((delivery) => normalize(delivery.name) === target);
@@ -1423,9 +1473,9 @@ function resolveDelivery(graph, input) {
     return byName[0];
   }
   if (byName.length > 1) {
-    throw new Error(`Multiple deliveries match '${input}'. Use delivery id instead.`);
+    throw new Error(`Multiple deliveries match '${input3}'. Use delivery id instead.`);
   }
-  throw new Error(`Delivery '${input}' not found.`);
+  throw new Error(`Delivery '${input3}' not found.`);
 }
 
 // src/commands/graph.ts
@@ -1616,6 +1666,8 @@ function registerIndexCommand(program) {
 import fs6 from "fs";
 import path8 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
 import { CURRENT_SCHEMA_VERSION, write_schema_version } from "@kitsy/coop-core";
 
 // src/hooks/pre-commit.ts
@@ -1643,7 +1695,41 @@ function toPosixPath2(filePath) {
 }
 function stagedTaskFiles(repoRoot) {
   const { stdout } = runGit(repoRoot, ["diff", "--cached", "--name-only", "--diff-filter=ACMR"]);
-  return stdout.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean).map(toPosixPath2).filter((entry) => entry.startsWith(".coop/tasks/") && entry.endsWith(".md"));
+  return stdout.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean).map(toPosixPath2).filter(
+    (entry) => (entry.startsWith(".coop/tasks/") || /^\.coop\/projects\/[^/]+\/tasks\//.test(entry)) && entry.endsWith(".md")
+  );
+}
+function projectRootFromRelativePath(repoRoot, relativePath) {
+  const normalized = toPosixPath2(relativePath);
+  const projectMatch = /^\.coop\/projects\/([^/]+)\/tasks\/.+\.md$/i.exec(normalized);
+  if (projectMatch?.[1]) {
+    return path6.join(repoRoot, ".coop", "projects", projectMatch[1]);
+  }
+  if (normalized.startsWith(".coop/tasks/")) {
+    return path6.join(repoRoot, ".coop");
+  }
+  throw new Error(`Unsupported staged COOP task path '${relativePath}'.`);
+}
+function listTaskFilesForProject(projectRoot) {
+  const tasksDir = path6.join(projectRoot, "tasks");
+  if (!fs4.existsSync(tasksDir)) return [];
+  const out = [];
+  const stack = [tasksDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = fs4.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path6.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (entry.isFile() && path6.extname(entry.name).toLowerCase() === ".md") {
+        out.push(fullPath);
+      }
+    }
+  }
+  return out.sort((a, b) => a.localeCompare(b));
 }
 function readGitBlob(repoRoot, spec) {
   const result = runGit(repoRoot, ["show", spec], true);
@@ -1658,6 +1744,7 @@ function parseStagedTasks(repoRoot, relativePaths) {
   const staged = [];
   for (const relativePath of relativePaths) {
     const absolutePath = path6.join(repoRoot, ...relativePath.split("/"));
+    const projectRoot = projectRootFromRelativePath(repoRoot, relativePath);
     const stagedBlob = readGitBlob(repoRoot, `:${relativePath}`);
     if (!stagedBlob) {
       errors.push(`[COOP] Unable to read staged task '${relativePath}' from git index.`);
@@ -1678,6 +1765,7 @@ function parseStagedTasks(repoRoot, relativePaths) {
     staged.push({
       relativePath,
       absolutePath,
+      projectRoot,
       task
     });
   }
@@ -1712,13 +1800,13 @@ function buildGraphForCycleCheck(tasks) {
     deliveries: /* @__PURE__ */ new Map()
   };
 }
-function collectTasksForCycleCheck(repoRoot, stagedTasks) {
+function collectTasksForCycleCheck(projectRoot, stagedTasks) {
   const stagedByPath = /* @__PURE__ */ new Map();
   for (const staged of stagedTasks) {
     stagedByPath.set(toPosixPath2(staged.absolutePath), staged.task);
   }
   const tasks = [];
-  for (const filePath of listTaskFiles(repoRoot)) {
+  for (const filePath of listTaskFilesForProject(projectRoot)) {
     const normalized = toPosixPath2(path6.resolve(filePath));
     const stagedTask = stagedByPath.get(normalized);
     if (stagedTask) {
@@ -1737,16 +1825,25 @@ function runPreCommitChecks(repoRoot) {
   const parsed = parseStagedTasks(repoRoot, relativeTaskFiles);
   const errors = [...parsed.errors];
   if (parsed.staged.length > 0 && errors.length === 0) {
-    try {
-      const tasks = collectTasksForCycleCheck(repoRoot, parsed.staged);
-      const graph = buildGraphForCycleCheck(tasks);
-      const cycle = detect_cycle(graph);
-      if (cycle) {
-        errors.push(`[COOP] Dependency cycle detected: ${cycle.join(" -> ")}.`);
+    const stagedByProject = /* @__PURE__ */ new Map();
+    for (const staged of parsed.staged) {
+      const existing = stagedByProject.get(staged.projectRoot) ?? [];
+      existing.push(staged);
+      stagedByProject.set(staged.projectRoot, existing);
+    }
+    for (const [projectRoot, stagedTasks] of stagedByProject.entries()) {
+      try {
+        const tasks = collectTasksForCycleCheck(projectRoot, stagedTasks);
+        const graph = buildGraphForCycleCheck(tasks);
+        const cycle = detect_cycle(graph);
+        if (cycle) {
+          const projectLabel = toPosixPath2(path6.relative(repoRoot, projectRoot));
+          errors.push(`[COOP] Dependency cycle detected in ${projectLabel}: ${cycle.join(" -> ")}.`);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`[COOP] Failed to run dependency cycle check: ${message}`);
       }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push(`[COOP] Failed to run dependency cycle check: ${message}`);
     }
   }
   return {
@@ -1806,28 +1903,37 @@ function installPreCommitHook(repoRoot) {
 // src/hooks/post-merge-validate.ts
 import fs5 from "fs";
 import path7 from "path";
+import { list_projects } from "@kitsy/coop-core";
 import { load_graph as load_graph3, validate_graph as validate_graph2 } from "@kitsy/coop-core";
 var HOOK_BLOCK_START2 = "# COOP_POST_MERGE_START";
 var HOOK_BLOCK_END2 = "# COOP_POST_MERGE_END";
 function runPostMergeValidate(repoRoot) {
-  const coopDir2 = path7.join(repoRoot, ".coop");
-  if (!fs5.existsSync(coopDir2)) {
+  const workspaceDir = path7.join(repoRoot, ".coop");
+  if (!fs5.existsSync(workspaceDir)) {
     return {
       ok: true,
       warnings: ["[COOP] Skipped post-merge validation (.coop not found)."]
     };
   }
   try {
-    const graph = load_graph3(coopDir2);
-    const issues = validate_graph2(graph);
-    if (issues.length === 0) {
-      return { ok: true, warnings: [] };
+    const projects = list_projects(repoRoot);
+    if (projects.length === 0) {
+      return {
+        ok: true,
+        warnings: ["[COOP] Skipped post-merge validation (no COOP projects found)."]
+      };
+    }
+    const warnings = [];
+    for (const project of projects) {
+      const graph = load_graph3(project.root);
+      const issues = validate_graph2(graph);
+      for (const issue of issues) {
+        warnings.push(`[COOP] post-merge warning [${project.id}] [${issue.invariant}] ${issue.message}`);
+      }
     }
     return {
       ok: true,
-      warnings: issues.map(
-        (issue) => `[COOP] post-merge warning [${issue.invariant}] ${issue.message}`
-      )
+      warnings
     };
   } catch (error) {
     return {
@@ -1886,14 +1992,32 @@ function installPostMergeHook(repoRoot) {
 }
 
 // src/commands/init.ts
-function buildDefaultConfig(root) {
-  const repoName = repoDisplayName(root);
-  const repoId = repoIdentityId(root);
+function normalizeProjectId(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+function parseAliases2(value) {
+  if (!value) return [];
+  return Array.from(
+    new Set(
+      value.split(",").map((entry) => entry.trim()).filter(Boolean).map(
+        (entry) => entry.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-")
+      ).filter(Boolean)
+    )
+  );
+}
+function aliasesYaml(aliases) {
+  if (aliases.length === 0) {
+    return " []";
+  }
+  return `
+${aliases.map((alias) => `    - "${alias}"`).join("\n")}`;
+}
+function buildProjectConfig(projectId, projectName, projectAliases) {
   return `version: 2
 project:
-  name: "${repoName}"
-  id: "${repoId}"
-  aliases: []
+  name: ${JSON.stringify(projectName)}
+  id: "${projectId}"
+  aliases:${aliasesYaml(projectAliases)}
 
 id_prefixes:
   idea: "IDEA"
@@ -1943,8 +2067,8 @@ api:
   remotes: {}
 
 hooks:
-  on_task_transition: .coop/hooks/on-task-transition.sh
-  on_delivery_complete: .coop/hooks/on-delivery-complete.sh
+  on_task_transition: .coop/projects/${projectId}/hooks/on-task-transition.sh
+  on_delivery_complete: .coop/projects/${projectId}/hooks/on-delivery-complete.sh
 
 index:
   data: yaml
@@ -2016,6 +2140,12 @@ triggers:
       type: github_pr
       operation: merge
 `;
+var COOP_IGNORE_TEMPLATE = `.index/
+logs/
+tmp/
+*.log
+*.tmp
+`;
 function ensureDir(dirPath) {
   fs6.mkdirSync(dirPath, { recursive: true });
 }
@@ -2064,8 +2194,8 @@ function setGitConfig(root, key, value) {
 }
 function installMergeDrivers(root) {
   const entries = [
-    ".coop/tasks/*.md merge=coop-task",
-    ".coop/deliveries/*.yml merge=coop-delivery"
+    ".coop/projects/*/tasks/*.md merge=coop-task",
+    ".coop/projects/*/deliveries/*.yml merge=coop-delivery"
   ];
   for (const entry of entries) {
     ensureGitattributesEntry(root, entry);
@@ -2081,10 +2211,58 @@ function installMergeDrivers(root) {
   }
   return "Updated .gitattributes but could not register merge drivers in git config.";
 }
+async function promptInitIdentity(root, options) {
+  const rl = createInterface({ input, output });
+  const ask2 = async (question, fallback) => {
+    try {
+      const answer = await rl.question(`${question} [${fallback}]: `);
+      return answer.trim() || fallback;
+    } catch {
+      return fallback;
+    }
+  };
+  const defaultName = repoDisplayName(root);
+  try {
+    const initialName = options.name?.trim() || defaultName;
+    const projectName = options.name?.trim() || await ask2("Project name", initialName);
+    const defaultId = options.id?.trim() || normalizeProjectId(projectName) || repoIdentityId(root);
+    const projectIdRaw = options.id?.trim() || await ask2("Project id", defaultId);
+    const projectId = normalizeProjectId(projectIdRaw);
+    if (!projectId) {
+      throw new Error("Invalid project id. Use letters, numbers, and hyphens.");
+    }
+    const aliasesInput = options.aliases !== void 0 ? options.aliases : await ask2("Aliases (csv, optional)", "");
+    return {
+      projectName,
+      projectId,
+      projectAliases: parseAliases2(aliasesInput)
+    };
+  } finally {
+    rl.close();
+  }
+}
+async function resolveInitIdentity(root, options) {
+  const defaultName = repoDisplayName(root);
+  const fallbackName = options.name?.trim() || defaultName;
+  const fallbackId = normalizeProjectId(options.id?.trim() || fallbackName) || repoIdentityId(root);
+  const fallbackAliases = parseAliases2(options.aliases);
+  const interactive = Boolean(options.interactive || !options.yes && input.isTTY && output.isTTY);
+  if (interactive) {
+    return promptInitIdentity(root, options);
+  }
+  return {
+    projectName: fallbackName,
+    projectId: fallbackId,
+    projectAliases: fallbackAliases
+  };
+}
 function registerInitCommand(program) {
-  program.command("init").description("Initialize .coop/ structure in the current repository").action(() => {
+  program.command("init").description("Initialize .coop/ structure in the current repository").option("--name <name>", "Project display name").option("--id <id>", "Project id").option("--aliases <csv>", "Comma-separated project aliases").option("-y, --yes", "Use defaults without prompting").option("--interactive", "Prompt for missing project identity values").action(async (options) => {
     const root = resolveRepoRoot();
-    const coop = coopDir(root);
+    const workspaceDir = coopWorkspaceDir(root);
+    const identity = await resolveInitIdentity(root, options);
+    const projectId = identity.projectId;
+    const projectRoot = path8.join(workspaceDir, "projects", projectId);
     const dirs = [
       "ideas",
       "tasks",
@@ -2100,23 +2278,36 @@ function registerInitCommand(program) {
       "history/deliveries",
       ".index"
     ];
+    ensureDir(path8.join(workspaceDir, "projects"));
     for (const dir of dirs) {
-      ensureDir(path8.join(coop, dir));
+      ensureDir(path8.join(projectRoot, dir));
     }
-    writeIfMissing(path8.join(coop, "config.yml"), buildDefaultConfig(root));
-    if (!fs6.existsSync(path8.join(coop, "schema-version"))) {
-      write_schema_version(coop, CURRENT_SCHEMA_VERSION);
+    writeIfMissing(
+      path8.join(projectRoot, "config.yml"),
+      buildProjectConfig(projectId, identity.projectName, identity.projectAliases)
+    );
+    if (!fs6.existsSync(path8.join(projectRoot, "schema-version"))) {
+      write_schema_version(projectRoot, CURRENT_SCHEMA_VERSION);
     }
-    writeIfMissing(path8.join(coop, "templates/task.md"), TASK_TEMPLATE);
-    writeIfMissing(path8.join(coop, "templates/idea.md"), IDEA_TEMPLATE);
-    writeIfMissing(path8.join(coop, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
-    writeIfMissing(path8.join(coop, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
-    ensureGitignoreEntry(root, ".coop/.index/");
+    writeIfMissing(path8.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
+    writeIfMissing(path8.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE);
+    writeIfMissing(path8.join(projectRoot, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
+    writeIfMissing(path8.join(projectRoot, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
+    writeIfMissing(path8.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE);
+    writeIfMissing(path8.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE);
+    writeWorkspaceConfig(root, { version: 2, current_project: projectId });
+    ensureGitignoreEntry(root, ".coop/logs/");
+    ensureGitignoreEntry(root, ".coop/tmp/");
     const preCommitHook = installPreCommitHook(root);
     const postMergeHook = installPostMergeHook(root);
     const mergeDrivers = installMergeDrivers(root);
+    const project = resolveProject(root, projectId);
     console.log("Initialized COOP workspace.");
     console.log(`- Root: ${root}`);
+    console.log(`- Workspace: ${path8.relative(root, workspaceDir)}`);
+    console.log(`- Project: ${project.id} (${path8.relative(root, project.root)})`);
+    console.log(`- Name: ${identity.projectName}`);
+    console.log(`- Aliases: ${identity.projectAliases.length > 0 ? identity.projectAliases.join(", ") : "(none)"}`);
     console.log(`- ${preCommitHook.message}`);
     if (preCommitHook.installed) {
       console.log(`- Hook: ${path8.relative(root, preCommitHook.hookPath)}`);
@@ -2275,11 +2466,11 @@ function resolveRepoSafe(start = process.cwd()) {
 }
 function resolveCliLogFile(start = process.cwd()) {
   const root = resolveRepoSafe(start);
-  const coop = coopDir(root);
-  if (fs7.existsSync(coop)) {
-    return path10.join(coop, "logs", "cli.log");
+  const workspace = coopWorkspaceDir(root);
+  if (fs7.existsSync(workspace)) {
+    return path10.join(workspace, "logs", "cli.log");
   }
-  return path10.join(root, ".coop-cli.log");
+  return path10.join(resolveCoopHome(), "logs", "cli.log");
 }
 function appendLogEntry(entry, logFile) {
   fs7.mkdirSync(path10.dirname(logFile), { recursive: true });
@@ -2358,8 +2549,11 @@ function registerLogCommand(program) {
 }
 
 // src/commands/migrate.ts
+import fs8 from "fs";
 import path11 from "path";
-import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, migrate_repository } from "@kitsy/coop-core";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager2, migrate_repository, parseYamlFile as parseYamlFile2, writeYamlFile as writeYamlFile4 } from "@kitsy/coop-core";
 function parseTargetVersion(raw) {
   if (!raw) return CURRENT_SCHEMA_VERSION2;
   const parsed = Number(raw);
@@ -2368,8 +2562,160 @@ function parseTargetVersion(raw) {
   }
   return parsed;
 }
+function legacyWorkspaceProjectEntries(root) {
+  const workspaceDir = coopWorkspaceDir(root);
+  return [
+    "config.yml",
+    "schema-version",
+    "ideas",
+    "tasks",
+    "tracks",
+    "deliveries",
+    "resources",
+    "templates",
+    "plugins",
+    "hooks",
+    "runs",
+    "decisions",
+    "history",
+    ".index",
+    "views",
+    "backlog",
+    "plans",
+    "releases"
+  ].filter((entry) => fs8.existsSync(path11.join(workspaceDir, entry)));
+}
+function normalizeProjectId2(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+function parseAliases3(value) {
+  if (!value) return [];
+  return Array.from(
+    new Set(
+      value.split(",").map((entry) => entry.trim()).filter(Boolean).map(
+        (entry) => entry.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-")
+      ).filter(Boolean)
+    )
+  );
+}
+async function promptProjectIdentity(defaults, options) {
+  const rl = createInterface2({ input: input2, output: output2 });
+  const ask2 = async (question, fallback) => {
+    try {
+      const answer = await rl.question(`${question} [${fallback}]: `);
+      return answer.trim() || fallback;
+    } catch {
+      return fallback;
+    }
+  };
+  try {
+    const projectName = options.name?.trim() || await ask2("Project name", defaults.projectName);
+    const projectIdRaw = options.id?.trim() || await ask2("Project id", defaults.projectId);
+    const projectId = normalizeProjectId2(projectIdRaw);
+    if (!projectId) {
+      throw new Error("Invalid project id. Use letters, numbers, and hyphens.");
+    }
+    const aliasesInput = options.aliases !== void 0 ? options.aliases : await ask2("Aliases (csv, optional)", defaults.projectAliases.join(","));
+    return {
+      projectName,
+      projectId,
+      projectAliases: parseAliases3(aliasesInput)
+    };
+  } finally {
+    rl.close();
+  }
+}
+async function resolveMigrationIdentity(root, options) {
+  const existing = readCoopConfig(root);
+  const defaults = {
+    projectName: existing.projectName || path11.basename(root),
+    projectId: normalizeProjectId2(existing.projectId || repoIdentityId(root)) || repoIdentityId(root),
+    projectAliases: options.aliases !== void 0 ? parseAliases3(options.aliases) : existing.projectAliases
+  };
+  const interactive = Boolean(options.interactive || !options.yes && input2.isTTY && output2.isTTY);
+  if (interactive) {
+    return promptProjectIdentity(defaults, options);
+  }
+  return {
+    projectName: options.name?.trim() || defaults.projectName,
+    projectId: normalizeProjectId2(options.id?.trim() || defaults.projectId) || defaults.projectId,
+    projectAliases: options.aliases !== void 0 ? parseAliases3(options.aliases) : defaults.projectAliases
+  };
+}
+async function migrateWorkspaceLayout(root, options) {
+  const target = (options.to ?? "").trim().toLowerCase();
+  if (target !== "v2") {
+    throw new Error(`Unsupported workspace-layout target '${options.to ?? ""}'. Expected 'v2'.`);
+  }
+  const workspaceDir = coopWorkspaceDir(root);
+  if (!fs8.existsSync(workspaceDir)) {
+    throw new Error("Missing .coop directory. Run 'coop init' first.");
+  }
+  const projectsDir = path11.join(workspaceDir, "projects");
+  const legacyEntries = legacyWorkspaceProjectEntries(root);
+  if (legacyEntries.length === 0 && fs8.existsSync(projectsDir)) {
+    console.log("[COOP] workspace layout already uses v2.");
+    return;
+  }
+  const identity = await resolveMigrationIdentity(root, options);
+  const projectId = identity.projectId;
+  const projectRoot = path11.join(projectsDir, projectId);
+  if (fs8.existsSync(projectRoot) && !options.force) {
+    throw new Error(`Project destination '${path11.relative(root, projectRoot)}' already exists. Re-run with --force.`);
+  }
+  const changed = legacyEntries.map((entry) => `${path11.join(".coop", entry)} -> ${path11.join(".coop", "projects", projectId, entry)}`);
+  changed.push(`.coop/config.yml -> workspace current_project=${projectId}`);
+  console.log(`Workspace layout migration (${options.dryRun ? "DRY RUN" : "APPLY"})`);
+  console.log(`- from: v1 flat layout`);
+  console.log(`- to:   v2 multi-project layout`);
+  console.log(`- project: ${projectId}`);
+  console.log(`- name: ${identity.projectName}`);
+  console.log(`- aliases: ${identity.projectAliases.length > 0 ? identity.projectAliases.join(", ") : "(none)"}`);
+  console.log(`- entries: ${legacyEntries.length}`);
+  for (const entry of changed) {
+    console.log(`  - ${entry}`);
+  }
+  if (options.dryRun) {
+    console.log("- no files were modified.");
+    return;
+  }
+  fs8.mkdirSync(projectsDir, { recursive: true });
+  fs8.mkdirSync(projectRoot, { recursive: true });
+  for (const entry of legacyEntries) {
+    const source = path11.join(workspaceDir, entry);
+    const destination = path11.join(projectRoot, entry);
+    if (fs8.existsSync(destination)) {
+      if (!options.force) {
+        throw new Error(`Destination '${path11.relative(root, destination)}' already exists.`);
+      }
+      fs8.rmSync(destination, { recursive: true, force: true });
+    }
+    fs8.renameSync(source, destination);
+  }
+  const movedConfigPath = path11.join(projectRoot, "config.yml");
+  if (fs8.existsSync(movedConfigPath)) {
+    const movedConfig = parseYamlFile2(movedConfigPath);
+    const nextProject = typeof movedConfig.project === "object" && movedConfig.project !== null ? { ...movedConfig.project } : {};
+    nextProject.name = identity.projectName;
+    nextProject.id = projectId;
+    nextProject.aliases = identity.projectAliases;
+    const nextHooks = typeof movedConfig.hooks === "object" && movedConfig.hooks !== null ? { ...movedConfig.hooks } : {};
+    nextHooks.on_task_transition = `.coop/projects/${projectId}/hooks/on-task-transition.sh`;
+    nextHooks.on_delivery_complete = `.coop/projects/${projectId}/hooks/on-delivery-complete.sh`;
+    writeYamlFile4(movedConfigPath, {
+      ...movedConfig,
+      project: nextProject,
+      hooks: nextHooks
+    });
+  }
+  const workspace = readWorkspaceConfig(root);
+  writeWorkspaceConfig(root, { ...workspace, version: 2, current_project: projectId });
+  const manager = new IndexManager2(projectRoot);
+  manager.build_full_index();
+  console.log(`[COOP] migrated workspace to v2 at ${path11.relative(root, projectRoot)}`);
+}
 function registerMigrateCommand(program) {
-  program.command("migrate").description("Migrate .coop data to a schema version").option("--dry-run", "Preview migration without writing files").option("--to <version>", "Target schema version", String(CURRENT_SCHEMA_VERSION2)).action((options) => {
+  const migrate = program.command("migrate").description("Migrate COOP data and workspace layouts").option("--dry-run", "Preview migration without writing files").option("--to <version>", "Target schema version", String(CURRENT_SCHEMA_VERSION2)).action((options) => {
     const root = resolveRepoRoot();
     ensureCoopInitialized(root);
     const target = parseTargetVersion(options.to);
@@ -2394,6 +2740,15 @@ function registerMigrateCommand(program) {
       console.log(`- schema-version updated to v${report.to_version}`);
     }
   });
+  migrate.command("workspace-layout").description("Migrate a flat v1 workspace layout to the v2 multi-project layout").option("--dry-run", "Preview migration without writing files").option("--to <version>", "Target workspace layout version", "v2").option("--force", "Overwrite an existing destination project directory").option("--name <name>", "Project display name").option("--id <id>", "Project id").option("--aliases <csv>", "Comma-separated project aliases").option("-y, --yes", "Use existing project identity defaults without prompting").option("--interactive", "Prompt for project identity during migration").action(async (options) => {
+    const root = resolveRepoRoot();
+    const parentOptions = migrate.opts();
+    await migrateWorkspaceLayout(root, {
+      ...parentOptions,
+      ...options,
+      dryRun: Boolean(options.dryRun || parentOptions.dryRun)
+    });
+  });
 }
 
 // src/commands/plan.ts
@@ -2629,9 +2984,206 @@ function registerPlanCommand(program) {
   });
 }
 
-// src/commands/run.ts
-import fs8 from "fs";
+// src/commands/project.ts
+import fs9 from "fs";
 import path12 from "path";
+import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION3, write_schema_version as write_schema_version2 } from "@kitsy/coop-core";
+var TASK_TEMPLATE2 = `---
+id: TASK-001
+title: "Implement feature"
+type: feature
+status: todo
+created: 2026-03-06
+updated: 2026-03-06
+aliases: []
+priority: p2
+track: unassigned
+depends_on: []
+---
+
+## Context
+Why this task exists.
+`;
+var IDEA_TEMPLATE2 = `---
+id: IDEA-001
+title: "New idea"
+created: 2026-03-06
+aliases: []
+author: your-name
+status: captured
+tags: []
+source: manual
+linked_tasks: []
+---
+
+## Problem
+What problem are you solving?
+`;
+var PROJECT_CONFIG_TEMPLATE = (projectId, projectName) => `version: 2
+project:
+  name: "${projectName}"
+  id: "${projectId}"
+  aliases: []
+
+id_prefixes:
+  idea: "IDEA"
+  task: "PM"
+  delivery: "DEL"
+  run: "RUN"
+
+id:
+  naming: "<TYPE>-<USER>-<YYMMDD>-<RAND>"
+  seq_padding: 0
+
+defaults:
+  task:
+    type: feature
+    priority: p2
+    complexity: medium
+    determinism: medium
+  track: unassigned
+
+scheduling:
+  algorithm: critical-path
+  velocity_window_weeks: 4
+  overhead_factor: 1.2
+
+ai:
+  provider: mock
+  model: mock-local
+  default_executor: claude-sonnet
+  sandbox: true
+  max_concurrent_agents: 4
+  token_budget_per_task: 50000
+
+plugins:
+  enabled: []
+
+github:
+  owner: ""
+  repo: ""
+  base_branch: main
+  token_env: GITHUB_TOKEN
+  webhook_secret_env: GITHUB_WEBHOOK_SECRET
+  merge_method: squash
+
+api:
+  host: 127.0.0.1
+  port: 3847
+  remotes: {}
+
+hooks:
+  on_task_transition: .coop/projects/${projectId}/hooks/on-task-transition.sh
+  on_delivery_complete: .coop/projects/${projectId}/hooks/on-delivery-complete.sh
+
+index:
+  data: yaml
+`;
+var PROJECT_DIRS = [
+  "ideas",
+  "tasks",
+  "tracks",
+  "deliveries",
+  "resources",
+  "templates",
+  "plugins",
+  "hooks",
+  "runs",
+  "decisions",
+  "history/tasks",
+  "history/deliveries",
+  ".index"
+];
+function ensureDir2(dirPath) {
+  fs9.mkdirSync(dirPath, { recursive: true });
+}
+function writeIfMissing2(filePath, content) {
+  if (!fs9.existsSync(filePath)) {
+    fs9.writeFileSync(filePath, content, "utf8");
+  }
+}
+function normalizeProjectId3(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+}
+function createProject(root, projectId, projectName) {
+  const workspaceDir = coopWorkspaceDir(root);
+  const projectRoot = path12.join(workspaceDir, "projects", projectId);
+  ensureDir2(path12.join(workspaceDir, "projects"));
+  for (const dir of PROJECT_DIRS) {
+    ensureDir2(path12.join(projectRoot, dir));
+  }
+  writeIfMissing2(path12.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName));
+  if (!fs9.existsSync(path12.join(projectRoot, "schema-version"))) {
+    write_schema_version2(projectRoot, CURRENT_SCHEMA_VERSION3);
+  }
+  writeIfMissing2(path12.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
+  writeIfMissing2(path12.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE2);
+  return projectRoot;
+}
+function registerProjectCommand(program) {
+  const project = program.command("project").description("Manage COOP projects");
+  project.command("list").description("List COOP projects in the current workspace").action(() => {
+    const root = resolveRepoRoot();
+    const projects = listProjects(root);
+    const workspace = readWorkspaceConfig(root);
+    if (projects.length === 0) {
+      console.log("No COOP projects found.");
+      return;
+    }
+    for (const item of projects) {
+      const current = workspace.current_project === item.id ? " *" : "";
+      console.log(`${item.id}${current}  ${item.name}`);
+    }
+  });
+  project.command("show").description("Show the active or selected COOP project").argument("[id]", "Optional project id").action((id) => {
+    const root = resolveRepoRoot();
+    const projects = listProjects(root);
+    const workspace = readWorkspaceConfig(root);
+    const active = (id ? projects.find((item) => item.id === id) : void 0) ?? projects.find((item) => item.id === workspace.current_project) ?? projects[0];
+    if (!active) {
+      throw new Error("No COOP projects found.");
+    }
+    console.log(`id=${active.id}`);
+    console.log(`name=${active.name}`);
+    console.log(`path=${path12.relative(root, active.root)}`);
+    console.log(`layout=${active.layout}`);
+  });
+  project.command("use").description("Set the active COOP project").argument("<id>", "Project id").action((id) => {
+    const root = resolveRepoRoot();
+    const projects = listProjects(root);
+    const match = projects.find((item) => item.id === id);
+    if (!match) {
+      throw new Error(`Project '${id}' not found.`);
+    }
+    const workspace = readWorkspaceConfig(root);
+    writeWorkspaceConfig(root, { ...workspace, version: 2, current_project: match.id });
+    console.log(`current_project=${match.id}`);
+  });
+  project.command("create").description("Create a new COOP project in the current workspace").argument("<id>", "Project id").option("--name <name>", "Project display name").action((id, options) => {
+    const root = resolveRepoRoot();
+    const projectId = normalizeProjectId3(id);
+    if (!projectId) {
+      throw new Error("Invalid project id. Use letters, numbers, and hyphens.");
+    }
+    const existing = listProjects(root).find((item) => item.id === projectId);
+    if (existing) {
+      throw new Error(`Project '${projectId}' already exists.`);
+    }
+    const projectName = options.name?.trim() || repoDisplayName(root);
+    const projectRoot = createProject(root, projectId, projectName);
+    const workspace = readWorkspaceConfig(root);
+    writeWorkspaceConfig(root, {
+      ...workspace,
+      version: 2,
+      current_project: workspace.current_project || projectId
+    });
+    console.log(`Created project '${projectId}' at ${path12.relative(root, projectRoot)}`);
+  });
+}
+
+// src/commands/run.ts
+import fs10 from "fs";
+import path13 from "path";
 import { load_graph as load_graph5, parseTaskFile as parseTaskFile7 } from "@kitsy/coop-core";
 import {
   build_contract,
@@ -2641,8 +3193,8 @@ import {
 } from "@kitsy/coop-ai";
 function loadTask(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
-  const taskFile = path12.join(root, ...target.file.split("/"));
-  if (!fs8.existsSync(taskFile)) {
+  const taskFile = path13.join(root, ...target.file.split("/"));
+  if (!fs10.existsSync(taskFile)) {
     throw new Error(`Task file not found: ${target.file}`);
   }
   return parseTaskFile7(taskFile).task;
@@ -2681,22 +3233,22 @@ function registerRunCommand(program) {
       on_progress: (message) => console.log(`[COOP] ${message}`)
     });
     if (result.status === "failed") {
-      throw new Error(`Run failed: ${result.run.id}. Log: ${path12.relative(root, result.log_path)}`);
+      throw new Error(`Run failed: ${result.run.id}. Log: ${path13.relative(root, result.log_path)}`);
     }
     if (result.status === "paused") {
       console.log(`[COOP] run paused: ${result.run.id}`);
-      console.log(`[COOP] log: ${path12.relative(root, result.log_path)}`);
+      console.log(`[COOP] log: ${path13.relative(root, result.log_path)}`);
       return;
     }
     console.log(`[COOP] run completed: ${result.run.id}`);
-    console.log(`[COOP] log: ${path12.relative(root, result.log_path)}`);
+    console.log(`[COOP] log: ${path13.relative(root, result.log_path)}`);
   });
 }
 
 // src/server/api.ts
-import fs9 from "fs";
+import fs11 from "fs";
 import http from "http";
-import path13 from "path";
+import path14 from "path";
 import {
   analyze_feasibility as analyze_feasibility2,
   load_graph as load_graph6,
@@ -2742,12 +3294,12 @@ function taskSummary(graph, task, external = []) {
   };
 }
 function taskFileById(root, id) {
-  const tasksDir = path13.join(root, ".coop", "tasks");
-  if (!fs9.existsSync(tasksDir)) return null;
-  const entries = fs9.readdirSync(tasksDir, { withFileTypes: true });
+  const tasksDir = path14.join(resolveProject(root).root, "tasks");
+  if (!fs11.existsSync(tasksDir)) return null;
+  const entries = fs11.readdirSync(tasksDir, { withFileTypes: true });
   const target = `${id}.md`.toLowerCase();
   const match = entries.find((entry) => entry.isFile() && entry.name.toLowerCase() === target);
-  return match ? path13.join(tasksDir, match.name) : null;
+  return match ? path14.join(tasksDir, match.name) : null;
 }
 function loadRemoteConfig(root) {
   const raw = readCoopConfig(root).raw;
@@ -2811,7 +3363,8 @@ function createApiServer(root, options = {}) {
         json(res, 200, workspaceMeta(repoRoot));
         return;
       }
-      const coopPath = coopDir(repoRoot);
+      const project = resolveProject(repoRoot);
+      const coopPath = project.root;
       const graph = load_graph6(coopPath);
       const resolutions = await externalResolutions(repoRoot, graph, options);
       if (pathname === "/api/tasks") {
@@ -2836,7 +3389,7 @@ function createApiServer(root, options = {}) {
             created: task.created,
             updated: task.updated,
             body: parsed.body,
-            file_path: path13.relative(repoRoot, filePath).replace(/\\/g, "/")
+            file_path: path14.relative(repoRoot, filePath).replace(/\\/g, "/")
           }
         });
         return;
@@ -2924,8 +3477,8 @@ function registerServeCommand(program) {
 }
 
 // src/commands/show.ts
-import fs10 from "fs";
-import path14 from "path";
+import fs12 from "fs";
+import path15 from "path";
 import { parseIdeaFile as parseIdeaFile4, parseTaskFile as parseTaskFile9 } from "@kitsy/coop-core";
 function stringify(value) {
   if (value === null || value === void 0) return "-";
@@ -2934,13 +3487,13 @@ function stringify(value) {
   return String(value);
 }
 function loadComputedFromIndex(root, taskId) {
-  const indexPath = path14.join(root, ".coop", ".index", "tasks.json");
-  if (!fs10.existsSync(indexPath)) {
+  const indexPath = path15.join(ensureCoopInitialized(root), ".index", "tasks.json");
+  if (!fs12.existsSync(indexPath)) {
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs10.readFileSync(indexPath, "utf8"));
+    parsed = JSON.parse(fs12.readFileSync(indexPath, "utf8"));
   } catch {
     return null;
   }
@@ -2979,7 +3532,7 @@ function showTask(taskId) {
   const root = resolveRepoRoot();
   const coop = ensureCoopInitialized(root);
   const target = resolveReference(root, taskId, "task");
-  const taskFile = path14.join(root, ...target.file.split("/"));
+  const taskFile = path15.join(root, ...target.file.split("/"));
   const parsed = parseTaskFile9(taskFile);
   const task = parsed.task;
   const body = parsed.body.trim();
@@ -2998,7 +3551,7 @@ function showTask(taskId) {
     `Tags: ${stringify(task.tags)}`,
     `Created: ${task.created}`,
     `Updated: ${task.updated}`,
-    `File: ${path14.relative(root, taskFile)}`,
+    `File: ${path15.relative(root, taskFile)}`,
     "",
     "Body:",
     body || "-",
@@ -3006,7 +3559,7 @@ function showTask(taskId) {
     "Computed:"
   ];
   if (!computed) {
-    lines.push(`index not built (${path14.relative(root, path14.join(coop, ".index", "tasks.json"))} missing)`);
+    lines.push(`index not built (${path15.relative(root, path15.join(coop, ".index", "tasks.json"))} missing)`);
   } else {
     for (const [key, value] of Object.entries(computed)) {
       lines.push(`- ${key}: ${stringify(value)}`);
@@ -3018,7 +3571,7 @@ function showIdea(ideaId) {
   const root = resolveRepoRoot();
   ensureCoopInitialized(root);
   const target = resolveReference(root, ideaId, "idea");
-  const ideaFile = path14.join(root, ...target.file.split("/"));
+  const ideaFile = path15.join(root, ...target.file.split("/"));
   const parsed = parseIdeaFile4(ideaFile);
   const idea = parsed.idea;
   const body = parsed.body.trim();
@@ -3032,7 +3585,7 @@ function showIdea(ideaId) {
     `Tags: ${stringify(idea.tags)}`,
     `Linked Tasks: ${stringify(idea.linked_tasks)}`,
     `Created: ${idea.created}`,
-    `File: ${path14.relative(root, ideaFile)}`,
+    `File: ${path15.relative(root, ideaFile)}`,
     "",
     "Body:",
     body || "-"
@@ -3139,7 +3692,7 @@ function registerStatusCommand(program) {
 }
 
 // src/commands/transition.ts
-import path15 from "path";
+import path16 from "path";
 import {
   TaskStatus as TaskStatus3,
   check_permission as check_permission3,
@@ -3168,8 +3721,8 @@ import { Octokit } from "octokit";
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function sanitizeBranchPart(input, fallback) {
-  const normalized = input.trim().toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+function sanitizeBranchPart(input3, fallback) {
+  const normalized = input3.trim().toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || fallback;
 }
 function readGitRemote(root) {
@@ -3302,15 +3855,15 @@ function toGitHubClient(config) {
     baseUrl: config.apiBaseUrl
   });
   return {
-    async createPullRequest(input) {
+    async createPullRequest(input3) {
       const response = await octokit.rest.pulls.create({
-        owner: input.owner,
-        repo: input.repo,
-        title: input.title,
-        body: input.body,
-        head: input.head,
-        base: input.base,
-        draft: input.draft
+        owner: input3.owner,
+        repo: input3.repo,
+        title: input3.title,
+        body: input3.body,
+        head: input3.head,
+        base: input3.base,
+        draft: input3.draft
       });
       return {
         number: response.data.number,
@@ -3320,14 +3873,14 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async updatePullRequest(input) {
+    async updatePullRequest(input3) {
       const response = await octokit.rest.pulls.update({
-        owner: input.owner,
-        repo: input.repo,
-        pull_number: input.pull_number,
-        title: input.title,
-        body: input.body,
-        base: input.base
+        owner: input3.owner,
+        repo: input3.repo,
+        pull_number: input3.pull_number,
+        title: input3.title,
+        body: input3.body,
+        base: input3.base
       });
       return {
         number: response.data.number,
@@ -3337,11 +3890,11 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async getPullRequest(input) {
+    async getPullRequest(input3) {
       const response = await octokit.rest.pulls.get({
-        owner: input.owner,
-        repo: input.repo,
-        pull_number: input.pull_number
+        owner: input3.owner,
+        repo: input3.repo,
+        pull_number: input3.pull_number
       });
       return {
         number: response.data.number,
@@ -3351,12 +3904,12 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async mergePullRequest(input) {
+    async mergePullRequest(input3) {
       const response = await octokit.rest.pulls.merge({
-        owner: input.owner,
-        repo: input.repo,
-        pull_number: input.pull_number,
-        merge_method: input.merge_method
+        owner: input3.owner,
+        repo: input3.repo,
+        pull_number: input3.pull_number,
+        merge_method: input3.merge_method
       });
       return {
         merged: response.data.merged,
@@ -3372,7 +3925,9 @@ function readGitHubConfig(root) {
   const owner = typeof githubRaw.owner === "string" && githubRaw.owner.trim() ? githubRaw.owner.trim() : inferred?.owner;
   const repo = typeof githubRaw.repo === "string" && githubRaw.repo.trim() ? githubRaw.repo.trim() : inferred?.repo;
   if (!owner || !repo) {
-    throw new Error("GitHub integration requires github.owner and github.repo in .coop/config.yml or a GitHub origin remote.");
+    throw new Error(
+      "GitHub integration requires github.owner and github.repo in the active COOP project config or a GitHub origin remote."
+    );
   }
   const tokenEnv = typeof githubRaw.token_env === "string" && githubRaw.token_env.trim() ? githubRaw.token_env.trim() : "GITHUB_TOKEN";
   const token = process.env[tokenEnv];
@@ -3733,7 +4288,7 @@ function registerTransitionCommand(program) {
       }
       console.warn(`[COOP][auth] override: user '${user}' forced transition_task on '${reference.id}'.`);
     }
-    const filePath = path15.join(root, ...reference.file.split("/"));
+    const filePath = path16.join(root, ...reference.file.split("/"));
     const parsed = parseTaskFile11(filePath);
     const result = transition2(parsed.task, target, {
       actor: options.actor ?? user,
@@ -3779,19 +4334,19 @@ ${errors}`);
 }
 
 // src/commands/ui.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs13 from "fs";
+import path17 from "path";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
-import { IndexManager as IndexManager2 } from "@kitsy/coop-core";
+import { IndexManager as IndexManager3 } from "@kitsy/coop-core";
 function findPackageRoot(entryPath) {
-  let current = path16.dirname(entryPath);
+  let current = path17.dirname(entryPath);
   while (true) {
-    if (fs11.existsSync(path16.join(current, "package.json"))) {
+    if (fs13.existsSync(path17.join(current, "package.json"))) {
       return current;
     }
-    const parent = path16.dirname(current);
+    const parent = path17.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to locate package root for ${entryPath}.`);
     }
@@ -3822,7 +4377,7 @@ function openBrowser(url) {
 }
 function ensureIndex(repoRoot) {
   const directory = ensureCoopInitialized(repoRoot);
-  const manager = new IndexManager2(directory);
+  const manager = new IndexManager3(directory);
   if (manager.is_stale() || !manager.load_indexed_graph()) {
     manager.build_full_index();
   }
@@ -3837,11 +4392,12 @@ function attachSignalForwarding(child) {
   process.once("SIGTERM", () => forward("SIGTERM"));
 }
 async function startUiServer(repoRoot, host, port, shouldOpen) {
+  const project = resolveProject(repoRoot);
   ensureIndex(repoRoot);
   const uiRoot = resolveUiPackageRoot();
-  const requireFromUi = createRequire(path16.join(uiRoot, "package.json"));
+  const requireFromUi = createRequire(path17.join(uiRoot, "package.json"));
   const vitePackageJson = requireFromUi.resolve("vite/package.json");
-  const viteBin = path16.join(path16.dirname(vitePackageJson), "bin", "vite.js");
+  const viteBin = path17.join(path17.dirname(vitePackageJson), "bin", "vite.js");
   const url = `http://${host}:${port}`;
   console.log(`COOP UI: ${url}`);
   const child = spawn(process.execPath, [viteBin, "--host", host, "--port", String(port)], {
@@ -3850,6 +4406,7 @@ async function startUiServer(repoRoot, host, port, shouldOpen) {
     env: {
       ...process.env,
       COOP_REPO_ROOT: repoRoot,
+      COOP_PROJECT_ID: project.id,
       COOP_UI_HOST: host,
       COOP_UI_PORT: String(port)
     }
@@ -4197,9 +4754,9 @@ function registerWebhookCommand(program) {
 }
 
 // src/merge-driver/merge-driver.ts
-import fs12 from "fs";
+import fs14 from "fs";
 import os2 from "os";
-import path17 from "path";
+import path18 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { stringifyFrontmatter as stringifyFrontmatter3, parseFrontmatterContent, parseYamlContent, stringifyYamlContent } from "@kitsy/coop-core";
 var STATUS_RANK = {
@@ -4258,16 +4815,16 @@ function chooseFieldValue(key, baseValue, oursValue, theirsValue, oursUpdated, t
 }
 function mergeTaskFrontmatter(base, ours, theirs) {
   const keys = /* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(ours), ...Object.keys(theirs)]);
-  const output = {};
+  const output3 = {};
   const oursUpdated = asTimestamp(ours.updated);
   const theirsUpdated = asTimestamp(theirs.updated);
   for (const key of keys) {
     const merged = chooseFieldValue(key, base[key], ours[key], theirs[key], oursUpdated, theirsUpdated);
     if (merged !== void 0) {
-      output[key] = merged;
+      output3[key] = merged;
     }
   }
-  return output;
+  return output3;
 }
 function mergeTextWithGit(ancestor, ours, theirs) {
   const result = spawnSync5("git", ["merge-file", "-p", ours, ancestor, theirs], {
@@ -4282,33 +4839,33 @@ function mergeTextWithGit(ancestor, ours, theirs) {
   return { ok: false, output: stdout };
 }
 function mergeTaskFile(ancestorPath, oursPath, theirsPath) {
-  const ancestorRaw = fs12.readFileSync(ancestorPath, "utf8");
-  const oursRaw = fs12.readFileSync(oursPath, "utf8");
-  const theirsRaw = fs12.readFileSync(theirsPath, "utf8");
+  const ancestorRaw = fs14.readFileSync(ancestorPath, "utf8");
+  const oursRaw = fs14.readFileSync(oursPath, "utf8");
+  const theirsRaw = fs14.readFileSync(theirsPath, "utf8");
   const ancestor = parseTaskDocument(ancestorRaw, ancestorPath);
   const ours = parseTaskDocument(oursRaw, oursPath);
   const theirs = parseTaskDocument(theirsRaw, theirsPath);
   const mergedFrontmatter = mergeTaskFrontmatter(ancestor.frontmatter, ours.frontmatter, theirs.frontmatter);
-  const tempDir = fs12.mkdtempSync(path17.join(os2.tmpdir(), "coop-merge-body-"));
+  const tempDir = fs14.mkdtempSync(path18.join(os2.tmpdir(), "coop-merge-body-"));
   try {
-    const ancestorBody = path17.join(tempDir, "ancestor.md");
-    const oursBody = path17.join(tempDir, "ours.md");
-    const theirsBody = path17.join(tempDir, "theirs.md");
-    fs12.writeFileSync(ancestorBody, ancestor.body, "utf8");
-    fs12.writeFileSync(oursBody, ours.body, "utf8");
-    fs12.writeFileSync(theirsBody, theirs.body, "utf8");
+    const ancestorBody = path18.join(tempDir, "ancestor.md");
+    const oursBody = path18.join(tempDir, "ours.md");
+    const theirsBody = path18.join(tempDir, "theirs.md");
+    fs14.writeFileSync(ancestorBody, ancestor.body, "utf8");
+    fs14.writeFileSync(oursBody, ours.body, "utf8");
+    fs14.writeFileSync(theirsBody, theirs.body, "utf8");
     const mergedBody = mergeTextWithGit(ancestorBody, oursBody, theirsBody);
-    const output = stringifyFrontmatter3(mergedFrontmatter, mergedBody.output);
-    fs12.writeFileSync(oursPath, output, "utf8");
+    const output3 = stringifyFrontmatter3(mergedFrontmatter, mergedBody.output);
+    fs14.writeFileSync(oursPath, output3, "utf8");
     return mergedBody.ok ? 0 : 1;
   } finally {
-    fs12.rmSync(tempDir, { recursive: true, force: true });
+    fs14.rmSync(tempDir, { recursive: true, force: true });
   }
 }
 function mergeDeliveryFile(ancestorPath, oursPath, theirsPath) {
-  const ancestor = parseYamlContent(fs12.readFileSync(ancestorPath, "utf8"), ancestorPath);
-  const ours = parseYamlContent(fs12.readFileSync(oursPath, "utf8"), oursPath);
-  const theirs = parseYamlContent(fs12.readFileSync(theirsPath, "utf8"), theirsPath);
+  const ancestor = parseYamlContent(fs14.readFileSync(ancestorPath, "utf8"), ancestorPath);
+  const ours = parseYamlContent(fs14.readFileSync(oursPath, "utf8"), oursPath);
+  const theirs = parseYamlContent(fs14.readFileSync(theirsPath, "utf8"), theirsPath);
   const oursUpdated = asTimestamp(ours.updated);
   const theirsUpdated = asTimestamp(theirs.updated);
   const base = ancestor;
@@ -4318,7 +4875,7 @@ function mergeDeliveryFile(ancestorPath, oursPath, theirsPath) {
     const value = chooseFieldValue(key, base[key], ours[key], theirs[key], oursUpdated, theirsUpdated);
     if (value !== void 0) merged[key] = value;
   }
-  fs12.writeFileSync(oursPath, stringifyYamlContent(merged), "utf8");
+  fs14.writeFileSync(oursPath, stringifyYamlContent(merged), "utf8");
   return 0;
 }
 function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
@@ -4331,9 +4888,9 @@ function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
 // src/index.ts
 function readVersion() {
   const currentFile = fileURLToPath2(import.meta.url);
-  const packageJsonPath = path18.resolve(path18.dirname(currentFile), "..", "package.json");
+  const packageJsonPath = path19.resolve(path19.dirname(currentFile), "..", "package.json");
   try {
-    const parsed = JSON.parse(fs13.readFileSync(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(fs15.readFileSync(packageJsonPath, "utf8"));
     return parsed.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -4350,6 +4907,7 @@ function createProgram() {
   program.version(readVersion());
   program.description("COOP CLI");
   program.option("--verbose", "Print stack traces for command errors");
+  program.option("-p, --project <id>", "Select the active COOP project");
   registerInitCommand(program);
   registerCreateCommand(program);
   registerAssignCommand(program);
@@ -4363,6 +4921,7 @@ function createProgram() {
   registerLogCommand(program);
   registerMigrateCommand(program);
   registerPlanCommand(program);
+  registerProjectCommand(program);
   registerRunCommand(program);
   registerServeCommand(program);
   registerStatusCommand(program);
@@ -4426,7 +4985,7 @@ async function runCli(argv = process.argv) {
 function isMainModule() {
   const entry = process.argv[1];
   if (!entry) return false;
-  return import.meta.url === pathToFileURL(path18.resolve(entry)).href;
+  return path19.resolve(entry) === fileURLToPath2(import.meta.url);
 }
 if (isMainModule()) {
   await runCli(process.argv);