@kitsy/coop 2.1.2 → 2.2.1

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs18 from "fs";
-import path24 from "path";
+import fs22 from "fs";
+import path26 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
@@ -223,6 +223,9 @@ function listTrackFiles(root) {
 function listDeliveryFiles(root) {
   return walkFiles(path.join(ensureCoopInitialized(root), "deliveries"), /* @__PURE__ */ new Set([".yml", ".yaml", ".md"]));
 }
+function loadTasks(root) {
+  return listTaskFiles(root).map((filePath) => parseTaskFile(filePath).task);
+}
 function findTaskFileById(root, id) {
   const target = `${id}.md`.toLowerCase();
   const match = listTaskFiles(root).find((filePath) => path.basename(filePath).toLowerCase() === target);
@@ -234,8 +237,8 @@ function findTaskFileById(root, id) {
 function todayIsoDate() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
-function normalizeIdPart(input3, fallback, maxLength = 12) {
-  const normalized = input3.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").replace(/-/g, "");
+function normalizeIdPart(input2, fallback, maxLength = 12) {
+  const normalized = input2.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-").replace(/-/g, "");
   if (!normalized) return fallback;
   return normalized.slice(0, maxLength);
 }
@@ -271,24 +274,24 @@ function shortDateToken(now = /* @__PURE__ */ new Date()) {
 function randomToken() {
   return crypto.randomBytes(4).toString("hex").toUpperCase();
 }
-function sanitizeTemplateValue(input3, fallback = "X") {
-  const normalized = input3.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
+function sanitizeTemplateValue(input2, fallback = "X") {
+  const normalized = input2.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
   return normalized || fallback;
 }
-function sanitizeSemanticWord(input3) {
-  return input3.toUpperCase().replace(/[^A-Z0-9]+/g, "").trim();
+function sanitizeSemanticWord(input2) {
+  return input2.toUpperCase().replace(/[^A-Z0-9]+/g, "").trim();
 }
-function semanticWords(input3) {
-  const rawWords = input3.split(/[^a-zA-Z0-9]+/g).map(sanitizeSemanticWord).filter(Boolean);
+function semanticWords(input2) {
+  const rawWords = input2.split(/[^a-zA-Z0-9]+/g).map(sanitizeSemanticWord).filter(Boolean);
   if (rawWords.length <= 1) {
     return rawWords;
   }
   const filtered = rawWords.filter((word) => !SEMANTIC_STOP_WORDS.has(word));
   return filtered.length > 0 ? filtered : rawWords;
 }
-function semanticTitleToken(input3, maxLength = DEFAULT_TITLE_TOKEN_LENGTH) {
+function semanticTitleToken(input2, maxLength = DEFAULT_TITLE_TOKEN_LENGTH) {
   const safeMaxLength = Number.isFinite(maxLength) ? Math.max(4, Math.floor(maxLength)) : DEFAULT_TITLE_TOKEN_LENGTH;
-  const words = semanticWords(input3);
+  const words = semanticWords(input2);
   if (words.length === 0) {
     return "UNTITLED";
   }
@@ -449,27 +452,27 @@ function generateConfiguredId(root, existingIds, context) {
 
 // src/utils/aliases.ts
 var ALIAS_PATTERN = /^[A-Z0-9]+(?:[.-][A-Z0-9]+)*$/;
-function toPosixPath(input3) {
-  return input3.replace(/\\/g, "/");
+function toPosixPath(input2) {
+  return input2.replace(/\\/g, "/");
 }
 function indexFilePath(root) {
   const { indexDataFormat } = readCoopConfig(root);
   const extension = indexDataFormat === "json" ? "json" : "yml";
   return path2.join(ensureCoopInitialized(root), ".index", `aliases.${extension}`);
 }
-function normalizeAliasValue(input3) {
-  return input3.trim().toUpperCase().replace(/_/g, ".").replace(/\.+/g, ".");
+function normalizeAliasValue(input2) {
+  return input2.trim().toUpperCase().replace(/_/g, ".").replace(/\.+/g, ".");
 }
-function normalizePatternValue(input3) {
-  return input3.trim().toUpperCase().replace(/_/g, ".");
+function normalizePatternValue(input2) {
+  return input2.trim().toUpperCase().replace(/_/g, ".");
 }
-function normalizeAlias(input3) {
-  const normalized = normalizeAliasValue(input3);
+function normalizeAlias(input2) {
+  const normalized = normalizeAliasValue(input2);
   if (!normalized) {
     throw new Error("Alias cannot be empty.");
   }
   if (!ALIAS_PATTERN.test(normalized)) {
-    throw new Error(`Invalid alias '${input3}'. Use letters/numbers with '.' and '-'.`);
+    throw new Error(`Invalid alias '${input2}'. Use letters/numbers with '.' and '-'.`);
   }
   return normalized;
 }
@@ -656,8 +659,8 @@ function updateTaskAliases(filePath, aliases) {
 function updateIdeaAliases(filePath, aliases) {
   const parsed = parseIdeaFile(filePath);
   const nextRaw = { ...parsed.raw, aliases };
-  const output3 = stringifyFrontmatter(nextRaw, parsed.body);
-  fs2.writeFileSync(filePath, output3, "utf8");
+  const output2 = stringifyFrontmatter(nextRaw, parsed.body);
+  fs2.writeFileSync(filePath, output2, "utf8");
 }
 function resolveFilePath(root, target) {
   return path2.join(root, ...target.file.split("/"));
@@ -799,18 +802,18 @@ function registerAliasCommand(program) {
 }
 
 // src/utils/taskflow.ts
-import path3 from "path";
+import path5 from "path";
 import {
   TaskStatus,
   check_permission,
   load_auth_config,
   load_graph as load_graph2,
-  parseTaskFile as parseTaskFile4,
+  parseTaskFile as parseTaskFile5,
   run_plugins_for_event as run_plugins_for_event2,
   schedule_next,
   transition as transition2,
-  validateStructural as validateStructural2,
-  writeTask as writeTask3
+  validateStructural as validateStructural3,
+  writeTask as writeTask4
 } from "@kitsy/coop-core";
 
 // src/integrations/github.ts
@@ -829,8 +832,8 @@ import { Octokit } from "octokit";
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function sanitizeBranchPart(input3, fallback) {
-  const normalized = input3.trim().toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+function sanitizeBranchPart(input2, fallback) {
+  const normalized = input2.trim().toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || fallback;
 }
 function readGitRemote(root) {
@@ -990,15 +993,15 @@ function toGitHubClient(config) {
     baseUrl: config.apiBaseUrl
   });
   return {
-    async createPullRequest(input3) {
+    async createPullRequest(input2) {
       const response = await octokit.rest.pulls.create({
-        owner: input3.owner,
-        repo: input3.repo,
-        title: input3.title,
-        body: input3.body,
-        head: input3.head,
-        base: input3.base,
-        draft: input3.draft
+        owner: input2.owner,
+        repo: input2.repo,
+        title: input2.title,
+        body: input2.body,
+        head: input2.head,
+        base: input2.base,
+        draft: input2.draft
       });
       return {
         number: response.data.number,
@@ -1008,14 +1011,14 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async updatePullRequest(input3) {
+    async updatePullRequest(input2) {
       const response = await octokit.rest.pulls.update({
-        owner: input3.owner,
-        repo: input3.repo,
-        pull_number: input3.pull_number,
-        title: input3.title,
-        body: input3.body,
-        base: input3.base
+        owner: input2.owner,
+        repo: input2.repo,
+        pull_number: input2.pull_number,
+        title: input2.title,
+        body: input2.body,
+        base: input2.base
       });
       return {
         number: response.data.number,
@@ -1025,11 +1028,11 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async getPullRequest(input3) {
+    async getPullRequest(input2) {
       const response = await octokit.rest.pulls.get({
-        owner: input3.owner,
-        repo: input3.repo,
-        pull_number: input3.pull_number
+        owner: input2.owner,
+        repo: input2.repo,
+        pull_number: input2.pull_number
       });
       return {
         number: response.data.number,
@@ -1039,12 +1042,12 @@ function toGitHubClient(config) {
         draft: response.data.draft
       };
     },
-    async mergePullRequest(input3) {
+    async mergePullRequest(input2) {
       const response = await octokit.rest.pulls.merge({
-        owner: input3.owner,
-        repo: input3.repo,
-        pull_number: input3.pull_number,
-        merge_method: input3.merge_method
+        owner: input2.owner,
+        repo: input2.repo,
+        pull_number: input2.pull_number,
+        merge_method: input2.merge_method
       });
       return {
         merged: response.data.merged,
@@ -1383,16 +1386,238 @@ function createGitHubWebhookServer(root, options = {}) {
   return server;
 }
 
-// src/utils/taskflow.ts
-function configDefaultTrack(root) {
+// src/utils/work-items.ts
+import fs3 from "fs";
+import path3 from "path";
+import {
+  effective_priority,
+  parseDeliveryFile,
+  parseIdeaFile as parseIdeaFile2,
+  parseTaskFile as parseTaskFile4,
+  stringifyFrontmatter as stringifyFrontmatter2,
+  validateStructural as validateStructural2,
+  validateSemantic,
+  writeTask as writeTask3
+} from "@kitsy/coop-core";
+function resolveTaskFile(root, idOrAlias) {
+  const reference = resolveReference(root, idOrAlias, "task");
+  return path3.join(root, ...reference.file.split("/"));
+}
+function resolveIdeaFile(root, idOrAlias) {
+  const reference = resolveReference(root, idOrAlias, "idea");
+  return path3.join(root, ...reference.file.split("/"));
+}
+function loadTaskEntry(root, idOrAlias) {
+  const filePath = resolveTaskFile(root, idOrAlias);
+  return { filePath, parsed: parseTaskFile4(filePath) };
+}
+function loadIdeaEntry(root, idOrAlias) {
+  const filePath = resolveIdeaFile(root, idOrAlias);
+  return { filePath, parsed: parseIdeaFile2(filePath) };
+}
+function writeIdeaFile(filePath, parsed, idea, body = parsed.body) {
+  const output2 = stringifyFrontmatter2({ ...parsed.raw, ...idea }, body);
+  fs3.writeFileSync(filePath, output2, "utf8");
+}
+function validateTaskForWrite(task, filePath) {
+  const structuralIssues = validateStructural2(task, { filePath });
+  const semanticIssues = validateSemantic(task);
+  const errors = [...structuralIssues, ...semanticIssues].filter((issue) => issue.level === "error");
+  if (errors.length > 0) {
+    throw new Error(errors.map((issue) => `- ${issue.message}`).join("\n"));
+  }
+}
+function writeTaskEntry(filePath, parsed, task, body = parsed.body) {
+  validateTaskForWrite(task, filePath);
+  writeTask3(task, {
+    body,
+    raw: parsed.raw,
+    filePath
+  });
+}
+function appendTaskComment(task, author, body, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    ...task,
+    updated: todayIsoDate(),
+    comments: [...task.comments ?? [], { at, author, body }]
+  };
+}
+function appendTaskTimeLog(task, actor, kind, hours, note, at = (/* @__PURE__ */ new Date()).toISOString()) {
+  const current = task.time ?? {};
+  return {
+    ...task,
+    updated: todayIsoDate(),
+    time: {
+      ...current,
+      logs: [...current.logs ?? [], { at, actor, kind, hours, note }]
+    }
+  };
+}
+function setTaskPlannedHours(task, plannedHours) {
+  return {
+    ...task,
+    updated: todayIsoDate(),
+    time: {
+      ...task.time ?? {},
+      planned_hours: plannedHours
+    }
+  };
+}
+function promoteTaskForContext(task, context) {
+  const next = {
+    ...task,
+    updated: todayIsoDate(),
+    fix_versions: [...task.fix_versions ?? []],
+    delivery_tracks: [...task.delivery_tracks ?? []],
+    priority_context: { ...task.priority_context ?? {} }
+  };
+  const scopedTrack = context.track?.trim();
+  if (scopedTrack) {
+    if (task.track?.trim() !== scopedTrack && !next.delivery_tracks?.includes(scopedTrack)) {
+      next.delivery_tracks = [...next.delivery_tracks ?? [], scopedTrack];
+    }
+    next.priority_context = {
+      ...next.priority_context ?? {},
+      [scopedTrack]: "p0"
+    };
+  } else {
+    next.priority = "p0";
+  }
+  const version = context.version?.trim();
+  if (version && !next.fix_versions?.includes(version)) {
+    next.fix_versions = [...next.fix_versions ?? [], version];
+  }
+  return next;
+}
+function taskEffectivePriority(task, track) {
+  return effective_priority(task, track);
+}
+function resolveDeliveryEntry(root, ref) {
+  const files = listDeliveryFiles(root);
+  const target = ref.trim().toLowerCase();
+  const entries = files.map((filePath) => {
+    const parsed = parseDeliveryFile(filePath);
+    return { filePath, delivery: parsed.delivery, body: parsed.body };
+  });
+  const direct = entries.find((entry) => entry.delivery.id.toLowerCase() === target);
+  if (direct) return direct;
+  const byName = entries.filter((entry) => entry.delivery.name.toLowerCase() === target);
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    throw new Error(`Multiple deliveries match '${ref}'. Use the delivery id.`);
+  }
+  throw new Error(`Delivery '${ref}' not found.`);
+}
+function sharedDefault(root, key) {
   const config = readCoopConfig(root).raw;
   const defaults = typeof config.defaults === "object" && config.defaults !== null ? config.defaults : {};
-  return typeof defaults.track === "string" && defaults.track.trim() ? defaults.track.trim() : void 0;
+  const value = defaults[key];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+// src/utils/working-context.ts
+import crypto3 from "crypto";
+import fs4 from "fs";
+import path4 from "path";
+function stableKey(root, projectId) {
+  return crypto3.createHash("sha256").update(`${path4.resolve(root)}::${projectId}`).digest("hex").slice(0, 16);
+}
+function contextFilePath(root, coopHome) {
+  const identity = readCoopIdentity(root);
+  return path4.join(coopHome, "contexts", `${stableKey(root, identity.id)}.json`);
+}
+function readPersistedContext(root, coopHome) {
+  const filePath = contextFilePath(root, coopHome);
+  if (!fs4.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readWorkingContext(root, coopHome) {
+  return readPersistedContext(root, coopHome)?.values ?? {};
+}
+function writeWorkingContext(root, coopHome, values) {
+  const identity = readCoopIdentity(root);
+  const filePath = contextFilePath(root, coopHome);
+  fs4.mkdirSync(path4.dirname(filePath), { recursive: true });
+  const normalized = {
+    track: values.track?.trim() || void 0,
+    delivery: values.delivery?.trim() || void 0,
+    version: values.version?.trim() || void 0
+  };
+  const payload = {
+    repo_root: path4.resolve(root),
+    project_id: identity.id,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    values: normalized
+  };
+  fs4.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  return normalized;
+}
+function updateWorkingContext(root, coopHome, patch) {
+  return writeWorkingContext(root, coopHome, { ...readWorkingContext(root, coopHome), ...patch });
+}
+function clearWorkingContext(root, coopHome, scope) {
+  if (scope === "all") {
+    const filePath = contextFilePath(root, coopHome);
+    if (fs4.existsSync(filePath)) {
+      fs4.rmSync(filePath, { force: true });
+    }
+    return {};
+  }
+  const next = { ...readWorkingContext(root, coopHome) };
+  delete next[scope];
+  return writeWorkingContext(root, coopHome, next);
+}
+function resolveContextValueWithSource(explicit, contextValue2, sharedDefault2) {
+  if (explicit?.trim()) {
+    return { value: explicit.trim(), source: "arg" };
+  }
+  if (contextValue2?.trim()) {
+    return { value: contextValue2.trim(), source: "use" };
+  }
+  if (sharedDefault2?.trim()) {
+    return { value: sharedDefault2.trim(), source: "config" };
+  }
+  return {};
+}
+function isVerboseRequested() {
+  return process.argv.includes("--verbose");
+}
+function formatResolvedContextMessage(values) {
+  const lines = [];
+  for (const key of ["track", "delivery", "version"]) {
+    const entry = values[key];
+    if (!entry?.value || !entry.source || entry.source === "arg") {
+      continue;
+    }
+    lines.push(`[COOP][context] ${key}=${entry.value} (from ${entry.source === "use" ? "`coop use`" : "config defaults"})`);
+  }
+  return lines;
+}
+
+// src/utils/taskflow.ts
+function configDefaultTrack(root) {
+  return sharedDefault(root, "track");
+}
+function configDefaultDelivery(root) {
+  return sharedDefault(root, "delivery");
+}
+function configDefaultVersion(root) {
+  return sharedDefault(root, "version");
 }
 function resolveSelectionOptions(root, options) {
+  const context = readWorkingContext(root, resolveCoopHome());
   return {
     ...options,
-    track: options.track?.trim() || configDefaultTrack(root)
+    track: options.track?.trim() || context.track?.trim() || configDefaultTrack(root),
+    delivery: options.delivery?.trim() || context.delivery?.trim() || configDefaultDelivery(root),
+    version: options.version?.trim() || context.version?.trim() || configDefaultVersion(root)
   };
 }
 function selectTopReadyTask(root = resolveRepoRoot(), options = {}) {
@@ -1417,8 +1642,9 @@ function formatSelectedTask(entry, selection = {}) {
   const lines = [
     `Selected task: ${entry.task.id}`,
     `Title: ${entry.task.title}`,
-    `Priority: ${entry.task.priority ?? "-"}`,
+    `Priority: ${selection.track && entry.task.priority_context?.[selection.track] ? `${entry.task.priority ?? "-"} -> ${entry.task.priority_context[selection.track]}` : entry.task.priority ?? "-"}`,
     `Track: ${entry.task.track ?? "-"}`,
+    `Delivery Tracks: ${entry.task.delivery_tracks && entry.task.delivery_tracks.length > 0 ? entry.task.delivery_tracks.join(", ") : "-"}`,
     `Score: ${entry.score.toFixed(1)}`,
     `Capacity fit: ${entry.fits_capacity ? "yes" : "no"}`,
     `WIP fit: ${entry.fits_wip ? "yes" : "no"}`
@@ -1507,8 +1733,8 @@ async function assignTaskByReference(root, id, options) {
       `Assignee '${assignee}' is not in resource profiles for track '${existing.track ?? "unassigned"}'. Known: ${known.join(", ")}.`
     );
   }
-  const filePath = path3.join(root, ...reference.file.split("/"));
-  const parsed = parseTaskFile4(filePath);
+  const filePath = path5.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile5(filePath);
   const from = parsed.task.assignee ?? null;
   const actor = options.actor?.trim() || user;
   if (from === assignee) {
@@ -1519,13 +1745,13 @@ async function assignTaskByReference(root, id, options) {
     assignee,
     updated: todayIsoDate()
   };
-  const structuralIssues = validateStructural2(nextTask, { filePath });
+  const structuralIssues = validateStructural3(nextTask, { filePath });
   if (structuralIssues.length > 0) {
     const errors = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
     throw new Error(`Updated task is structurally invalid:
 ${errors}`);
   }
-  writeTask3(nextTask, {
+  writeTask4(nextTask, {
     body: parsed.body,
     raw: parsed.raw,
     filePath
@@ -1582,8 +1808,8 @@ async function transitionTaskByReference(root, id, status, options) {
     }
     console.warn(`[COOP][auth] override: user '${user}' forced transition_task on '${reference.id}'.`);
   }
-  const filePath = path3.join(root, ...reference.file.split("/"));
-  const parsed = parseTaskFile4(filePath);
+  const filePath = path5.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile5(filePath);
   const result = transition2(parsed.task, target, {
     actor: options.actor ?? user,
     dependencyStatuses: dependencyStatusMapForTask(reference.id, graph)
@@ -1591,13 +1817,13 @@ async function transitionTaskByReference(root, id, status, options) {
   if (!result.success) {
     throw new Error(result.error ?? "Transition failed.");
   }
-  const structuralIssues = validateStructural2(result.task, { filePath });
+  const structuralIssues = validateStructural3(result.task, { filePath });
   if (structuralIssues.length > 0) {
     const errors = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
     throw new Error(`Updated task is structurally invalid:
 ${errors}`);
   }
-  writeTask3(result.task, {
+  writeTask4(result.task, {
     body: parsed.body,
     raw: parsed.raw,
     filePath
@@ -1640,6 +1866,30 @@ function registerAssignCommand(program) {
   });
 }
 
+// src/utils/command-args.ts
+function resolveOptionalEntityArg(first, second, allowed, fallback) {
+  const normalizedFirst = first.trim().toLowerCase();
+  if (allowed.includes(normalizedFirst) && second?.trim()) {
+    return { entity: normalizedFirst, id: second.trim() };
+  }
+  return { entity: fallback, id: first.trim() };
+}
+
+// src/commands/comment.ts
+function registerCommentCommand(program) {
+  program.command("comment").description("Append a comment to a COOP task").argument("<id-or-type>", "Task id/alias, or the literal `task` followed by an id").argument("[id]", "Task id when an explicit entity type is provided").requiredOption("--message <text>", "Comment text").option("--author <id>", "Comment author").action((first, second, options) => {
+    const { entity, id } = resolveOptionalEntityArg(first, second, ["task"], "task");
+    if (entity !== "task") {
+      throw new Error("Only task comments are supported.");
+    }
+    const root = resolveRepoRoot();
+    const { filePath, parsed } = loadTaskEntry(root, id);
+    const task = appendTaskComment(parsed.task, options.author?.trim() || defaultCoopAuthor(root), options.message.trim());
+    writeTaskEntry(filePath, parsed, task);
+    console.log(`Commented ${task.id}`);
+  });
+}
+
 // src/commands/config.ts
 var INDEX_DATA_KEY = "index.data";
 var ID_NAMING_KEY = "id.naming";
@@ -1874,29 +2124,30 @@ function registerConfigCommand(program) {
 }
 
 // src/commands/create.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path8 from "path";
 import {
   DeliveryStatus,
   IdeaStatus as IdeaStatus2,
-  parseIdeaFile as parseIdeaFile2,
+  parseIdeaFile as parseIdeaFile3,
   TaskStatus as TaskStatus3,
   TaskType as TaskType2,
   check_permission as check_permission2,
   load_auth_config as load_auth_config2,
-  parseTaskFile as parseTaskFile6,
+  parseTaskFile as parseTaskFile7,
   writeYamlFile as writeYamlFile3,
-  stringifyFrontmatter as stringifyFrontmatter3,
-  validateStructural as validateStructural4,
-  writeTask as writeTask5
+  stringifyFrontmatter as stringifyFrontmatter4,
+  validateStructural as validateStructural5,
+  writeTask as writeTask6
 } from "@kitsy/coop-core";
 import { create_provider_idea_decomposer, decompose_idea_to_tasks } from "@kitsy/coop-ai";
 
 // src/utils/prompt.ts
-import readline from "readline/promises";
+import readline from "readline";
+import readlinePromises from "readline/promises";
 import process2 from "process";
 async function ask(question, defaultValue = "") {
-  const rl = readline.createInterface({
+  const rl = readlinePromises.createInterface({
     input: process2.stdin,
     output: process2.stdout
   });
@@ -1905,15 +2156,80 @@ async function ask(question, defaultValue = "") {
   rl.close();
   return answer || defaultValue;
 }
+function renderSelect(question, choices, selected) {
+  process2.stdout.write(`${question}
+`);
+  for (let index = 0; index < choices.length; index += 1) {
+    const choice = choices[index];
+    const prefix = index === selected ? ">" : " ";
+    const hint = choice.hint ? ` - ${choice.hint}` : "";
+    process2.stdout.write(` ${prefix} ${choice.label}${hint}
+`);
+  }
+  process2.stdout.write("\nUse \u2191/\u2193 to choose, Enter to confirm.\n");
+}
+function moveCursorUp(lines) {
+  if (lines <= 0) return;
+  readline.moveCursor(process2.stdout, 0, -lines);
+  readline.clearScreenDown(process2.stdout);
+}
+async function select(question, choices, defaultIndex = 0) {
+  if (choices.length === 0) {
+    throw new Error(`No choices available for '${question}'.`);
+  }
+  if (!process2.stdin.isTTY || !process2.stdout.isTTY) {
+    return choices[Math.min(Math.max(defaultIndex, 0), choices.length - 1)].value;
+  }
+  readline.emitKeypressEvents(process2.stdin);
+  const previousRawMode = process2.stdin.isRaw;
+  process2.stdin.setRawMode(true);
+  let selected = Math.min(Math.max(defaultIndex, 0), choices.length - 1);
+  const renderedLines = choices.length + 2;
+  renderSelect(question, choices, selected);
+  return await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      process2.stdin.off("keypress", onKeypress);
+      process2.stdin.setRawMode(previousRawMode ?? false);
+      process2.stdout.write("\n");
+    };
+    const rerender = () => {
+      moveCursorUp(renderedLines + 1);
+      renderSelect(question, choices, selected);
+    };
+    const onKeypress = (_input, key) => {
+      if (key.name === "up") {
+        selected = selected === 0 ? choices.length - 1 : selected - 1;
+        rerender();
+        return;
+      }
+      if (key.name === "down") {
+        selected = selected === choices.length - 1 ? 0 : selected + 1;
+        rerender();
+        return;
+      }
+      if (key.name === "return") {
+        const value = choices[selected].value;
+        cleanup();
+        resolve(value);
+        return;
+      }
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Prompt cancelled."));
+      }
+    };
+    process2.stdin.on("keypress", onKeypress);
+  });
+}
 
 // src/utils/idea-drafts.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import {
   IdeaStatus,
   parseFrontmatterContent,
   parseYamlContent,
-  stringifyFrontmatter as stringifyFrontmatter2
+  stringifyFrontmatter as stringifyFrontmatter3
 } from "@kitsy/coop-core";
 function asUniqueStrings(value) {
   if (!Array.isArray(value)) return void 0;
@@ -1957,7 +2273,7 @@ function parseIdeaDraftInput(content, source) {
   return parseIdeaDraftObject(parseYamlContent(content, source), source);
 }
 function writeIdeaFromDraft(root, projectDir, draft) {
-  const existingIds = listIdeaFiles(root).map((filePath2) => path4.basename(filePath2, ".md"));
+  const existingIds = listIdeaFiles(root).map((filePath2) => path6.basename(filePath2, ".md"));
   const id = draft.id?.trim()?.toUpperCase() || generateConfiguredId(root, existingIds, {
     entityType: "idea",
     title: draft.title,
@@ -1978,25 +2294,25 @@ function writeIdeaFromDraft(root, projectDir, draft) {
     source: draft.source ?? "manual",
     linked_tasks: draft.linked_tasks ?? []
   };
-  const filePath = path4.join(projectDir, "ideas", `${id}.md`);
-  if (fs3.existsSync(filePath)) {
+  const filePath = path6.join(projectDir, "ideas", `${id}.md`);
+  if (fs5.existsSync(filePath)) {
     throw new Error(`Idea '${id}' already exists.`);
   }
-  fs3.writeFileSync(filePath, stringifyFrontmatter2(frontmatter, draft.body ?? ""), "utf8");
+  fs5.writeFileSync(filePath, stringifyFrontmatter3(frontmatter, draft.body ?? ""), "utf8");
   return filePath;
 }
 
 // src/utils/refinement-drafts.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path7 from "path";
 import {
   IndexManager,
   parseFrontmatterContent as parseFrontmatterContent2,
-  parseTaskFile as parseTaskFile5,
+  parseTaskFile as parseTaskFile6,
   parseYamlContent as parseYamlContent2,
   stringifyYamlContent,
-  validateStructural as validateStructural3,
-  writeTask as writeTask4
+  validateStructural as validateStructural4,
+  writeTask as writeTask5
 } from "@kitsy/coop-core";
 
 // src/utils/stdin.ts
@@ -2023,16 +2339,16 @@ function nonEmptyStrings(value) {
   return entries.length > 0 ? entries : void 0;
 }
 function refinementDir(projectDir) {
-  const dir = path5.join(projectDir, "tmp", "refinements");
-  fs4.mkdirSync(dir, { recursive: true });
+  const dir = path7.join(projectDir, "tmp", "refinements");
+  fs6.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function draftPath(projectDir, mode, sourceId) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return path5.join(refinementDir(projectDir), `${mode}-${sourceId}-${stamp}.yml`);
+  return path7.join(refinementDir(projectDir), `${mode}-${sourceId}-${stamp}.yml`);
 }
 function assignCreateProposalIds(root, draft) {
-  const existingIds = listTaskFiles(root).map((filePath) => path5.basename(filePath, ".md"));
+  const existingIds = listTaskFiles(root).map((filePath) => path7.basename(filePath, ".md"));
   const createdIds = [];
   const proposals = draft.proposals.map((proposal) => {
     if (proposal.action !== "create") {
@@ -2061,13 +2377,13 @@ function assignCreateProposalIds(root, draft) {
   };
 }
 function writeDraftFile(root, projectDir, draft, outputFile) {
-  const filePath = outputFile?.trim() ? path5.resolve(root, outputFile.trim()) : draftPath(projectDir, draft.mode, draft.source.id);
-  fs4.mkdirSync(path5.dirname(filePath), { recursive: true });
-  fs4.writeFileSync(filePath, stringifyYamlContent(draft), "utf8");
+  const filePath = outputFile?.trim() ? path7.resolve(root, outputFile.trim()) : draftPath(projectDir, draft.mode, draft.source.id);
+  fs6.mkdirSync(path7.dirname(filePath), { recursive: true });
+  fs6.writeFileSync(filePath, stringifyYamlContent(draft), "utf8");
   return filePath;
 }
 function printDraftSummary(root, draft, filePath) {
-  console.log(`[COOP] refinement draft created: ${path5.relative(root, filePath)}`);
+  console.log(`[COOP] refinement draft created: ${path7.relative(root, filePath)}`);
   console.log(`[COOP] source: ${draft.source.entity_type} ${draft.source.id}`);
   console.log(`[COOP] summary: ${draft.summary}`);
   for (const proposal of draft.proposals) {
@@ -2076,7 +2392,7 @@ function printDraftSummary(root, draft, filePath) {
       `- ${proposal.action.toUpperCase()} ${target ?? "(pending-id)"} | ${proposal.title} | ${proposal.type ?? "feature"} | ${proposal.priority ?? "p2"}`
     );
   }
-  console.log(`[COOP] apply with: coop apply draft --from-file ${path5.relative(root, filePath)}`);
+  console.log(`[COOP] apply with: coop apply draft --from-file ${path7.relative(root, filePath)}`);
 }
 function parseRefinementDraftInput(content, source) {
   const parsed = parseYamlContent2(content, source);
@@ -2160,16 +2476,16 @@ function applyCreateProposal(projectDir, proposal) {
   if (!id) {
     throw new Error(`Create proposal '${proposal.title}' is missing id.`);
   }
-  const filePath = path5.join(projectDir, "tasks", `${id}.md`);
-  if (fs4.existsSync(filePath)) {
+  const filePath = path7.join(projectDir, "tasks", `${id}.md`);
+  if (fs6.existsSync(filePath)) {
     throw new Error(`Task '${id}' already exists.`);
   }
   const task = taskFromProposal({ ...proposal, id }, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
-  const issues = validateStructural3(task, { filePath });
+  const issues = validateStructural4(task, { filePath });
   if (issues.length > 0) {
     throw new Error(issues.map((issue) => issue.message).join(" | "));
   }
-  writeTask4(task, { body: proposal.body ?? "", filePath });
+  writeTask5(task, { body: proposal.body ?? "", filePath });
   return filePath;
 }
 function applyUpdateProposal(root, proposal) {
@@ -2178,7 +2494,7 @@ function applyUpdateProposal(root, proposal) {
     throw new Error(`Update proposal '${proposal.title}' is missing target_id.`);
   }
   const filePath = findTaskFileById(root, targetId);
-  const parsed = parseTaskFile5(filePath);
+  const parsed = parseTaskFile6(filePath);
   const nextTask = {
     ...parsed.task,
     title: proposal.title || parsed.task.title,
@@ -2196,11 +2512,11 @@ function applyUpdateProposal(root, proposal) {
       derived_refs: proposal.derived_refs ?? parsed.task.origin?.derived_refs
     } : parsed.task.origin
   };
-  const issues = validateStructural3(nextTask, { filePath });
+  const issues = validateStructural4(nextTask, { filePath });
   if (issues.length > 0) {
     throw new Error(issues.map((issue) => issue.message).join(" | "));
   }
-  writeTask4(nextTask, {
+  writeTask5(nextTask, {
     body: proposal.body ?? parsed.body,
     raw: parsed.raw,
     filePath
@@ -2222,8 +2538,8 @@ function applyRefinementDraft(root, projectDir, draft) {
 }
 async function readDraftContent(root, options) {
   if (options.fromFile?.trim()) {
-    const filePath = path5.resolve(root, options.fromFile.trim());
-    return { content: fs4.readFileSync(filePath, "utf8"), source: filePath };
+    const filePath = path7.resolve(root, options.fromFile.trim());
+    return { content: fs6.readFileSync(filePath, "utf8"), source: filePath };
   }
   if (options.stdin) {
     return { content: await readStdinText(), source: "<stdin>" };
@@ -2318,9 +2634,9 @@ function plusDaysIso(days) {
 function unique(values) {
   return Array.from(new Set(values));
 }
-function resolveIdeaFile(root, idOrAlias) {
+function resolveIdeaFile2(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "idea");
-  return path6.join(root, ...target.file.split("/"));
+  return path8.join(root, ...target.file.split("/"));
 }
 function updateIdeaLinkedTasks(filePath, idea, raw, body, linked) {
   const next = unique([...idea.linked_tasks ?? [], ...linked]).sort((a, b) => a.localeCompare(b));
@@ -2328,30 +2644,30 @@ function updateIdeaLinkedTasks(filePath, idea, raw, body, linked) {
     ...raw,
     linked_tasks: next
   };
-  fs5.writeFileSync(filePath, stringifyFrontmatter3(nextRaw, body), "utf8");
+  fs7.writeFileSync(filePath, stringifyFrontmatter4(nextRaw, body), "utf8");
 }
-function makeTaskDraft(input3) {
+function makeTaskDraft(input2) {
   return {
-    title: input3.title,
-    type: input3.type,
-    status: input3.status,
-    track: input3.track,
-    priority: input3.priority,
-    body: input3.body,
-    acceptance: unique(input3.acceptance ?? []),
-    testsRequired: unique(input3.testsRequired ?? []),
-    authorityRefs: unique(input3.authorityRefs ?? []),
-    derivedRefs: unique(input3.derivedRefs ?? [])
+    title: input2.title,
+    type: input2.type,
+    status: input2.status,
+    track: input2.track,
+    priority: input2.priority,
+    body: input2.body,
+    acceptance: unique(input2.acceptance ?? []),
+    testsRequired: unique(input2.testsRequired ?? []),
+    authorityRefs: unique(input2.authorityRefs ?? []),
+    derivedRefs: unique(input2.derivedRefs ?? [])
   };
 }
 function registerCreateCommand(program) {
   const create = program.command("create").description("Create COOP entities");
-  create.command("task").description("Create a task").argument("[title]", "Task title").option("--id <id>", "Task id").option("--from <idea>", "Create task(s) from an idea id/alias").option("--ai", "Use AI-assisted decomposition for --from").option("--title <title>", "Task title").option("--type <type>", `Task type (${Object.values(TaskType2).join(", ")})`).option("--status <status>", `Task status (${Object.values(TaskStatus3).join(", ")})`).option("--track <track>", "Track id").option("--priority <priority>", "Task priority").option("--body <body>", "Markdown body").option("--acceptance <items>", "Comma-separated acceptance criteria", collectMultiValue, []).option("--tests-required <items>", "Comma-separated required tests", collectMultiValue, []).option("--authority-ref <ref>", "Authority document reference", collectMultiValue, []).option("--derived-ref <ref>", "Derived planning document reference", collectMultiValue, []).option("--from-file <path>", "Create task(s) from task draft/refinement draft file").option("--stdin", "Read task draft/refinement draft from stdin").option("--interactive", "Prompt for optional fields").action(async (titleArg, options) => {
+  create.command("task").description("Create a task").argument("[title]", "Task title").option("--id <id>", "Task id").option("--from <idea>", "Create task(s) from an idea id/alias").option("--ai", "Use AI-assisted decomposition for --from").option("--title <title>", "Task title").option("--type <type>", `Task type (${Object.values(TaskType2).join(", ")})`).option("--status <status>", `Task status (${Object.values(TaskStatus3).join(", ")})`).option("--track <track>", "Home/origin track id").option("--delivery <delivery>", "Primary delivery id").option("--priority <priority>", "Task priority").option("--body <body>", "Markdown body").option("--acceptance <items>", "Comma-separated acceptance criteria", collectMultiValue, []).option("--tests-required <items>", "Comma-separated required tests", collectMultiValue, []).option("--authority-ref <ref>", "Authority document reference", collectMultiValue, []).option("--derived-ref <ref>", "Derived planning document reference", collectMultiValue, []).option("--from-file <path>", "Create task(s) from task draft/refinement draft file").option("--stdin", "Read task draft/refinement draft from stdin").option("--interactive", "Prompt for optional fields").action(async (titleArg, options) => {
     const root = resolveRepoRoot();
     const coop = ensureCoopInitialized(root);
     const interactive = Boolean(options.interactive);
     if (options.fromFile?.trim() || options.stdin) {
-      if (options.id || options.from || options.ai || options.title || titleArg || options.type || options.status || options.track || options.priority || options.body || (options.acceptance?.length ?? 0) > 0 || (options.testsRequired?.length ?? 0) > 0 || (options.authorityRef?.length ?? 0) > 0 || (options.derivedRef?.length ?? 0) > 0) {
+      if (options.id || options.from || options.ai || options.title || titleArg || options.type || options.status || options.track || options.delivery || options.priority || options.body || (options.acceptance?.length ?? 0) > 0 || (options.testsRequired?.length ?? 0) > 0 || (options.authorityRef?.length ?? 0) > 0 || (options.derivedRef?.length ?? 0) > 0) {
         throw new Error("Cannot combine --from-file/--stdin with direct task field flags. Use one input mode.");
       }
       const draftInput = await readDraftContent(root, {
@@ -2365,7 +2681,7 @@ function registerCreateCommand(program) {
       const written = applyRefinementDraft(root, coop, parsedDraft);
       console.log(`[COOP] created ${written.length} task file(s) from ${draftInput.source}`);
       for (const filePath of written) {
-        console.log(`Created task: ${path6.relative(root, filePath)}`);
+        console.log(`Created task: ${path8.relative(root, filePath)}`);
       }
       return;
     }
@@ -2373,6 +2689,7 @@ function registerCreateCommand(program) {
     const statusInput = (options.status?.trim() || (interactive ? await ask("Task status", "todo") : "todo")).toLowerCase();
     const track = options.track?.trim() || (interactive ? await ask("Track", "unassigned") : "unassigned");
     const priority = options.priority?.trim() || (interactive ? await ask("Priority", "p2") : "p2");
+    const delivery = options.delivery?.trim() || (interactive ? await ask("Delivery (optional)", "") : "");
     const body = options.body ?? (interactive ? await ask("Task body (optional)", "") : "");
     const acceptance = options.acceptance && options.acceptance.length > 0 ? unique(options.acceptance) : interactive ? parseCsv(await ask("Acceptance criteria (comma-separated, optional)", "")) : [];
     const testsRequired = options.testsRequired && options.testsRequired.length > 0 ? unique(options.testsRequired) : interactive ? parseCsv(await ask("Tests required (comma-separated, optional)", "")) : [];
@@ -2383,8 +2700,8 @@ function registerCreateCommand(program) {
     let sourceIdeaPath = null;
     let sourceIdeaParsed = null;
     if (options.from?.trim()) {
-      sourceIdeaPath = resolveIdeaFile(root, options.from.trim());
-      sourceIdeaParsed = parseIdeaFile2(sourceIdeaPath);
+      sourceIdeaPath = resolveIdeaFile2(root, options.from.trim());
+      sourceIdeaParsed = parseIdeaFile3(sourceIdeaPath);
       if (options.ai) {
         const providerDecomposer = create_provider_idea_decomposer(readCoopConfig(root).raw);
         const aiDrafts = await decompose_idea_to_tasks({
@@ -2456,7 +2773,7 @@ function registerCreateCommand(program) {
     if (options.id && drafts.length > 1) {
       throw new Error("Cannot combine --id with multi-task creation. Remove --id or disable --ai decomposition.");
     }
-    const existingIds = listTaskFiles(root).map((filePath) => path6.basename(filePath, ".md"));
+    const existingIds = listTaskFiles(root).map((filePath) => path8.basename(filePath, ".md"));
     const createdIds = [];
     for (let index = 0; index < drafts.length; index += 1) {
       const draft = drafts[index];
@@ -2483,6 +2800,7 @@ function registerCreateCommand(program) {
         aliases: [],
         track: draft.track,
         priority: draft.priority,
+        delivery: delivery || void 0,
         acceptance: draft.acceptance,
         tests_required: draft.testsRequired,
         origin: draft.authorityRefs.length > 0 || draft.derivedRefs.length > 0 || options.from?.trim() ? {
@@ -2491,19 +2809,19 @@ function registerCreateCommand(program) {
           promoted_from: options.from?.trim() ? [sourceIdeaParsed?.idea.id ?? options.from.trim()] : void 0
         } : void 0
       };
-      const filePath = path6.join(coop, "tasks", `${id}.md`);
-      const structuralIssues = validateStructural4(task, { filePath });
+      const filePath = path8.join(coop, "tasks", `${id}.md`);
+      const structuralIssues = validateStructural5(task, { filePath });
       if (structuralIssues.length > 0) {
         const message = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
         throw new Error(`Task failed structural validation:
 ${message}`);
       }
-      writeTask5(task, {
+      writeTask6(task, {
         body: draft.body,
         filePath
       });
       createdIds.push(id);
-      console.log(`Created task: ${path6.relative(root, filePath)}`);
+      console.log(`Created task: ${path8.relative(root, filePath)}`);
     }
     if (sourceIdeaPath && sourceIdeaParsed && createdIds.length > 0) {
       updateIdeaLinkedTasks(
@@ -2530,7 +2848,7 @@ ${message}`);
       });
       const written = writeIdeaFromDraft(root, coop, parseIdeaDraftInput(draftInput.content, draftInput.source));
       console.log(`[COOP] created 1 idea file from ${draftInput.source}`);
-      console.log(`Created idea: ${path6.relative(root, written)}`);
+      console.log(`Created idea: ${path8.relative(root, written)}`);
       return;
     }
     const title = options.title?.trim() || titleArg?.trim() || await ask("Idea title");
@@ -2540,7 +2858,7 @@ ${message}`);
     const status = (options.status?.trim() || (interactive ? await ask("Idea status", "captured") : "captured")).toLowerCase();
     const tags = options.tags ? parseCsv(options.tags) : interactive ? parseCsv(await ask("Tags (comma-separated)", "")) : [];
     const body = options.body ?? (interactive ? await ask("Idea body (optional)", "") : "");
-    const existingIds = listIdeaFiles(root).map((filePath2) => path6.basename(filePath2, ".md"));
+    const existingIds = listIdeaFiles(root).map((filePath2) => path8.basename(filePath2, ".md"));
     const id = options.id?.trim()?.toUpperCase() || generateConfiguredId(root, existingIds, {
       entityType: "idea",
       title,
@@ -2564,9 +2882,9 @@ ${message}`);
     if (!Object.values(IdeaStatus2).includes(status)) {
       throw new Error(`Invalid idea status '${status}'.`);
     }
-    const filePath = path6.join(coop, "ideas", `${id}.md`);
-    fs5.writeFileSync(filePath, stringifyFrontmatter3(frontmatter, body), "utf8");
-    console.log(`Created idea: ${path6.relative(root, filePath)}`);
+    const filePath = path8.join(coop, "ideas", `${id}.md`);
+    fs7.writeFileSync(filePath, stringifyFrontmatter4(frontmatter, body), "utf8");
+    console.log(`Created idea: ${path8.relative(root, filePath)}`);
   });
   create.command("track").description("Create a track").argument("[name]", "Track name").option("--id <id>", "Track id").option("--name <name>", "Track name").option("--profiles <profiles>", "Comma-separated capacity profile ids").option("--max-wip <number>", "Max concurrent tasks").option("--allowed-types <types>", "Comma-separated allowed task types").option("--interactive", "Prompt for optional fields").action(async (nameArg, options) => {
     const root = resolveRepoRoot();
@@ -2592,7 +2910,7 @@ ${message}`);
         throw new Error(`Invalid task type in allowed-types: '${type}'.`);
       }
     }
-    const existingIds = listTrackFiles(root).map((filePath2) => path6.basename(filePath2).replace(/\.(yml|yaml)$/i, ""));
+    const existingIds = listTrackFiles(root).map((filePath2) => path8.basename(filePath2).replace(/\.(yml|yaml)$/i, ""));
     const config = readCoopConfig(root);
     const idPrefixesRaw = typeof config.raw.id_prefixes === "object" && config.raw.id_prefixes !== null ? config.raw.id_prefixes : {};
     const prefix = typeof idPrefixesRaw.track === "string" ? idPrefixesRaw.track : "TRK";
@@ -2613,9 +2931,9 @@ ${message}`);
         allowed_types: allowed
       }
     };
-    const filePath = path6.join(coop, "tracks", `${id}.yml`);
+    const filePath = path8.join(coop, "tracks", `${id}.yml`);
     writeYamlFile3(filePath, payload);
-    console.log(`Created track: ${path6.relative(root, filePath)}`);
+    console.log(`Created track: ${path8.relative(root, filePath)}`);
   });
   create.command("delivery").description("Create a delivery").argument("[name]", "Delivery name").option("--id <id>", "Delivery id").option("--name <name>", "Delivery name").option("--status <status>", `Delivery status (${Object.values(DeliveryStatus).join(", ")})`).option("--commit", "Create delivery directly in committed state").option("--target-date <date>", "Target date (YYYY-MM-DD)").option("--budget-hours <hours>", "Engineering budget hours").option("--budget-cost <usd>", "Cost budget in USD").option("--profiles <profiles>", "Comma-separated capacity profile ids").option("--scope <ids>", "Comma-separated task ids to include in scope").option("--exclude <ids>", "Comma-separated task ids to exclude from scope").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").option("--interactive", "Prompt for optional fields").action(async (nameArg, options) => {
     const root = resolveRepoRoot();
@@ -2668,7 +2986,7 @@ ${message}`);
       options.profiles ? parseCsv(options.profiles) : interactive ? parseCsv(await ask("Capacity profiles (comma-separated)", "backend_team")) : ["backend_team"]
     );
     const tasks = listTaskFiles(root).map((filePath2) => {
-      const parsed = parseTaskFile6(filePath2).task;
+      const parsed = parseTaskFile7(filePath2).task;
       return { id: parsed.id, title: parsed.title };
     });
     if (interactive && tasks.length > 0) {
@@ -2697,7 +3015,7 @@ ${message}`);
       }
     }
     const existingIds = listDeliveryFiles(root).map(
-      (filePath2) => path6.basename(filePath2).replace(/\.(yml|yaml|md)$/i, "")
+      (filePath2) => path8.basename(filePath2).replace(/\.(yml|yaml|md)$/i, "")
     );
     const idPrefixesRaw = typeof config.raw.id_prefixes === "object" && config.raw.id_prefixes !== null ? config.raw.id_prefixes : {};
     const prefix = typeof idPrefixesRaw.delivery === "string" ? idPrefixesRaw.delivery : "DEL";
@@ -2726,9 +3044,113 @@ ${message}`);
         exclude: scopeExclude
       }
     };
-    const filePath = path6.join(coop, "deliveries", `${id}.yml`);
+    const filePath = path8.join(coop, "deliveries", `${id}.yml`);
     writeYamlFile3(filePath, payload);
-    console.log(`Created delivery: ${path6.relative(root, filePath)}`);
+    console.log(`Created delivery: ${path8.relative(root, filePath)}`);
+  });
+}
+
+// src/commands/current.ts
+function contextValue(value) {
+  return value?.trim() || "unset";
+}
+function selectionScope(context) {
+  if (context.delivery?.trim()) {
+    return `delivery '${context.delivery.trim()}'`;
+  }
+  if (context.track?.trim()) {
+    return `track '${context.track.trim()}'`;
+  }
+  return "workspace-wide (no working track or delivery set)";
+}
+function selectionReason(context, score) {
+  if (context.delivery?.trim()) {
+    return `top ready task for delivery '${context.delivery.trim()}' with score ${score.toFixed(1)}`;
+  }
+  if (context.track?.trim()) {
+    return `top ready task for track '${context.track.trim()}' with score ${score.toFixed(1)}`;
+  }
+  return `top ready task across the workspace with score ${score.toFixed(1)}`;
+}
+function registerCurrentCommand(program) {
+  program.command("current").description("Show active project, working context, my in-progress tasks, and the next ready task").action(() => {
+    const root = resolveRepoRoot();
+    const identity = readCoopIdentity(root);
+    const context = readWorkingContext(root, resolveCoopHome());
+    const actor = defaultCoopAuthor(root);
+    const inProgress = loadTasks(root).filter(
+      (task) => task.assignee === actor && (task.status === "in_progress" || task.status === "in_review")
+    );
+    console.log(`Project: ${identity.name} (${identity.id})`);
+    console.log(`Actor: ${actor}`);
+    console.log("");
+    console.log("Working Context:");
+    console.log(`- Track: ${contextValue(context.track)}`);
+    console.log(`- Delivery: ${contextValue(context.delivery)}`);
+    console.log(`- Version: ${contextValue(context.version)}`);
+    if (!context.track?.trim() && !context.delivery?.trim()) {
+      console.log("- Hint: use `coop use track <id>` and/or `coop use delivery <id>` to set your working context.");
+    }
+    console.log("");
+    console.log("My Active Tasks:");
+    if (inProgress.length === 0) {
+      console.log("- none");
+    } else {
+      for (const task of inProgress) {
+        console.log(`- ${task.id} [${task.status}] ${task.title}`);
+      }
+    }
+    console.log("");
+    console.log("Next Ready:");
+    try {
+      const selected = selectTopReadyTask(root, {
+        track: context.track,
+        delivery: context.delivery,
+        version: context.version
+      });
+      console.log(`Selection scope: ${selectionScope(context)}`);
+      console.log(`Why selected: ${selectionReason(context, selected.entry.score)}`);
+      if ((selected.entry.task.track ?? "").trim().toLowerCase() === "unassigned") {
+        console.log("Warning: selected task has no assigned track.");
+      }
+      console.log(formatSelectedTask(selected.entry, selected.selection));
+    } catch (error) {
+      console.log(error instanceof Error ? error.message : String(error));
+    }
+  });
+}
+
+// src/commands/deps.ts
+import { load_graph as load_graph3 } from "@kitsy/coop-core";
+function registerDepsCommand(program) {
+  program.command("deps").description("Show dependencies and reverse dependencies for a task, including status and title").argument("<id>", "Task id or alias").action((id) => {
+    const root = resolveRepoRoot();
+    const graph = load_graph3(coopDir(root));
+    const reference = resolveReference(root, id, "task");
+    const task = graph.nodes.get(reference.id);
+    if (!task) {
+      throw new Error(`Task '${reference.id}' not found.`);
+    }
+    const reverse = Array.from(graph.reverse.get(task.id) ?? []).sort((a, b) => a.localeCompare(b));
+    console.log(`Task: ${task.id} [${task.status}] ${task.title}`);
+    console.log("Depends On:");
+    if (!task.depends_on || task.depends_on.length === 0) {
+      console.log("- none");
+    } else {
+      for (const depId of task.depends_on) {
+        const dep = graph.nodes.get(depId);
+        console.log(`- ${depId}${dep ? ` [${dep.status}] ${dep.title}` : " [missing]"}`);
+      }
+    }
+    console.log("Required By:");
+    if (reverse.length === 0) {
+      console.log("- none");
+    } else {
+      for (const dependentId of reverse) {
+        const dependent = graph.nodes.get(dependentId);
+        console.log(`- ${dependentId}${dependent ? ` [${dependent.status}] ${dependent.title}` : " [missing]"}`);
+      }
+    }
   });
 }
 
@@ -2737,7 +3159,8 @@ import chalk from "chalk";
 import {
   compute_critical_path,
   compute_readiness_with_corrections,
-  load_graph as load_graph3,
+  effective_priority as effective_priority2,
+  load_graph as load_graph4,
   schedule_next as schedule_next2,
   topological_sort,
   validate_graph
@@ -2747,10 +3170,10 @@ import {
 function normalize(value) {
   return value.trim().toLowerCase();
 }
-function resolveDelivery(graph, input3) {
-  const direct = graph.deliveries.get(input3);
+function resolveDelivery(graph, input2) {
+  const direct = graph.deliveries.get(input2);
   if (direct) return direct;
-  const target = normalize(input3);
+  const target = normalize(input2);
   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);
@@ -2758,9 +3181,9 @@ function resolveDelivery(graph, input3) {
     return byName[0];
   }
   if (byName.length > 1) {
-    throw new Error(`Multiple deliveries match '${input3}'. Use delivery id instead.`);
+    throw new Error(`Multiple deliveries match '${input2}'. Use delivery id instead.`);
   }
-  throw new Error(`Delivery '${input3}' not found.`);
+  throw new Error(`Delivery '${input2}' not found.`);
 }
 
 // src/commands/graph.ts
@@ -2790,7 +3213,7 @@ function renderAsciiDag(tasks, order) {
 }
 function runValidate() {
   const root = resolveRepoRoot();
-  const graph = load_graph3(coopDir(root));
+  const graph = load_graph4(coopDir(root));
   const issues = validate_graph(graph);
   if (issues.length === 0) {
     console.log(chalk.green("Graph is healthy. No invariant violations found."));
@@ -2805,12 +3228,20 @@ function runValidate() {
 }
 function runNext(options) {
   const root = resolveRepoRoot();
-  const graph = load_graph3(coopDir(root));
+  const context = readWorkingContext(root, resolveCoopHome());
+  const resolvedTrack = resolveContextValueWithSource(options.track, context.track, sharedDefault(root, "track"));
+  const resolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery, sharedDefault(root, "delivery"));
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({ track: resolvedTrack, delivery: resolvedDelivery })) {
+      console.log(line);
+    }
+  }
+  const graph = load_graph4(coopDir(root));
   const readiness = compute_readiness_with_corrections(graph);
   const limit = options.limit && options.limit.trim().length > 0 ? Number(options.limit) : void 0;
   const ready = schedule_next2(graph, {
-    track: options.track,
-    delivery: options.delivery,
+    track: resolvedTrack.value,
+    delivery: resolvedDelivery.value,
     executor: options.executor,
     today: options.today,
     limit: Number.isInteger(limit) && Number(limit) > 0 ? Number(limit) : void 0
@@ -2824,7 +3255,7 @@ function runNext(options) {
         ready.map((entry) => [
           entry.task.id,
           entry.task.title,
-          entry.task.priority ?? "-",
+          effective_priority2(entry.task, resolvedTrack.value),
           entry.task.track ?? "-",
           entry.score.toFixed(1),
           entry.fits_capacity ? chalk.green("yes") : chalk.yellow("no"),
@@ -2854,13 +3285,13 @@ Warnings (${readiness.warnings.length}):`);
 }
 function runShow() {
   const root = resolveRepoRoot();
-  const graph = load_graph3(coopDir(root));
+  const graph = load_graph4(coopDir(root));
   const order = topological_sort(graph);
   console.log(renderAsciiDag(graph.nodes, order));
 }
 function runCriticalPath(deliveryName) {
   const root = resolveRepoRoot();
-  const graph = load_graph3(coopDir(root));
+  const graph = load_graph4(coopDir(root));
   const delivery = resolveDelivery(graph, deliveryName);
   const result = compute_critical_path(delivery, graph);
   console.log(`Critical Path: ${delivery.name} (${delivery.id})`);
@@ -2899,13 +3330,16 @@ function registerGraphCommand(program) {
 }
 
 // src/utils/ai-help.ts
-import path7 from "path";
+import path9 from "path";
 var catalog = {
   purpose: "COOP is a Git-native planning, backlog, execution, and orchestration CLI. It stores canonical data in .coop/projects/<project.id>/ and should be treated as the source of truth for work selection and lifecycle state.",
   selection_rules: [
     "Use `coop project show` first to confirm the active workspace and project.",
+    "Use `coop use show` to inspect the current user-local working defaults for track, delivery, and version.",
     "Use `coop graph next --delivery <delivery>` or `coop next task` to choose work. Do not reprioritize outside COOP unless the user explicitly overrides it.",
-    "Use `coop show task <id>` before implementation to read acceptance, tests_required, dependencies, and origin refs.",
+    "Commands resolve selection scope from: explicit CLI arg, then `coop use` working context, then shared project defaults.",
+    "Use `--track` for the workstream lens (home track or delivery_tracks). Use `--delivery` for release/scope membership.",
+    "Use `coop show <id>` or `coop show task <id>` before implementation to read acceptance, tests_required, dependencies, origin refs, and task metadata.",
     "Use `coop refine idea` or `coop refine task` when the task lacks planning detail. COOP owns canonical writes; agents should not edit `.coop` files directly."
   ],
   workspace_rules: [
@@ -2955,6 +3389,11 @@ var catalog = {
         { usage: "coop project list", purpose: "List projects in the current workspace." },
         { usage: "coop project show", purpose: "Show the active project id, name, path, and layout." },
         { usage: "coop project use <id>", purpose: "Switch the active project in a multi-project workspace." },
+        { usage: "coop use show", purpose: "Show the user-local working defaults for track, delivery, and version." },
+        { usage: "coop use track <id>", purpose: "Set the default working track for commands that can infer scope." },
+        { usage: "coop use delivery <id>", purpose: "Set the default working delivery for commands that need delivery scope." },
+        { usage: "coop use version <id>", purpose: "Set the default working version for promotion and prompt generation." },
+        { usage: "coop current", purpose: "Show the active project, working context, my active tasks, and the next ready task." },
         { usage: "coop naming", purpose: "Explain the current naming template, tokens, and examples." },
         { usage: 'coop naming preview "Natural-language COOP command recommender"', purpose: "Preview a semantic ID before creating an item." }
       ]
@@ -2967,6 +3406,7 @@ var catalog = {
         { usage: "coop create idea --from-file idea-draft.yml", purpose: "Ingest a structured idea draft file." },
         { usage: "cat idea.md | coop create idea --stdin", purpose: "Ingest an idea draft from stdin." },
         { usage: 'coop create task "Implement webhook pipeline"', purpose: "Create a task with defaults." },
+        { usage: 'coop create task --title "Lock auth contract" --track MVP --delivery MVP', purpose: "Create a task directly inside a track and delivery scope." },
         {
           usage: 'coop create task --title "Lock auth contract" --acceptance "Contract approved,Client mapping documented" --tests-required "Contract fixture test" --authority-ref docs/webapp-mvp-plan.md#auth',
           purpose: "Create a planning-grade task with acceptance, tests, and origin refs."
@@ -2993,8 +3433,10 @@ var catalog = {
       commands: [
         { usage: "coop next task", purpose: "Show the top ready task using the default track or full workspace context." },
         { usage: "coop graph next --delivery MVP", purpose: "Show the ready queue for a delivery with scores and blockers." },
+        { usage: "coop pick task PM-101 --promote --claim --actor dev1 --user lead-user", purpose: "Select a specific task, optionally promote it in the current context, assign it, and move it to in_progress." },
         { usage: "coop pick task --delivery MVP --claim --actor dev1 --user lead-user", purpose: "Select the top ready task, optionally assign it, and move it to in_progress." },
-        { usage: "coop start task PM-101 --claim --actor dev1 --user lead-user", purpose: "Start a specific task or the top ready task if no id is provided." },
+        { usage: "coop start task PM-101 --promote --claim --actor dev1 --user lead-user", purpose: "Start a specific task or the top ready task if no id is provided." },
+        { usage: "coop promote task PM-101", purpose: "Promote a task using the current working track/version context." },
         { usage: "coop review task PM-101", purpose: "Move an in-progress task into in_review using a DX-friendly verb." },
         { usage: "coop complete task PM-101", purpose: "Move a task in review into done using a DX-friendly verb." },
         { usage: "coop block task PM-101", purpose: "Mark a task as blocked." },
@@ -3008,8 +3450,21 @@ var catalog = {
       description: "Read backlog state, task details, and planning output.",
       commands: [
         { usage: "coop list tasks --status todo", purpose: "List tasks with filters." },
+        { usage: "coop list tasks --track MVP --delivery MVP --ready --columns id,title,p,assignee,score", purpose: "List ready tasks with lean columns and score visible." },
+        { usage: "coop list tasks --mine", purpose: "List tasks assigned to the current default COOP author." },
+        { usage: 'coop search "auth and login form"', purpose: "Run deterministic non-AI search across tasks, ideas, and deliveries." },
+        { usage: 'coop search "auth" --open', purpose: "Require a single match and print the resolved summary row." },
+        { usage: "coop show PM-101", purpose: "Resolve a task, idea, or delivery by reference without an extra entity noun." },
+        { usage: "coop show PM-101 --compact", purpose: "Show a smaller summary view for a large task." },
         { usage: "coop show task PM-101", purpose: "Show a task with acceptance, tests_required, refs, and runbook sections." },
         { usage: "coop show idea IDEA-101", purpose: "Show an idea." },
+        { usage: "coop deps PM-101", purpose: "Show task dependencies and reverse dependencies with status and title." },
+        { usage: "coop prompt PM-101 --format markdown", purpose: "Generate a manual handoff prompt from a task and current working context." },
+        { usage: "coop update PM-101 --track MVP --delivery MVP", purpose: "Update a task's home track or primary delivery without editing `.coop` files directly." },
+        { usage: "coop update PM-101 --add-delivery-track MVP --priority-in MVP:p0", purpose: "Add a contributing track lens and scoped priority override." },
+        { usage: "coop update PM-101 --priority p1 --add-fix-version v2", purpose: "Update task metadata without editing `.coop` files directly." },
+        { usage: 'coop comment PM-101 --message "Needs API review"', purpose: "Append a comment to a task." },
+        { usage: 'coop log-time PM-101 --hours 2 --kind worked --note "pairing"', purpose: "Append a planned or worked time log to a task." },
         { usage: "coop plan delivery MVP", purpose: "Run delivery feasibility analysis." },
         { usage: "coop plan delivery MVP --monte-carlo --iterations 5000", purpose: "Run probabilistic delivery forecasting." },
         { usage: "coop view velocity", purpose: "Show historical throughput." },
@@ -3052,6 +3507,7 @@ var catalog = {
   execution_model: [
     "Agents or services may send drafts through files or stdin, but COOP owns canonical writes.",
     "Use `coop create ... --from-file|--stdin` and `coop apply draft` instead of editing `.coop` task or idea files directly.",
+    "Use `coop update`, `coop comment`, and `coop log-time` for task mutations instead of manually editing task files.",
     "Use `coop log --last --verbose` when command execution fails and the concise error points to a stack trace.",
     "If a workflow depends on stable human-readable IDs, inspect `coop naming` or `coop config id.naming` before creating items."
   ],
@@ -3168,7 +3624,7 @@ function renderAiHelpTopic(format, topic) {
 `;
 }
 function normalizeRepoPath(repoPath) {
-  return repoPath ? path7.resolve(repoPath) : process.cwd();
+  return repoPath ? path9.resolve(repoPath) : process.cwd();
 }
 function formatSelectionCommand(commandName, delivery, track) {
   if (delivery) {
@@ -3209,12 +3665,15 @@ function renderInitialPrompt(options = {}) {
     `- If you are unsure about lifecycle changes, run \`${commandName} help-ai --state-transitions --format markdown\`.`,
     `- If you are unsure where artifacts should go, run \`${commandName} help-ai --artifacts --format markdown\`.`,
     `- If you are unsure whether to continue after a task, run \`${commandName} help-ai --post-execution --format markdown\`.`,
+    `- Use \`${commandName} use show\` to inspect current working track, delivery, and version defaults before selecting work.`,
     "- Use only commands that actually exist in COOP. Do not invent command names.",
     "- Do not reprioritize work outside COOP unless the user explicitly overrides it.",
     "- Select only the first ready task from the COOP readiness output.",
-    "- Inspect the selected task with `coop show task <id>` before implementation.",
+    "- Inspect the selected task with `coop show <id>` before implementation.",
     "- Do not create, edit, move, or normalize files directly inside `.coop/`; use COOP commands, MCP, or API surfaces so COOP remains the canonical writer.",
     "- Respect lifecycle prerequisites: use `coop review task <id>` before `coop complete task <id>`; do not complete directly from `in_progress`.",
+    "- Use `coop promote <id>` or `coop pick/start --promote` when the selected task must be escalated inside the active track/version context.",
+    "- Use `coop update <id>`, `coop comment <id>`, and `coop log-time <id>` for task metadata changes; do not hand-edit task frontmatter.",
     `- Write any contract-review, audit, or planning artifact under \`${artifactsDir}\` unless the user explicitly chooses another location.`
   ];
   if (rigour === "strict") {
@@ -3256,6 +3715,9 @@ function renderAiHelp(format) {
   const heading = format === "markdown" ? "# COOP AI Help" : "COOP AI Help";
   lines.push(heading, "");
   lines.push(catalog.purpose, "");
+  lines.push("Fast agent handoff:");
+  lines.push("- `coop help-ai --initial-prompt --strict --repo C:/path/to/repo --delivery MVP --command coop.cmd`");
+  lines.push("");
   const bullet = (value) => format === "markdown" ? `- ${value}` : `- ${value}`;
   lines.push(format === "markdown" ? "## Selection Rules" : "Selection Rules");
   for (const rule of catalog.selection_rules) {
@@ -3341,7 +3803,7 @@ function registerHelpAiCommand(program) {
     } catch {
       artifactsDir = "docs";
     }
-    const output3 = options.initialPrompt ? renderAiInitialPrompt({
+    const output2 = options.initialPrompt ? renderAiInitialPrompt({
       repoPath: options.repo,
       delivery: options.delivery,
       track: options.track,
@@ -3349,7 +3811,7 @@ function registerHelpAiCommand(program) {
       rigour,
       artifactsDir
     }) : topic ? renderAiHelpTopic(format, topic) : renderAiHelp(format);
-    console.log(output3.trimEnd());
+    console.log(output2.trimEnd());
   });
 }
 function resolveHelpTopic(options) {
@@ -3372,11 +3834,11 @@ function resolveHelpTopic(options) {
   if (options.naming) {
     requestedTopics.push("naming");
   }
-  const unique2 = [...new Set(requestedTopics)];
-  if (unique2.length > 1) {
-    throw new Error(`Specify only one focused help-ai topic at a time. Received: ${unique2.join(", ")}.`);
+  const unique3 = [...new Set(requestedTopics)];
+  if (unique3.length > 1) {
+    throw new Error(`Specify only one focused help-ai topic at a time. Received: ${unique3.join(", ")}.`);
   }
-  const topic = unique2[0];
+  const topic = unique3[0];
   if (topic !== void 0 && topic !== "state-transitions" && topic !== "artifacts" && topic !== "post-execution" && topic !== "selection" && topic !== "naming") {
     throw new Error(`Unsupported help-ai topic '${topic}'. Expected state-transitions|artifacts|post-execution|selection|naming.`);
   }
@@ -3384,7 +3846,7 @@ function resolveHelpTopic(options) {
 }
 
 // src/commands/index.ts
-import path8 from "path";
+import path10 from "path";
 import { IndexManager as IndexManager2 } from "@kitsy/coop-core";
 function runStatus(options) {
   const root = resolveRepoRoot();
@@ -3394,7 +3856,7 @@ function runStatus(options) {
   const freshness = status.stale ? "stale" : "fresh";
   const existsText = status.exists ? "present" : "missing";
   console.log(`[COOP] index ${existsText}, ${freshness}`);
-  console.log(`[COOP] graph: ${path8.relative(root, status.graph_path)}`);
+  console.log(`[COOP] graph: ${path10.relative(root, status.graph_path)}`);
   if (status.generated_at) {
     console.log(`[COOP] generated_at: ${status.generated_at}`);
   }
@@ -3417,7 +3879,7 @@ function runRebuild() {
   const graph = manager.build_full_index();
   const elapsed = Date.now() - start;
   console.log(`[COOP] index rebuilt: ${graph.nodes.size} tasks (${elapsed} ms)`);
-  console.log(`[COOP] graph: ${path8.relative(root, manager.graphPath)}`);
+  console.log(`[COOP] graph: ${path10.relative(root, manager.graphPath)}`);
 }
 function registerIndexCommand(program) {
   const index = program.command("index").description("Index management commands");
@@ -3433,18 +3895,16 @@ function registerIndexCommand(program) {
 }
 
 // src/commands/init.ts
-import fs8 from "fs";
-import path11 from "path";
+import fs10 from "fs";
+import path13 from "path";
 import { spawnSync as spawnSync4 } 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
-import fs6 from "fs";
-import path9 from "path";
+import fs8 from "fs";
+import path11 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
-import { detect_cycle, parseTaskContent, parseTaskFile as parseTaskFile7, validateStructural as validateStructural5 } from "@kitsy/coop-core";
+import { detect_cycle, parseTaskContent, parseTaskFile as parseTaskFile8, validateStructural as validateStructural6 } from "@kitsy/coop-core";
 var HOOK_BLOCK_START = "# COOP_PRE_COMMIT_START";
 var HOOK_BLOCK_END = "# COOP_PRE_COMMIT_END";
 function runGit(repoRoot, args, allowFailure = false) {
@@ -3473,28 +3933,28 @@ function projectRootFromRelativePath(repoRoot, relativePath) {
   const normalized = toPosixPath2(relativePath);
   const projectMatch = /^\.coop\/projects\/([^/]+)\/tasks\/.+\.md$/i.exec(normalized);
   if (projectMatch?.[1]) {
-    return path9.join(repoRoot, ".coop", "projects", projectMatch[1]);
+    return path11.join(repoRoot, ".coop", "projects", projectMatch[1]);
   }
   if (normalized.startsWith(".coop/tasks/")) {
-    return path9.join(repoRoot, ".coop");
+    return path11.join(repoRoot, ".coop");
   }
   throw new Error(`Unsupported staged COOP task path '${relativePath}'.`);
 }
 function listTaskFilesForProject(projectRoot) {
-  const tasksDir = path9.join(projectRoot, "tasks");
-  if (!fs6.existsSync(tasksDir)) return [];
+  const tasksDir = path11.join(projectRoot, "tasks");
+  if (!fs8.existsSync(tasksDir)) return [];
   const out = [];
   const stack = [tasksDir];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = fs6.readdirSync(current, { withFileTypes: true });
+    const entries = fs8.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path9.join(current, entry.name);
+      const fullPath = path11.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
       }
-      if (entry.isFile() && path9.extname(entry.name).toLowerCase() === ".md") {
+      if (entry.isFile() && path11.extname(entry.name).toLowerCase() === ".md") {
         out.push(fullPath);
       }
     }
@@ -3513,7 +3973,7 @@ function parseStagedTasks(repoRoot, relativePaths) {
   const errors = [];
   const staged = [];
   for (const relativePath of relativePaths) {
-    const absolutePath = path9.join(repoRoot, ...relativePath.split("/"));
+    const absolutePath = path11.join(repoRoot, ...relativePath.split("/"));
     const projectRoot = projectRootFromRelativePath(repoRoot, relativePath);
     const stagedBlob = readGitBlob(repoRoot, `:${relativePath}`);
     if (!stagedBlob) {
@@ -3528,7 +3988,7 @@ function parseStagedTasks(repoRoot, relativePaths) {
       errors.push(`[COOP] ${message}`);
       continue;
     }
-    const issues = validateStructural5(task, { filePath: absolutePath });
+    const issues = validateStructural6(task, { filePath: absolutePath });
     for (const issue of issues) {
       errors.push(`[COOP] ${relativePath}: ${issue.message}`);
     }
@@ -3577,13 +4037,13 @@ function collectTasksForCycleCheck(projectRoot, stagedTasks) {
   }
   const tasks = [];
   for (const filePath of listTaskFilesForProject(projectRoot)) {
-    const normalized = toPosixPath2(path9.resolve(filePath));
+    const normalized = toPosixPath2(path11.resolve(filePath));
     const stagedTask = stagedByPath.get(normalized);
     if (stagedTask) {
       tasks.push(stagedTask);
       continue;
     }
-    tasks.push(parseTaskFile7(filePath).task);
+    tasks.push(parseTaskFile8(filePath).task);
   }
   return tasks;
 }
@@ -3607,7 +4067,7 @@ function runPreCommitChecks(repoRoot) {
         const graph = buildGraphForCycleCheck(tasks);
         const cycle = detect_cycle(graph);
         if (cycle) {
-          const projectLabel = toPosixPath2(path9.relative(repoRoot, projectRoot));
+          const projectLabel = toPosixPath2(path11.relative(repoRoot, projectRoot));
           errors.push(`[COOP] Dependency cycle detected in ${projectLabel}: ${cycle.join(" -> ")}.`);
         }
       } catch (error) {
@@ -3639,9 +4099,9 @@ function hookScriptBlock() {
   ].join("\n");
 }
 function installPreCommitHook(repoRoot) {
-  const hookPath = path9.join(repoRoot, ".git", "hooks", "pre-commit");
-  const hookDir = path9.dirname(hookPath);
-  if (!fs6.existsSync(hookDir)) {
+  const hookPath = path11.join(repoRoot, ".git", "hooks", "pre-commit");
+  const hookDir = path11.dirname(hookPath);
+  if (!fs8.existsSync(hookDir)) {
     return {
       installed: false,
       hookPath,
@@ -3649,18 +4109,18 @@ function installPreCommitHook(repoRoot) {
     };
   }
   const block = hookScriptBlock();
-  if (!fs6.existsSync(hookPath)) {
+  if (!fs8.existsSync(hookPath)) {
     const content = ["#!/bin/sh", "", block].join("\n");
-    fs6.writeFileSync(hookPath, content, "utf8");
+    fs8.writeFileSync(hookPath, content, "utf8");
   } else {
-    const existing = fs6.readFileSync(hookPath, "utf8");
+    const existing = fs8.readFileSync(hookPath, "utf8");
     if (!existing.includes(HOOK_BLOCK_START)) {
       const suffix = existing.endsWith("\n") ? "" : "\n";
-      fs6.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
+      fs8.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
     }
   }
   try {
-    fs6.chmodSync(hookPath, 493);
+    fs8.chmodSync(hookPath, 493);
   } catch {
   }
   return {
@@ -3671,15 +4131,15 @@ function installPreCommitHook(repoRoot) {
 }
 
 // src/hooks/post-merge-validate.ts
-import fs7 from "fs";
-import path10 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import { list_projects } from "@kitsy/coop-core";
-import { load_graph as load_graph4, validate_graph as validate_graph2 } from "@kitsy/coop-core";
+import { load_graph as load_graph5, 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 workspaceDir = path10.join(repoRoot, ".coop");
-  if (!fs7.existsSync(workspaceDir)) {
+  const workspaceDir = path12.join(repoRoot, ".coop");
+  if (!fs9.existsSync(workspaceDir)) {
     return {
       ok: true,
       warnings: ["[COOP] Skipped post-merge validation (.coop not found)."]
@@ -3695,7 +4155,7 @@ function runPostMergeValidate(repoRoot) {
     }
     const warnings = [];
     for (const project of projects) {
-      const graph = load_graph4(project.root);
+      const graph = load_graph5(project.root);
       const issues = validate_graph2(graph);
       for (const issue of issues) {
         warnings.push(`[COOP] post-merge warning [${project.id}] [${issue.invariant}] ${issue.message}`);
@@ -3731,9 +4191,9 @@ function postMergeHookBlock() {
   ].join("\n");
 }
 function installPostMergeHook(repoRoot) {
-  const hookPath = path10.join(repoRoot, ".git", "hooks", "post-merge");
-  const hookDir = path10.dirname(hookPath);
-  if (!fs7.existsSync(hookDir)) {
+  const hookPath = path12.join(repoRoot, ".git", "hooks", "post-merge");
+  const hookDir = path12.dirname(hookPath);
+  if (!fs9.existsSync(hookDir)) {
     return {
       installed: false,
       hookPath,
@@ -3741,17 +4201,17 @@ function installPostMergeHook(repoRoot) {
     };
   }
   const block = postMergeHookBlock();
-  if (!fs7.existsSync(hookPath)) {
-    fs7.writeFileSync(hookPath, ["#!/bin/sh", "", block].join("\n"), "utf8");
+  if (!fs9.existsSync(hookPath)) {
+    fs9.writeFileSync(hookPath, ["#!/bin/sh", "", block].join("\n"), "utf8");
   } else {
-    const existing = fs7.readFileSync(hookPath, "utf8");
+    const existing = fs9.readFileSync(hookPath, "utf8");
     if (!existing.includes(HOOK_BLOCK_START2)) {
       const suffix = existing.endsWith("\n") ? "" : "\n";
-      fs7.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
+      fs9.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
     }
   }
   try {
-    fs7.chmodSync(hookPath, 493);
+    fs9.chmodSync(hookPath, 493);
   } catch {
   }
   return {
@@ -3762,6 +4222,28 @@ function installPostMergeHook(repoRoot) {
 }
 
 // src/commands/init.ts
+var NAMING_TEMPLATE_PRESETS = [
+  {
+    label: "<TYPE>-<TITLE16>-<SEQ>",
+    value: "<TYPE>-<TITLE16>-<SEQ>",
+    hint: "Balanced semantic default"
+  },
+  {
+    label: "<TYPE>-<TRACK>-<TITLE16>-<SEQ>",
+    value: "<TYPE>-<TRACK>-<TITLE16>-<SEQ>",
+    hint: "Include track in ids"
+  },
+  {
+    label: "<TYPE>-<USER>-<YYMMDD>-<RAND>",
+    value: "<TYPE>-<USER>-<YYMMDD>-<RAND>",
+    hint: "Actor/date/random oriented"
+  },
+  {
+    label: "Custom template",
+    value: "__custom__",
+    hint: "Enter a custom naming template manually"
+  }
+];
 function normalizeProjectId(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
 }
@@ -3917,40 +4399,40 @@ tmp/
 *.tmp
 `;
 function ensureDir(dirPath) {
-  fs8.mkdirSync(dirPath, { recursive: true });
+  fs10.mkdirSync(dirPath, { recursive: true });
 }
 function writeIfMissing(filePath, content) {
-  if (!fs8.existsSync(filePath)) {
-    fs8.writeFileSync(filePath, content, "utf8");
+  if (!fs10.existsSync(filePath)) {
+    fs10.writeFileSync(filePath, content, "utf8");
   }
 }
 function ensureGitignoreEntry(root, entry) {
-  const gitignorePath = path11.join(root, ".gitignore");
-  if (!fs8.existsSync(gitignorePath)) {
-    fs8.writeFileSync(gitignorePath, `${entry}
+  const gitignorePath = path13.join(root, ".gitignore");
+  if (!fs10.existsSync(gitignorePath)) {
+    fs10.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs8.readFileSync(gitignorePath, "utf8");
+  const content = fs10.readFileSync(gitignorePath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (!lines.includes(entry)) {
     const suffix = content.endsWith("\n") ? "" : "\n";
-    fs8.writeFileSync(gitignorePath, `${content}${suffix}${entry}
+    fs10.writeFileSync(gitignorePath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
 function ensureGitattributesEntry(root, entry) {
-  const attrsPath = path11.join(root, ".gitattributes");
-  if (!fs8.existsSync(attrsPath)) {
-    fs8.writeFileSync(attrsPath, `${entry}
+  const attrsPath = path13.join(root, ".gitattributes");
+  if (!fs10.existsSync(attrsPath)) {
+    fs10.writeFileSync(attrsPath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs8.readFileSync(attrsPath, "utf8");
+  const content = fs10.readFileSync(attrsPath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (!lines.includes(entry)) {
     const suffix = content.endsWith("\n") ? "" : "\n";
-    fs8.writeFileSync(attrsPath, `${content}${suffix}${entry}
+    fs10.writeFileSync(attrsPath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
@@ -3982,36 +4464,27 @@ 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)", "");
-    const namingTemplate = options.naming?.trim() || await ask2("ID naming template", DEFAULT_ID_NAMING_TEMPLATE);
-    return {
-      projectName,
-      projectId,
-      projectAliases: parseAliases2(aliasesInput),
-      namingTemplate
-    };
-  } finally {
-    rl.close();
+  const initialName = options.name?.trim() || defaultName;
+  const projectName = options.name?.trim() || await ask("Project name", initialName);
+  const defaultId = options.id?.trim() || normalizeProjectId(projectName) || repoIdentityId(root);
+  const projectIdRaw = options.id?.trim() || await ask("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 ask("Aliases (csv, optional)", "");
+  let namingTemplate = options.naming?.trim();
+  if (!namingTemplate) {
+    const selected = await select("ID naming template", [...NAMING_TEMPLATE_PRESETS], 0);
+    namingTemplate = selected === "__custom__" ? await ask("Custom ID naming template", DEFAULT_ID_NAMING_TEMPLATE) : selected;
   }
+  return {
+    projectName,
+    projectId,
+    projectAliases: parseAliases2(aliasesInput),
+    namingTemplate
+  };
 }
 async function resolveInitIdentity(root, options) {
   const defaultName = repoDisplayName(root);
@@ -4019,7 +4492,7 @@ async function resolveInitIdentity(root, options) {
   const fallbackId = normalizeProjectId(options.id?.trim() || fallbackName) || repoIdentityId(root);
   const fallbackAliases = parseAliases2(options.aliases);
   const fallbackNaming = options.naming?.trim() || DEFAULT_ID_NAMING_TEMPLATE;
-  const interactive = Boolean(options.interactive || !options.yes && input.isTTY && output.isTTY);
+  const interactive = Boolean(options.interactive || !options.yes && process.stdin.isTTY && process.stdout.isTTY);
   if (interactive) {
     return promptInitIdentity(root, options);
   }
@@ -4036,7 +4509,7 @@ function registerInitCommand(program) {
     const workspaceDir = coopWorkspaceDir(root);
     const identity = await resolveInitIdentity(root, options);
     const projectId = identity.projectId;
-    const projectRoot = path11.join(workspaceDir, "projects", projectId);
+    const projectRoot = path13.join(workspaceDir, "projects", projectId);
     const dirs = [
       "ideas",
       "tasks",
@@ -4052,23 +4525,23 @@ function registerInitCommand(program) {
       "history/deliveries",
       ".index"
     ];
-    ensureDir(path11.join(workspaceDir, "projects"));
+    ensureDir(path13.join(workspaceDir, "projects"));
     for (const dir of dirs) {
-      ensureDir(path11.join(projectRoot, dir));
+      ensureDir(path13.join(projectRoot, dir));
     }
     writeIfMissing(
-      path11.join(projectRoot, "config.yml"),
+      path13.join(projectRoot, "config.yml"),
       buildProjectConfig(projectId, identity.projectName, identity.projectAliases, identity.namingTemplate)
     );
-    if (!fs8.existsSync(path11.join(projectRoot, "schema-version"))) {
+    if (!fs10.existsSync(path13.join(projectRoot, "schema-version"))) {
       write_schema_version(projectRoot, CURRENT_SCHEMA_VERSION);
     }
-    writeIfMissing(path11.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
-    writeIfMissing(path11.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE);
-    writeIfMissing(path11.join(projectRoot, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
-    writeIfMissing(path11.join(projectRoot, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
-    writeIfMissing(path11.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE);
-    writeIfMissing(path11.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE);
+    writeIfMissing(path13.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
+    writeIfMissing(path13.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE);
+    writeIfMissing(path13.join(projectRoot, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
+    writeIfMissing(path13.join(projectRoot, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
+    writeIfMissing(path13.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE);
+    writeIfMissing(path13.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE);
     writeWorkspaceConfig(root, { version: 2, current_project: projectId });
     ensureGitignoreEntry(root, ".coop/logs/");
     ensureGitignoreEntry(root, ".coop/tmp/");
@@ -4078,30 +4551,32 @@ function registerInitCommand(program) {
     const project = resolveProject(root, projectId);
     console.log("Initialized COOP workspace.");
     console.log(`- Root: ${root}`);
-    console.log(`- Workspace: ${path11.relative(root, workspaceDir)}`);
-    console.log(`- Project: ${project.id} (${path11.relative(root, project.root)})`);
+    console.log(`- Workspace: ${path13.relative(root, workspaceDir)}`);
+    console.log(`- Project: ${project.id} (${path13.relative(root, project.root)})`);
     console.log(`- Name: ${identity.projectName}`);
     console.log(`- Aliases: ${identity.projectAliases.length > 0 ? identity.projectAliases.join(", ") : "(none)"}`);
     console.log(`- ID naming: ${identity.namingTemplate}`);
     console.log(`- ${preCommitHook.message}`);
     if (preCommitHook.installed) {
-      console.log(`- Hook: ${path11.relative(root, preCommitHook.hookPath)}`);
+      console.log(`- Hook: ${path13.relative(root, preCommitHook.hookPath)}`);
     }
     console.log(`- ${postMergeHook.message}`);
     if (postMergeHook.installed) {
-      console.log(`- Hook: ${path11.relative(root, postMergeHook.hookPath)}`);
+      console.log(`- Hook: ${path13.relative(root, postMergeHook.hookPath)}`);
     }
     console.log(`- ${mergeDrivers}`);
     console.log("- Next steps:");
     console.log('  1. coop create idea "Describe the idea"');
     console.log('  2. coop create task "Describe the task"');
     console.log("  3. coop graph validate");
+    console.log(`  4. coop help-ai --initial-prompt --strict --repo ${root.replace(/\\/g, "/")} --command coop.cmd`);
+    console.log("  5. after you create a delivery, add --delivery <id> to that help-ai prompt for agent handoff");
   });
 }
 
 // src/commands/lifecycle.ts
-import path12 from "path";
-import { parseTaskFile as parseTaskFile8 } from "@kitsy/coop-core";
+import path14 from "path";
+import { parseTaskFile as parseTaskFile9 } from "@kitsy/coop-core";
 var lifecycleVerbs = [
   {
     name: "review",
@@ -4136,8 +4611,8 @@ var lifecycleVerbs = [
 ];
 function currentTaskSelection(root, id) {
   const reference = resolveReference(root, id, "task");
-  const filePath = path12.join(root, ...reference.file.split("/"));
-  const parsed = parseTaskFile8(filePath);
+  const filePath = path14.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile9(filePath);
   return formatSelectedTask(
     {
       task: parsed.task,
@@ -4161,16 +4636,16 @@ function registerLifecycleCommands(program) {
 }
 
 // src/commands/list.ts
-import path13 from "path";
-import { parseIdeaFile as parseIdeaFile3, parseTaskFile as parseTaskFile9 } from "@kitsy/coop-core";
+import path15 from "path";
+import {
+  effective_priority as effective_priority3,
+  load_graph as load_graph6,
+  parseDeliveryFile as parseDeliveryFile2,
+  parseIdeaFile as parseIdeaFile4,
+  parseTaskFile as parseTaskFile10,
+  schedule_next as schedule_next3
+} from "@kitsy/coop-core";
 import chalk2 from "chalk";
-
-// src/utils/not-implemented.ts
-function printNotImplemented(command, phase) {
-  console.log(`${command}: Not yet implemented - coming in Phase ${phase}.`);
-}
-
-// src/commands/list.ts
 function statusColor(status) {
   switch (status) {
     case "done":
@@ -4187,53 +4662,309 @@ function statusColor(status) {
       return status;
   }
 }
-function sortByIdAsc(items) {
-  return [...items].sort((a, b) => a.id.localeCompare(b.id));
+function parseColumns(input2) {
+  return (input2 ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
 }
-function loadTasks(root) {
+function normalizeTaskColumns(value, ready) {
+  if (!value?.trim()) {
+    return ready ? ["id", "title", "priority", "status", "assignee", "score"] : ["id", "title", "priority", "status", "assignee"];
+  }
+  const raw = parseColumns(value);
+  if (raw.length === 1 && raw[0] === "all") {
+    return ["id", "title", "priority", "status", "assignee", "track", "delivery", "score", "file"];
+  }
+  const normalized = raw.map((column) => {
+    if (column === "p") return "priority";
+    return column;
+  });
+  const valid = /* @__PURE__ */ new Set(["id", "title", "status", "priority", "assignee", "track", "delivery", "score", "file"]);
+  for (const column of normalized) {
+    if (!valid.has(column)) {
+      throw new Error(`Invalid task column '${column}'. Expected id|title|status|priority|assignee|track|delivery|score|file|all.`);
+    }
+  }
+  return normalized;
+}
+function normalizeIdeaColumns(value) {
+  if (!value?.trim()) {
+    return ["id", "title", "status"];
+  }
+  const raw = parseColumns(value);
+  if (raw.length === 1 && raw[0] === "all") {
+    return ["id", "title", "status", "file"];
+  }
+  const valid = /* @__PURE__ */ new Set(["id", "title", "status", "file"]);
+  for (const column of raw) {
+    if (!valid.has(column)) {
+      throw new Error(`Invalid idea column '${column}'. Expected id|title|status|file|all.`);
+    }
+  }
+  return raw;
+}
+function normalizeTaskSort(value, fallback) {
+  switch ((value ?? "").trim().toLowerCase()) {
+    case "":
+      return fallback;
+    case "id":
+    case "priority":
+    case "status":
+    case "title":
+    case "updated":
+    case "created":
+    case "score":
+      return value.trim().toLowerCase();
+    default:
+      throw new Error(`Invalid sort '${value}'. Expected id|priority|status|title|updated|created|score.`);
+  }
+}
+function normalizeIdeaSort(value, fallback) {
+  switch ((value ?? "").trim().toLowerCase()) {
+    case "":
+      return fallback;
+    case "id":
+    case "status":
+    case "title":
+    case "updated":
+    case "created":
+      return value.trim().toLowerCase();
+    default:
+      throw new Error(`Invalid sort '${value}'. Expected id|status|title|updated|created.`);
+  }
+}
+function priorityRank(value) {
+  switch (value) {
+    case "p0":
+      return 0;
+    case "p1":
+      return 1;
+    case "p2":
+      return 2;
+    case "p3":
+      return 3;
+    default:
+      return 4;
+  }
+}
+function taskStatusRank(value) {
+  switch (value) {
+    case "in_progress":
+      return 0;
+    case "in_review":
+      return 1;
+    case "todo":
+      return 2;
+    case "blocked":
+      return 3;
+    case "done":
+      return 4;
+    case "canceled":
+      return 5;
+    default:
+      return 6;
+  }
+}
+function ideaStatusRank(value) {
+  switch (value) {
+    case "active":
+      return 0;
+    case "captured":
+      return 1;
+    case "validated":
+      return 2;
+    case "rejected":
+      return 3;
+    case "promoted":
+      return 4;
+    default:
+      return 5;
+  }
+}
+function compareDatesDesc(a, b) {
+  return (b ?? "").localeCompare(a ?? "");
+}
+function compareTaskScoreLike(a, b, readyOrder, track) {
+  const aReady = readyOrder.get(a.id);
+  const bReady = readyOrder.get(b.id);
+  if (aReady !== void 0 || bReady !== void 0) {
+    if (aReady === void 0) return 1;
+    if (bReady === void 0) return -1;
+    return aReady - bReady;
+  }
+  const status = taskStatusRank(a.status) - taskStatusRank(b.status);
+  if (status !== 0) return status;
+  const priority = priorityRank(effective_priority3(b.task, track)) - priorityRank(effective_priority3(a.task, track));
+  if (priority !== 0) return priority;
+  const updated = compareDatesDesc(a.task.updated, b.task.updated);
+  if (updated !== 0) return updated;
+  return a.id.localeCompare(b.id);
+}
+function sortTaskRows(rows, sortMode, readyOrder, track) {
+  return [...rows].sort((a, b) => {
+    switch (sortMode) {
+      case "score":
+        return compareTaskScoreLike(a, b, readyOrder, track);
+      case "priority": {
+        const priority = priorityRank(a.priority) - priorityRank(b.priority);
+        if (priority !== 0) return priority;
+        return a.id.localeCompare(b.id);
+      }
+      case "status": {
+        const status = taskStatusRank(a.status) - taskStatusRank(b.status);
+        if (status !== 0) return status;
+        return a.id.localeCompare(b.id);
+      }
+      case "title":
+        return a.title.localeCompare(b.title);
+      case "updated": {
+        const updated = compareDatesDesc(a.task.updated, b.task.updated);
+        if (updated !== 0) return updated;
+        return a.id.localeCompare(b.id);
+      }
+      case "created": {
+        const created = compareDatesDesc(a.task.created, b.task.created);
+        if (created !== 0) return created;
+        return a.id.localeCompare(b.id);
+      }
+      case "id":
+      default:
+        return a.id.localeCompare(b.id);
+    }
+  });
+}
+function taskColumnHeader(column) {
+  switch (column) {
+    case "priority":
+      return "P";
+    case "assignee":
+      return "Assignee";
+    case "track":
+      return "Track";
+    case "delivery":
+      return "Delivery";
+    case "score":
+      return "Score";
+    case "file":
+      return "File";
+    case "status":
+      return "Status";
+    case "title":
+      return "Title";
+    case "id":
+    default:
+      return "ID";
+  }
+}
+function ideaColumnHeader(column) {
+  switch (column) {
+    case "file":
+      return "File";
+    case "status":
+      return "Status";
+    case "title":
+      return "Title";
+    case "id":
+    default:
+      return "ID";
+  }
+}
+function loadTasks2(root) {
   return listTaskFiles(root).map((filePath) => ({
-    task: parseTaskFile9(filePath).task,
+    task: parseTaskFile10(filePath).task,
     filePath
   }));
 }
 function loadIdeas(root) {
   return listIdeaFiles(root).map((filePath) => ({
-    idea: parseIdeaFile3(filePath).idea,
+    idea: parseIdeaFile4(filePath).idea,
     filePath
   }));
 }
 function listTasks(options) {
   const root = resolveRepoRoot();
   ensureCoopInitialized(root);
-  const rows = loadTasks(root).filter(({ task }) => {
+  const context = readWorkingContext(root, resolveCoopHome());
+  const graph = load_graph6(coopDir(root));
+  const resolvedTrack = resolveContextValueWithSource(options.track, context.track);
+  const resolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery);
+  const resolvedVersion = resolveContextValueWithSource(options.version, context.version);
+  const assignee = options.mine ? defaultCoopAuthor(root) : options.assignee?.trim();
+  const deliveryScope = resolvedDelivery.value ? new Set(graph.deliveries.get(resolvedDelivery.value)?.scope.include ?? []) : null;
+  const defaultSort = options.ready || resolvedTrack.value || resolvedDelivery.value ? "score" : "id";
+  const sortMode = normalizeTaskSort(options.sort, defaultSort);
+  const columns = normalizeTaskColumns(options.columns, Boolean(options.ready));
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({
+      track: resolvedTrack,
+      delivery: resolvedDelivery,
+      version: resolvedVersion
+    })) {
+      console.log(line);
+    }
+  }
+  const scoredEntries = sortMode === "score" || options.ready ? schedule_next3(graph, {
+    track: resolvedTrack.value,
+    delivery: resolvedDelivery.value
+  }) : [];
+  const readyIds = options.ready ? new Set(scoredEntries.map((entry) => entry.task.id)) : null;
+  const readyOrder = new Map(scoredEntries.map((entry, index) => [entry.task.id, index]));
+  const scoreMap = new Map(scoredEntries.map((entry) => [entry.task.id, entry.score]));
+  const rows = loadTasks2(root).filter(({ task }) => {
+    if (readyIds && !readyIds.has(task.id)) return false;
     if (options.status && task.status !== options.status) return false;
-    if (options.track && (task.track ?? "unassigned") !== options.track) return false;
-    if (options.priority && (task.priority ?? "p2") !== options.priority) return false;
+    if (resolvedTrack.value && task.track !== resolvedTrack.value && !(task.delivery_tracks ?? []).includes(resolvedTrack.value)) {
+      return false;
+    }
+    if (resolvedDelivery.value && task.delivery !== resolvedDelivery.value && !deliveryScope?.has(task.id)) return false;
+    if (options.priority && taskEffectivePriority(task, resolvedTrack.value) !== options.priority) return false;
+    if (assignee && (task.assignee ?? "") !== assignee) return false;
+    if (resolvedVersion.value && !(task.fix_versions ?? []).includes(resolvedVersion.value) && !(task.released_in ?? []).includes(resolvedVersion.value)) {
+      return false;
+    }
     return true;
   }).map(({ task, filePath }) => ({
+    task,
     id: task.id,
     title: task.title,
     status: task.status,
-    priority: task.priority ?? "-",
+    priority: taskEffectivePriority(task, resolvedTrack.value),
     track: task.track ?? "-",
+    assignee: task.assignee ?? "-",
+    delivery: task.delivery ?? "-",
     filePath
   }));
-  const sorted = sortByIdAsc(rows);
+  const sorted = sortTaskRows(rows, sortMode, readyOrder, resolvedTrack.value);
   if (sorted.length === 0) {
     console.log("No tasks found.");
     return;
   }
   console.log(
     formatTable(
-      ["ID", "Title", "Status", "Priority", "Track", "File"],
-      sorted.map((entry) => [
-        entry.id,
-        entry.title,
-        statusColor(entry.status),
-        entry.priority,
-        entry.track,
-        path13.relative(root, entry.filePath)
-      ])
+      columns.map(taskColumnHeader),
+      sorted.map(
+        (entry) => columns.map((column) => {
+          switch (column) {
+            case "title":
+              return entry.title;
+            case "status":
+              return statusColor(entry.status);
+            case "priority":
+              return entry.priority;
+            case "assignee":
+              return entry.assignee;
+            case "track":
+              return entry.track;
+            case "delivery":
+              return entry.delivery;
+            case "score":
+              return scoreMap.has(entry.id) ? scoreMap.get(entry.id).toFixed(1) : "-";
+            case "file":
+              return path15.relative(root, entry.filePath);
+            case "id":
+            default:
+              return entry.id;
+          }
+        })
+      )
     )
   );
   console.log(`
@@ -4242,6 +4973,8 @@ Total tasks: ${sorted.length}`);
 function listIdeas(options) {
   const root = resolveRepoRoot();
   ensureCoopInitialized(root);
+  const sortMode = normalizeIdeaSort(options.sort, "id");
+  const columns = normalizeIdeaColumns(options.columns);
   const rows = loadIdeas(root).filter(({ idea }) => {
     if (options.status && idea.status !== options.status) return false;
     return true;
@@ -4253,64 +4986,115 @@ function listIdeas(options) {
     track: "-",
     filePath
   }));
-  const sorted = sortByIdAsc(rows);
+  const sorted = [...rows].sort((a, b) => {
+    switch (sortMode) {
+      case "status": {
+        const status = ideaStatusRank(a.status) - ideaStatusRank(b.status);
+        if (status !== 0) return status;
+        return a.id.localeCompare(b.id);
+      }
+      case "title":
+        return a.title.localeCompare(b.title);
+      case "updated":
+      case "created":
+        return a.id.localeCompare(b.id);
+      case "id":
+      default:
+        return a.id.localeCompare(b.id);
+    }
+  });
   if (sorted.length === 0) {
     console.log("No ideas found.");
     return;
   }
   console.log(
     formatTable(
-      ["ID", "Title", "Status", "Priority", "Track", "File"],
-      sorted.map((entry) => [
-        entry.id,
-        entry.title,
-        statusColor(entry.status),
-        entry.priority,
-        entry.track,
-        path13.relative(root, entry.filePath)
-      ])
+      columns.map(ideaColumnHeader),
+      sorted.map(
+        (entry) => columns.map((column) => {
+          switch (column) {
+            case "title":
+              return entry.title;
+            case "status":
+              return statusColor(entry.status);
+            case "file":
+              return path15.relative(root, entry.filePath);
+            case "id":
+            default:
+              return entry.id;
+          }
+        })
+      )
     )
   );
   console.log(`
 Total ideas: ${sorted.length}`);
 }
+function listDeliveries() {
+  const root = resolveRepoRoot();
+  const rows = listDeliveryFiles(root).map((filePath) => ({ delivery: parseDeliveryFile2(filePath).delivery, filePath })).map(({ delivery, filePath }) => [
+    delivery.id,
+    delivery.name,
+    statusColor(delivery.status),
+    delivery.target_date ?? "-",
+    path15.relative(root, filePath)
+  ]);
+  if (rows.length === 0) {
+    console.log("No deliveries found.");
+    return;
+  }
+  console.log(formatTable(["ID", "Name", "Status", "Target", "File"], rows));
+}
 function registerListCommand(program) {
   const list = program.command("list").description("List COOP entities");
-  list.command("tasks").description("List tasks").option("--status <status>", "Filter by status").option("--track <track>", "Filter by track").option("--priority <priority>", "Filter by priority").action((options) => {
+  list.command("tasks").description("List tasks").option("--status <status>", "Filter by status").option("--track <track>", "Filter by home/contributing track lens, using `coop use track` if omitted").option("--delivery <delivery>", "Filter by delivery membership, using `coop use delivery` if omitted").option("--priority <priority>", "Filter by effective priority").option("--assignee <assignee>", "Filter by assignee").option("--version <version>", "Filter by fix/released version, using `coop use version` if omitted").option("--mine", "Filter to the current default COOP author").option("--ready", "Only list ready tasks in scored order").option("--sort <sort>", "Sort by id|priority|status|title|updated|created|score").option("--columns <columns>", "Columns: id,title,status,priority,assignee,track,delivery,score,file or all").action((options) => {
     listTasks(options);
   });
-  list.command("ideas").description("List ideas").option("--status <status>", "Filter by status").action((options) => {
+  list.command("ideas").description("List ideas").option("--status <status>", "Filter by status").option("--sort <sort>", "Sort by id|status|title|updated|created").option("--columns <columns>", "Columns: id,title,status,file or all").action((options) => {
     listIdeas(options);
   });
   list.command("alias").description("List aliases").argument("[pattern]", "Wildcard pattern, e.g. PAY*").action((pattern) => {
     listAliasRows(pattern);
   });
-  list.command("deliveries").description("List deliveries (Phase 2)").action(() => {
-    printNotImplemented("coop list deliveries", 2);
+  list.command("deliveries").description("List deliveries").action(() => {
+    listDeliveries();
   });
 }
 
 // src/utils/logger.ts
-import fs9 from "fs";
-import path14 from "path";
-function resolveRepoSafe(start = process.cwd()) {
-  try {
-    return resolveRepoRoot(start);
-  } catch {
-    return path14.resolve(start);
+import fs11 from "fs";
+import path16 from "path";
+function resolveWorkspaceRoot(start = process.cwd()) {
+  let current = path16.resolve(start);
+  while (true) {
+    const gitDir = path16.join(current, ".git");
+    const coopDir2 = coopWorkspaceDir(current);
+    const workspaceConfig = path16.join(coopDir2, "config.yml");
+    const projectsDir = path16.join(coopDir2, "projects");
+    if (fs11.existsSync(gitDir)) {
+      return current;
+    }
+    if (fs11.existsSync(workspaceConfig) || fs11.existsSync(projectsDir)) {
+      return current;
+    }
+    const parent = path16.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
   }
 }
 function resolveCliLogFile(start = process.cwd()) {
-  const root = resolveRepoSafe(start);
-  const workspace = coopWorkspaceDir(root);
-  if (fs9.existsSync(workspace)) {
-    return path14.join(workspace, "logs", "cli.log");
+  const root = resolveWorkspaceRoot(start);
+  if (root) {
+    const workspace = coopWorkspaceDir(root);
+    return path16.join(workspace, "logs", "cli.log");
   }
-  return path14.join(resolveCoopHome(), "logs", "cli.log");
+  return path16.join(resolveCoopHome(), "logs", "cli.log");
 }
 function appendLogEntry(entry, logFile) {
-  fs9.mkdirSync(path14.dirname(logFile), { recursive: true });
-  fs9.appendFileSync(logFile, `${JSON.stringify(entry)}
+  fs11.mkdirSync(path16.dirname(logFile), { recursive: true });
+  fs11.appendFileSync(logFile, `${JSON.stringify(entry)}
 `, "utf8");
 }
 function logCliError(error, start = process.cwd()) {
@@ -4349,8 +5133,8 @@ function parseLogLine(line) {
 }
 function readLastCliLog(start = process.cwd()) {
   const logFile = resolveCliLogFile(start);
-  if (!fs9.existsSync(logFile)) return null;
-  const content = fs9.readFileSync(logFile, "utf8");
+  if (!fs11.existsSync(logFile)) return null;
+  const content = fs11.readFileSync(logFile, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   for (let i = lines.length - 1; i >= 0; i -= 1) {
     const entry = parseLogLine(lines[i] ?? "");
@@ -4384,11 +5168,39 @@ function registerLogCommand(program) {
   });
 }
 
+// src/commands/log-time.ts
+function registerLogTimeCommand(program) {
+  program.command("log-time").description("Append planned or worked time to a task").argument("<id-or-type>", "Task id/alias, or the literal `task` followed by an id").argument("[id]", "Task id when an explicit entity type is provided").requiredOption("--hours <n>", "Hours to log").requiredOption("--kind <kind>", "planned|worked").option("--note <text>", "Optional note").option("--actor <id>", "Actor for the log entry").action((first, second, options) => {
+    const { entity, id } = resolveOptionalEntityArg(first, second, ["task"], "task");
+    if (entity !== "task") {
+      throw new Error("Only task time logging is supported.");
+    }
+    const hours = Number(options.hours);
+    if (!Number.isFinite(hours) || hours < 0) {
+      throw new Error(`Invalid --hours value '${options.hours}'. Expected a non-negative number.`);
+    }
+    if (options.kind !== "planned" && options.kind !== "worked") {
+      throw new Error(`Invalid --kind value '${options.kind}'. Expected planned|worked.`);
+    }
+    const root = resolveRepoRoot();
+    const { filePath, parsed } = loadTaskEntry(root, id);
+    const task = appendTaskTimeLog(
+      parsed.task,
+      options.actor?.trim() || defaultCoopAuthor(root),
+      options.kind,
+      hours,
+      options.note?.trim() || void 0
+    );
+    writeTaskEntry(filePath, parsed, task);
+    console.log(`Logged ${hours}h ${options.kind} on ${task.id}`);
+  });
+}
+
 // src/commands/migrate.ts
-import fs10 from "fs";
-import path15 from "path";
-import { createInterface as createInterface2 } from "readline/promises";
-import { stdin as input2, stdout as output2 } from "process";
+import fs12 from "fs";
+import path17 from "path";
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
 import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager3, migrate_repository, parseYamlFile as parseYamlFile2, writeYamlFile as writeYamlFile4 } from "@kitsy/coop-core";
 var COOP_IGNORE_TEMPLATE2 = `.index/
 logs/
@@ -4405,22 +5217,22 @@ function parseTargetVersion(raw) {
   return parsed;
 }
 function writeIfMissing2(filePath, content) {
-  if (!fs10.existsSync(filePath)) {
-    fs10.writeFileSync(filePath, content, "utf8");
+  if (!fs12.existsSync(filePath)) {
+    fs12.writeFileSync(filePath, content, "utf8");
   }
 }
 function ensureGitignoreEntry2(root, entry) {
-  const gitignorePath = path15.join(root, ".gitignore");
-  if (!fs10.existsSync(gitignorePath)) {
-    fs10.writeFileSync(gitignorePath, `${entry}
+  const gitignorePath = path17.join(root, ".gitignore");
+  if (!fs12.existsSync(gitignorePath)) {
+    fs12.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs10.readFileSync(gitignorePath, "utf8");
+  const content = fs12.readFileSync(gitignorePath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (!lines.includes(entry)) {
     const suffix = content.endsWith("\n") ? "" : "\n";
-    fs10.writeFileSync(gitignorePath, `${content}${suffix}${entry}
+    fs12.writeFileSync(gitignorePath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
@@ -4445,7 +5257,7 @@ function legacyWorkspaceProjectEntries(root) {
     "backlog",
     "plans",
     "releases"
-  ].filter((entry) => fs10.existsSync(path15.join(workspaceDir, entry)));
+  ].filter((entry) => fs12.existsSync(path17.join(workspaceDir, entry)));
 }
 function normalizeProjectId2(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
@@ -4461,7 +5273,7 @@ function parseAliases3(value) {
   );
 }
 async function promptProjectIdentity(defaults, options) {
-  const rl = createInterface2({ input: input2, output: output2 });
+  const rl = createInterface({ input, output });
   const ask2 = async (question, fallback) => {
     try {
       const answer = await rl.question(`${question} [${fallback}]: `);
@@ -4490,11 +5302,11 @@ async function promptProjectIdentity(defaults, options) {
 async function resolveMigrationIdentity(root, options) {
   const existing = readCoopConfig(root);
   const defaults = {
-    projectName: existing.projectName || path15.basename(root),
+    projectName: existing.projectName || path17.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);
+  const interactive = Boolean(options.interactive || !options.yes && input.isTTY && output.isTTY);
   if (interactive) {
     return promptProjectIdentity(defaults, options);
   }
@@ -4510,22 +5322,22 @@ async function migrateWorkspaceLayout(root, options) {
     throw new Error(`Unsupported workspace-layout target '${options.to ?? ""}'. Expected 'v2'.`);
   }
   const workspaceDir = coopWorkspaceDir(root);
-  if (!fs10.existsSync(workspaceDir)) {
+  if (!fs12.existsSync(workspaceDir)) {
     throw new Error("Missing .coop directory. Run 'coop init' first.");
   }
-  const projectsDir = path15.join(workspaceDir, "projects");
+  const projectsDir = path17.join(workspaceDir, "projects");
   const legacyEntries = legacyWorkspaceProjectEntries(root);
-  if (legacyEntries.length === 0 && fs10.existsSync(projectsDir)) {
+  if (legacyEntries.length === 0 && fs12.existsSync(projectsDir)) {
     console.log("[COOP] workspace layout already uses v2.");
     return;
   }
   const identity = await resolveMigrationIdentity(root, options);
   const projectId = identity.projectId;
-  const projectRoot = path15.join(projectsDir, projectId);
-  if (fs10.existsSync(projectRoot) && !options.force) {
-    throw new Error(`Project destination '${path15.relative(root, projectRoot)}' already exists. Re-run with --force.`);
+  const projectRoot = path17.join(projectsDir, projectId);
+  if (fs12.existsSync(projectRoot) && !options.force) {
+    throw new Error(`Project destination '${path17.relative(root, projectRoot)}' already exists. Re-run with --force.`);
   }
-  const changed = legacyEntries.map((entry) => `${path15.join(".coop", entry)} -> ${path15.join(".coop", "projects", projectId, entry)}`);
+  const changed = legacyEntries.map((entry) => `${path17.join(".coop", entry)} -> ${path17.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`);
@@ -4541,21 +5353,21 @@ async function migrateWorkspaceLayout(root, options) {
     console.log("- no files were modified.");
     return;
   }
-  fs10.mkdirSync(projectsDir, { recursive: true });
-  fs10.mkdirSync(projectRoot, { recursive: true });
+  fs12.mkdirSync(projectsDir, { recursive: true });
+  fs12.mkdirSync(projectRoot, { recursive: true });
   for (const entry of legacyEntries) {
-    const source = path15.join(workspaceDir, entry);
-    const destination = path15.join(projectRoot, entry);
-    if (fs10.existsSync(destination)) {
+    const source = path17.join(workspaceDir, entry);
+    const destination = path17.join(projectRoot, entry);
+    if (fs12.existsSync(destination)) {
       if (!options.force) {
-        throw new Error(`Destination '${path15.relative(root, destination)}' already exists.`);
+        throw new Error(`Destination '${path17.relative(root, destination)}' already exists.`);
       }
-      fs10.rmSync(destination, { recursive: true, force: true });
+      fs12.rmSync(destination, { recursive: true, force: true });
     }
-    fs10.renameSync(source, destination);
+    fs12.renameSync(source, destination);
   }
-  const movedConfigPath = path15.join(projectRoot, "config.yml");
-  if (fs10.existsSync(movedConfigPath)) {
+  const movedConfigPath = path17.join(projectRoot, "config.yml");
+  if (fs12.existsSync(movedConfigPath)) {
     const movedConfig = parseYamlFile2(movedConfigPath);
     const nextProject = typeof movedConfig.project === "object" && movedConfig.project !== null ? { ...movedConfig.project } : {};
     nextProject.name = identity.projectName;
@@ -4572,13 +5384,13 @@ async function migrateWorkspaceLayout(root, options) {
   }
   const workspace = readWorkspaceConfig(root);
   writeWorkspaceConfig(root, { ...workspace, version: 2, current_project: projectId });
-  writeIfMissing2(path15.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE2);
-  writeIfMissing2(path15.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE2);
+  writeIfMissing2(path17.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE2);
+  writeIfMissing2(path17.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE2);
   ensureGitignoreEntry2(root, ".coop/logs/");
   ensureGitignoreEntry2(root, ".coop/tmp/");
   const manager = new IndexManager3(projectRoot);
   manager.build_full_index();
-  console.log(`[COOP] migrated workspace to v2 at ${path15.relative(root, projectRoot)}`);
+  console.log(`[COOP] migrated workspace to v2 at ${path17.relative(root, projectRoot)}`);
 }
 function registerMigrateCommand(program) {
   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) => {
@@ -4597,7 +5409,7 @@ function registerMigrateCommand(program) {
     if (report.changed_files.length > 0) {
       console.log("- changed files:");
       for (const filePath of report.changed_files) {
-        console.log(`  - ${path15.relative(root, filePath)}`);
+        console.log(`  - ${path17.relative(root, filePath)}`);
       }
     }
     if (report.dry_run) {
@@ -4691,7 +5503,7 @@ import chalk3 from "chalk";
 import {
   analyze_feasibility,
   analyze_what_if,
-  load_graph as load_graph5,
+  load_graph as load_graph7,
   monte_carlo_forecast,
   TaskPriority as TaskPriority2
 } from "@kitsy/coop-core";
@@ -4755,8 +5567,19 @@ function collectWhatIfModifications(options) {
 }
 async function runPlanDelivery(deliveryName, options) {
   const root = resolveRepoRoot();
-  const graph = load_graph5(coopDir(root));
-  const delivery = resolveDelivery(graph, deliveryName);
+  const context = readWorkingContext(root, resolveCoopHome());
+  const graph = load_graph7(coopDir(root));
+  const resolvedDelivery = deliveryName?.trim() ? { value: deliveryName.trim(), source: "arg" } : resolveContextValueWithSource(void 0, context.delivery, sharedDefault(root, "delivery"));
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({ delivery: resolvedDelivery })) {
+      console.log(line);
+    }
+  }
+  const deliveryRef = resolvedDelivery.value;
+  if (!deliveryRef) {
+    throw new Error("delivery is not set; pass a delivery id or set a default working delivery with `coop use delivery <id>`.");
+  }
+  const delivery = resolveDelivery(graph, deliveryRef);
   const modifications = collectWhatIfModifications(options);
   if (modifications.length > 0) {
     const comparison = analyze_what_if(
@@ -4871,7 +5694,7 @@ async function runPlanDelivery(deliveryName, options) {
 }
 function runPlanCapacity(trackArg, options) {
   const root = resolveRepoRoot();
-  const graph = load_graph5(coopDir(root));
+  const graph = load_graph7(coopDir(root));
   const track = normalizeTrack(trackArg);
   const deliveries = Array.from(graph.deliveries.values()).sort((a, b) => a.id.localeCompare(b.id));
   if (deliveries.length === 0) {
@@ -4911,17 +5734,43 @@ function runPlanCapacity(trackArg, options) {
 }
 function registerPlanCommand(program) {
   const plan = program.command("plan").description("Planning commands");
-  plan.command("delivery").description("Analyze delivery feasibility").argument("<name>", "Delivery id or name").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--monte-carlo", "Run Monte Carlo schedule forecast").option("--iterations <n>", "Monte Carlo iterations (default 10000)").option("--workers <n>", "Worker count hint (default 4)").option("--without <taskId>", "Remove a task and its exclusive dependencies from scope").option("--add-member <trackOrProfile>", "Add one default-capacity member to a human profile").option("--target <date>", "Run scenario with a different target date (YYYY-MM-DD)").option("--set <override>", "Override one field, for example TASK-1:priority=p0").action(async (name, options) => {
-    await runPlanDelivery(name, options);
+  plan.command("delivery").description("Analyze delivery feasibility").argument("[name]", "Delivery id or name").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--monte-carlo", "Run Monte Carlo schedule forecast").option("--iterations <n>", "Monte Carlo iterations (default 10000)").option("--workers <n>", "Worker count hint (default 4)").option("--without <taskId>", "Remove a task and its exclusive dependencies from scope").option("--add-member <trackOrProfile>", "Add one default-capacity member to a human profile").option("--target <date>", "Run scenario with a different target date (YYYY-MM-DD)").option("--set <override>", "Override one field, for example TASK-1:priority=p0").action(async (name, options) => {
+    await runPlanDelivery(name ?? "", options);
   });
   plan.command("capacity").description("Show track capacity utilization across deliveries").argument("<track>", "Track id").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action((track, options) => {
     runPlanCapacity(track, options);
   });
 }
 
+// src/commands/promote.ts
+function registerPromoteCommand(program) {
+  program.command("promote").description("Promote a task within the current working context").argument("<id-or-type>", "Task id/alias, or the literal `task` followed by an id").argument("[id]", "Task id when an explicit entity type is provided").option("--track <track>", "Scoped track context").option("--version <version>", "Scoped version context").action((first, second, options) => {
+    const { entity, id } = resolveOptionalEntityArg(first, second, ["task"], "task");
+    if (entity !== "task") {
+      throw new Error("Only task promotion is supported.");
+    }
+    const root = resolveRepoRoot();
+    const context = readWorkingContext(root, resolveCoopHome());
+    const resolvedTrack = resolveContextValueWithSource(options.track, context.track, sharedDefault(root, "track"));
+    const resolvedVersion = resolveContextValueWithSource(options.version, context.version, sharedDefault(root, "version"));
+    if (isVerboseRequested()) {
+      for (const line of formatResolvedContextMessage({ track: resolvedTrack, version: resolvedVersion })) {
+        console.log(line);
+      }
+    }
+    const { filePath, parsed } = loadTaskEntry(root, id);
+    const task = promoteTaskForContext(parsed.task, {
+      track: resolvedTrack.value,
+      version: resolvedVersion.value
+    });
+    writeTaskEntry(filePath, parsed, task);
+    console.log(`Promoted ${task.id}`);
+  });
+}
+
 // src/commands/project.ts
-import fs11 from "fs";
-import path16 from "path";
+import fs13 from "fs";
+import path18 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
@@ -5030,11 +5879,11 @@ var PROJECT_DIRS = [
   ".index"
 ];
 function ensureDir2(dirPath) {
-  fs11.mkdirSync(dirPath, { recursive: true });
+  fs13.mkdirSync(dirPath, { recursive: true });
 }
 function writeIfMissing3(filePath, content) {
-  if (!fs11.existsSync(filePath)) {
-    fs11.writeFileSync(filePath, content, "utf8");
+  if (!fs13.existsSync(filePath)) {
+    fs13.writeFileSync(filePath, content, "utf8");
   }
 }
 function normalizeProjectId3(value) {
@@ -5042,17 +5891,17 @@ function normalizeProjectId3(value) {
 }
 function createProject(root, projectId, projectName, namingTemplate = DEFAULT_ID_NAMING_TEMPLATE) {
   const workspaceDir = coopWorkspaceDir(root);
-  const projectRoot = path16.join(workspaceDir, "projects", projectId);
-  ensureDir2(path16.join(workspaceDir, "projects"));
+  const projectRoot = path18.join(workspaceDir, "projects", projectId);
+  ensureDir2(path18.join(workspaceDir, "projects"));
   for (const dir of PROJECT_DIRS) {
-    ensureDir2(path16.join(projectRoot, dir));
+    ensureDir2(path18.join(projectRoot, dir));
   }
-  writeIfMissing3(path16.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName, namingTemplate));
-  if (!fs11.existsSync(path16.join(projectRoot, "schema-version"))) {
+  writeIfMissing3(path18.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName, namingTemplate));
+  if (!fs13.existsSync(path18.join(projectRoot, "schema-version"))) {
     write_schema_version2(projectRoot, CURRENT_SCHEMA_VERSION3);
   }
-  writeIfMissing3(path16.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
-  writeIfMissing3(path16.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE2);
+  writeIfMissing3(path18.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
+  writeIfMissing3(path18.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE2);
   return projectRoot;
 }
 function registerProjectCommand(program) {
@@ -5080,7 +5929,7 @@ function registerProjectCommand(program) {
     }
     console.log(`id=${active.id}`);
     console.log(`name=${active.name}`);
-    console.log(`path=${path16.relative(root, active.root)}`);
+    console.log(`path=${path18.relative(root, active.root)}`);
     console.log(`layout=${active.layout}`);
   });
   project.command("use").description("Set the active COOP project").argument("<id>", "Project id").action((id) => {
@@ -5112,26 +5961,127 @@ function registerProjectCommand(program) {
       version: 2,
       current_project: workspace.current_project || projectId
     });
-    console.log(`Created project '${projectId}' at ${path16.relative(root, projectRoot)}`);
+    console.log(`Created project '${projectId}' at ${path18.relative(root, projectRoot)}`);
+  });
+}
+
+// src/commands/prompt.ts
+import fs14 from "fs";
+function buildPayload(root, id) {
+  const { parsed } = loadTaskEntry(root, id);
+  const context = readWorkingContext(root, resolveCoopHome());
+  const task = parsed.task;
+  return {
+    task: {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      type: task.type,
+      track: task.track ?? null,
+      delivery_tracks: task.delivery_tracks ?? [],
+      delivery: task.delivery ?? null,
+      priority: task.priority ?? null,
+      effective_priority: taskEffectivePriority(task, context.track),
+      fix_versions: task.fix_versions ?? [],
+      released_in: task.released_in ?? [],
+      acceptance: task.acceptance ?? [],
+      tests_required: task.tests_required ?? [],
+      refs: {
+        authority: task.origin?.authority_refs ?? [],
+        derived: task.origin?.derived_refs ?? []
+      },
+      execution: task.execution ?? null
+    },
+    working_context: context,
+    body: parsed.body.trim()
+  };
+}
+function renderMarkdown(payload) {
+  const lines = [
+    `# Task Prompt: ${payload.task.id}`,
+    "",
+    `- Title: ${payload.task.title}`,
+    `- Status: ${payload.task.status}`,
+    `- Type: ${payload.task.type}`,
+    `- Home track: ${payload.task.track ?? "-"}`,
+    `- Delivery tracks: ${payload.task.delivery_tracks.length > 0 ? payload.task.delivery_tracks.join(", ") : "-"}`,
+    `- Delivery: ${payload.task.delivery ?? "-"}`,
+    `- Effective priority: ${payload.task.effective_priority}`,
+    `- Fix versions: ${payload.task.fix_versions.length > 0 ? payload.task.fix_versions.join(", ") : "-"}`,
+    `- Released in: ${payload.task.released_in.length > 0 ? payload.task.released_in.join(", ") : "-"}`,
+    "",
+    "## Acceptance",
+    ...payload.task.acceptance.length > 0 ? payload.task.acceptance.map((entry) => `- ${entry}`) : ["- none"],
+    "",
+    "## Tests Required",
+    ...payload.task.tests_required.length > 0 ? payload.task.tests_required.map((entry) => `- ${entry}`) : ["- none"],
+    "",
+    "## Refs",
+    `- Authority: ${payload.task.refs.authority.length > 0 ? payload.task.refs.authority.join(", ") : "-"}`,
+    `- Derived: ${payload.task.refs.derived.length > 0 ? payload.task.refs.derived.join(", ") : "-"}`,
+    "",
+    "## Working Context",
+    `- Track: ${payload.working_context.track ?? "-"}`,
+    `- Delivery: ${payload.working_context.delivery ?? "-"}`,
+    `- Version: ${payload.working_context.version ?? "-"}`,
+    "",
+    "## Task Body",
+    payload.body || "-"
+  ];
+  if (payload.task.execution) {
+    lines.push("", "## Execution Hints", "```json", JSON.stringify(payload.task.execution, null, 2), "```");
+  }
+  return `${lines.join("\n")}
+`;
+}
+function registerPromptCommand(program) {
+  program.command("prompt").description("Generate a manual agent prompt from a task").argument("<id-or-type>", "Task id/alias, or the literal `task` followed by an id").argument("[id]", "Task id when an explicit entity type is provided").option("--format <format>", "text|markdown|json", "text").option("--save <path>", "Write the prompt to a file as well as stdout").action((first, second, options) => {
+    const { entity, id } = resolveOptionalEntityArg(first, second, ["task"], "task");
+    if (entity !== "task") {
+      throw new Error("Only task prompts are supported.");
+    }
+    const root = resolveRepoRoot();
+    const payload = buildPayload(root, id);
+    const format = options.format ?? "text";
+    let output2 = "";
+    if (format === "json") {
+      output2 = `${JSON.stringify(payload, null, 2)}
+`;
+    } else {
+      output2 = renderMarkdown(payload);
+    }
+    if (options.save) {
+      fs14.writeFileSync(options.save, output2, "utf8");
+    }
+    if (isVerboseRequested()) {
+      for (const line of formatResolvedContextMessage({
+        track: payload.working_context.track ? { value: payload.working_context.track, source: "use" } : void 0,
+        delivery: payload.working_context.delivery ? { value: payload.working_context.delivery, source: "use" } : void 0,
+        version: payload.working_context.version ? { value: payload.working_context.version, source: "use" } : void 0
+      })) {
+        console.log(line);
+      }
+    }
+    console.log(output2.trimEnd());
   });
 }
 
 // src/commands/refine.ts
-import fs12 from "fs";
-import path17 from "path";
-import { parseIdeaFile as parseIdeaFile4, parseTaskFile as parseTaskFile10 } from "@kitsy/coop-core";
+import fs15 from "fs";
+import path19 from "path";
+import { parseIdeaFile as parseIdeaFile5, parseTaskFile as parseTaskFile11 } from "@kitsy/coop-core";
 import { create_provider_refinement_client, refine_idea_to_draft, refine_task_to_draft } from "@kitsy/coop-ai";
-function resolveTaskFile(root, idOrAlias) {
+function resolveTaskFile2(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
-  return path17.join(root, ...target.file.split("/"));
+  return path19.join(root, ...target.file.split("/"));
 }
-function resolveIdeaFile2(root, idOrAlias) {
+function resolveIdeaFile3(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "idea");
-  return path17.join(root, ...target.file.split("/"));
+  return path19.join(root, ...target.file.split("/"));
 }
 async function readSupplementalInput(root, options) {
   if (options.inputFile?.trim()) {
-    return fs12.readFileSync(path17.resolve(root, options.inputFile.trim()), "utf8");
+    return fs15.readFileSync(path19.resolve(root, options.inputFile.trim()), "utf8");
   }
   if (options.stdin) {
     return readStdinText();
@@ -5149,11 +6099,11 @@ function loadAuthorityContext(root, refs) {
   for (const ref of refs ?? []) {
     const filePart = extractRefFile(ref);
     if (!filePart) continue;
-    const fullPath = path17.resolve(root, filePart);
-    if (!fs12.existsSync(fullPath) || !fs12.statSync(fullPath).isFile()) continue;
+    const fullPath = path19.resolve(root, filePart);
+    if (!fs15.existsSync(fullPath) || !fs15.statSync(fullPath).isFile()) continue;
     out.push({
       ref,
-      content: fs12.readFileSync(fullPath, "utf8")
+      content: fs15.readFileSync(fullPath, "utf8")
     });
   }
   return out;
@@ -5163,8 +6113,8 @@ function registerRefineCommand(program) {
   refine.command("idea").description("Refine an idea into proposed tasks").argument("<id>", "Idea ID or alias").option("--apply", "Apply the generated draft immediately").option("--output-file <path>", "Write the draft to a specific file").option("--input-file <path>", "Supplemental planning brief").option("--stdin", "Read supplemental planning brief from stdin").action(async (id, options) => {
     const root = resolveRepoRoot();
     const projectDir = ensureCoopInitialized(root);
-    const ideaFile = resolveIdeaFile2(root, id);
-    const parsed = parseIdeaFile4(ideaFile);
+    const ideaFile = resolveIdeaFile3(root, id);
+    const parsed = parseIdeaFile5(ideaFile);
     const supplemental = await readSupplementalInput(root, options);
     const client = create_provider_refinement_client(readCoopConfig(root).raw);
     const refined = await refine_idea_to_draft(
@@ -5187,8 +6137,8 @@ function registerRefineCommand(program) {
   refine.command("task").description("Refine a task into an execution-ready update draft").argument("<id>", "Task ID or alias").option("--apply", "Apply the generated draft immediately").option("--output-file <path>", "Write the draft to a specific file").option("--input-file <path>", "Supplemental planning brief").option("--stdin", "Read supplemental planning brief from stdin").action(async (id, options) => {
     const root = resolveRepoRoot();
     const projectDir = ensureCoopInitialized(root);
-    const taskFile = resolveTaskFile(root, id);
-    const parsed = parseTaskFile10(taskFile);
+    const taskFile = resolveTaskFile2(root, id);
+    const parsed = parseTaskFile11(taskFile);
     const supplemental = await readSupplementalInput(root, options);
     const client = create_provider_refinement_client(readCoopConfig(root).raw);
     const draft = await refine_task_to_draft(
@@ -5216,15 +6166,15 @@ function registerRefineCommand(program) {
     const written = applyRefinementDraft(root, projectDir, draft);
     console.log(`[COOP] applied draft from ${draftInput.source}: ${written.length} task file(s) updated`);
     for (const filePath of written) {
-      console.log(`- ${path17.relative(root, filePath)}`);
+      console.log(`- ${path19.relative(root, filePath)}`);
     }
   });
 }
 
 // src/commands/run.ts
-import fs13 from "fs";
-import path18 from "path";
-import { load_graph as load_graph6, parseTaskFile as parseTaskFile11 } from "@kitsy/coop-core";
+import fs16 from "fs";
+import path20 from "path";
+import { load_graph as load_graph8, parseTaskFile as parseTaskFile12 } from "@kitsy/coop-core";
 import {
   build_contract,
   create_provider_agent_client,
@@ -5233,11 +6183,11 @@ import {
 } from "@kitsy/coop-ai";
 function loadTask(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
-  const taskFile = path18.join(root, ...target.file.split("/"));
-  if (!fs13.existsSync(taskFile)) {
+  const taskFile = path20.join(root, ...target.file.split("/"));
+  if (!fs16.existsSync(taskFile)) {
     throw new Error(`Task file not found: ${target.file}`);
   }
-  return parseTaskFile11(taskFile).task;
+  return parseTaskFile12(taskFile).task;
 }
 function printContract(contract) {
   console.log(JSON.stringify(contract, null, 2));
@@ -5250,7 +6200,7 @@ function registerRunCommand(program) {
   run.command("task").description("Execute a task runbook").argument("<id>", "Task ID or alias").option("--step <step>", "Run a single step by step id").option("--dry-run", "Print contract without executing").action(async (id, options) => {
     const root = resolveRepoRoot();
     const coop = ensureCoopInitialized(root);
-    const graph = load_graph6(coopDir(root));
+    const graph = load_graph8(coopDir(root));
     const task = loadTask(root, id);
     const config = readCoopConfig(root).raw;
     const routedAgent = select_agent(task, config);
@@ -5273,26 +6223,141 @@ function registerRunCommand(program) {
       on_progress: (message) => console.log(`[COOP] ${message}`)
     });
     if (result.status === "failed") {
-      throw new Error(`Run failed: ${result.run.id}. Log: ${path18.relative(root, result.log_path)}`);
+      throw new Error(`Run failed: ${result.run.id}. Log: ${path20.relative(root, result.log_path)}`);
     }
     if (result.status === "paused") {
       console.log(`[COOP] run paused: ${result.run.id}`);
-      console.log(`[COOP] log: ${path18.relative(root, result.log_path)}`);
+      console.log(`[COOP] log: ${path20.relative(root, result.log_path)}`);
       return;
     }
     console.log(`[COOP] run completed: ${result.run.id}`);
-    console.log(`[COOP] log: ${path18.relative(root, result.log_path)}`);
+    console.log(`[COOP] log: ${path20.relative(root, result.log_path)}`);
+  });
+}
+
+// src/commands/search.ts
+import { load_graph as load_graph9, parseDeliveryFile as parseDeliveryFile3, parseIdeaFile as parseIdeaFile6, parseTaskFile as parseTaskFile13 } from "@kitsy/coop-core";
+function haystackForTask(task) {
+  return [
+    task.id,
+    task.title,
+    ...task.aliases ?? [],
+    ...task.tags ?? [],
+    ...task.acceptance ?? [],
+    ...task.tests_required ?? [],
+    ...task.fix_versions ?? [],
+    ...task.released_in ?? [],
+    ...task.delivery_tracks ?? [],
+    ...task.origin?.authority_refs ?? [],
+    ...task.origin?.derived_refs ?? [],
+    ...task.comments?.map((entry) => entry.body) ?? []
+  ].join("\n").toLowerCase();
+}
+function haystackForIdea(idea, body) {
+  return [idea.id, idea.title, ...idea.aliases ?? [], ...idea.tags, ...idea.linked_tasks, body].join("\n").toLowerCase();
+}
+function haystackForDelivery(delivery, body) {
+  return [
+    delivery.id,
+    delivery.name,
+    delivery.status,
+    ...delivery.scope.include ?? [],
+    ...delivery.scope.exclude ?? [],
+    ...delivery.capacity_profiles ?? [],
+    body
+  ].join("\n").toLowerCase();
+}
+function includesQuery(haystack, query) {
+  return haystack.includes(query.toLowerCase());
+}
+function registerSearchCommand(program) {
+  program.command("search").description("Deterministic text search across tasks, ideas, and deliveries").argument("<query>", "Search text").option("--kind <kind>", "task|idea|delivery|all", "all").option("--track <id>", "Filter tasks by home/contributing track").option("--delivery <id>", "Filter tasks by delivery").option("--version <id>", "Filter tasks by fix/released version").option("--status <status>", "Filter by item status").option("--limit <n>", "Maximum result count", "20").option("--open", "Require exactly one match and print only that resolved summary row").action((query, options) => {
+    const root = resolveRepoRoot();
+    const graph = load_graph9(coopDir(root));
+    const deliveryScope = options.delivery ? new Set(graph.deliveries.get(options.delivery)?.scope.include ?? []) : null;
+    const limit = Number(options.limit ?? "20");
+    const rows = [];
+    if (options.kind === "all" || options.kind === "task" || !options.kind) {
+      for (const filePath of listTaskFiles(root)) {
+        const parsed = parseTaskFile13(filePath);
+        const task = parsed.task;
+        if (options.status && task.status !== options.status) continue;
+        if (options.track && task.track !== options.track && !(task.delivery_tracks ?? []).includes(options.track)) {
+          continue;
+        }
+        if (options.delivery && task.delivery !== options.delivery && !deliveryScope?.has(task.id)) continue;
+        if (options.version && !(task.fix_versions ?? []).includes(options.version) && !(task.released_in ?? []).includes(options.version)) {
+          continue;
+        }
+        if (!includesQuery(`${haystackForTask(task)}
+${parsed.body}`, query)) continue;
+        rows.push({
+          kind: "task",
+          id: task.id,
+          title: task.title,
+          status: task.status,
+          extra: task.track ?? "-"
+        });
+      }
+    }
+    if (options.kind === "all" || options.kind === "idea") {
+      for (const filePath of listIdeaFiles(root)) {
+        const parsed = parseIdeaFile6(filePath);
+        if (options.status && parsed.idea.status !== options.status) continue;
+        if (!includesQuery(haystackForIdea(parsed.idea, parsed.body), query)) continue;
+        rows.push({
+          kind: "idea",
+          id: parsed.idea.id,
+          title: parsed.idea.title,
+          status: parsed.idea.status
+        });
+      }
+    }
+    if (options.kind === "all" || options.kind === "delivery") {
+      for (const filePath of listDeliveryFiles(root)) {
+        const parsed = parseDeliveryFile3(filePath);
+        if (options.status && parsed.delivery.status !== options.status) continue;
+        if (!includesQuery(haystackForDelivery(parsed.delivery, parsed.body), query)) continue;
+        rows.push({
+          kind: "delivery",
+          id: parsed.delivery.id,
+          title: parsed.delivery.name,
+          status: parsed.delivery.status,
+          extra: parsed.delivery.target_date ?? "-"
+        });
+      }
+    }
+    rows.sort((a, b) => `${a.kind}:${a.id}`.localeCompare(`${b.kind}:${b.id}`));
+    if (options.open) {
+      if (rows.length === 0) {
+        console.log("No matches found.");
+        return;
+      }
+      if (rows.length !== 1) {
+        throw new Error(`--open requires exactly one match, found ${rows.length}. Narrow the query or add filters.`);
+      }
+    }
+    for (const row of rows.slice(0, Number.isFinite(limit) && limit > 0 ? limit : 20)) {
+      const suffix = row.extra ? ` | ${row.extra}` : "";
+      console.log(`${row.kind}	${row.id}	${row.status}	${row.title}${suffix}`);
+      if (options.open) {
+        break;
+      }
+    }
+    if (rows.length === 0) {
+      console.log("No matches found.");
+    }
   });
 }
 
 // src/server/api.ts
-import fs14 from "fs";
+import fs17 from "fs";
 import http2 from "http";
-import path19 from "path";
+import path21 from "path";
 import {
   analyze_feasibility as analyze_feasibility2,
-  load_graph as load_graph7,
-  parseTaskFile as parseTaskFile12,
+  load_graph as load_graph10,
+  parseTaskFile as parseTaskFile14,
   resolve_external_dependencies
 } from "@kitsy/coop-core";
 function json(res, statusCode, payload) {
@@ -5334,12 +6399,12 @@ function taskSummary(graph, task, external = []) {
   };
 }
 function taskFileById(root, id) {
-  const tasksDir = path19.join(resolveProject(root).root, "tasks");
-  if (!fs14.existsSync(tasksDir)) return null;
-  const entries = fs14.readdirSync(tasksDir, { withFileTypes: true });
+  const tasksDir = path21.join(resolveProject(root).root, "tasks");
+  if (!fs17.existsSync(tasksDir)) return null;
+  const entries = fs17.readdirSync(tasksDir, { withFileTypes: true });
   const target = `${id}.md`.toLowerCase();
   const match = entries.find((entry) => entry.isFile() && entry.name.toLowerCase() === target);
-  return match ? path19.join(tasksDir, match.name) : null;
+  return match ? path21.join(tasksDir, match.name) : null;
 }
 function loadRemoteConfig(root) {
   const raw = readCoopConfig(root).raw;
@@ -5405,7 +6470,7 @@ function createApiServer(root, options = {}) {
       }
       const project = resolveProject(repoRoot);
       const coopPath = project.root;
-      const graph = load_graph7(coopPath);
+      const graph = load_graph10(coopPath);
       const resolutions = await externalResolutions(repoRoot, graph, options);
       if (pathname === "/api/tasks") {
         const tasks = Array.from(graph.nodes.values()).sort((a, b) => a.id.localeCompare(b.id)).map((task) => taskSummary(graph, task, resolutions.get(task.id) ?? []));
@@ -5420,7 +6485,7 @@ function createApiServer(root, options = {}) {
           notFound(res, `Task '${taskId}' not found.`);
           return;
         }
-        const parsed = parseTaskFile12(filePath);
+        const parsed = parseTaskFile14(filePath);
         const task = graph.nodes.get(parsed.task.id) ?? parsed.task;
         json(res, 200, {
           ...workspaceMeta(repoRoot),
@@ -5429,7 +6494,7 @@ function createApiServer(root, options = {}) {
             created: task.created,
             updated: task.updated,
             body: parsed.body,
-            file_path: path19.relative(repoRoot, filePath).replace(/\\/g, "/")
+            file_path: path21.relative(repoRoot, filePath).replace(/\\/g, "/")
           }
         });
         return;
@@ -5517,9 +6582,9 @@ function registerServeCommand(program) {
 }
 
 // src/commands/show.ts
-import fs15 from "fs";
-import path20 from "path";
-import { parseIdeaFile as parseIdeaFile5, parseTaskFile as parseTaskFile13 } from "@kitsy/coop-core";
+import fs18 from "fs";
+import path22 from "path";
+import { parseIdeaFile as parseIdeaFile7 } from "@kitsy/coop-core";
 function stringify(value) {
   if (value === null || value === void 0) return "-";
   if (Array.isArray(value)) return value.length > 0 ? value.join(", ") : "-";
@@ -5537,13 +6602,13 @@ function pushListSection(lines, title, values) {
   }
 }
 function loadComputedFromIndex(root, taskId) {
-  const indexPath = path20.join(ensureCoopInitialized(root), ".index", "tasks.json");
-  if (!fs15.existsSync(indexPath)) {
+  const indexPath = path22.join(ensureCoopInitialized(root), ".index", "tasks.json");
+  if (!fs18.existsSync(indexPath)) {
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs15.readFileSync(indexPath, "utf8"));
+    parsed = JSON.parse(fs18.readFileSync(indexPath, "utf8"));
   } catch {
     return null;
   }
@@ -5578,30 +6643,59 @@ function loadComputedFromIndex(root, taskId) {
   }
   return null;
 }
-function showTask(taskId) {
+function formatTimeSummary(task) {
+  const planned = task.time?.planned_hours;
+  const worked = (task.time?.logs ?? []).filter((entry) => entry.kind === "worked").reduce((sum, entry) => sum + entry.hours, 0);
+  const plannedLogged = (task.time?.logs ?? []).filter((entry) => entry.kind === "planned").reduce((sum, entry) => sum + entry.hours, 0);
+  return `planned_hours=${planned ?? "-"} | planned_logged=${plannedLogged || 0} | worked=${worked || 0}`;
+}
+function showTask(taskId, options = {}) {
   const root = resolveRepoRoot();
-  const coop = ensureCoopInitialized(root);
-  const target = resolveReference(root, taskId, "task");
-  const taskFile = path20.join(root, ...target.file.split("/"));
-  const parsed = parseTaskFile13(taskFile);
+  const context = readWorkingContext(root, resolveCoopHome());
+  const { filePath, parsed } = loadTaskEntry(root, taskId);
   const task = parsed.task;
   const body = parsed.body.trim();
   const computed = loadComputedFromIndex(root, task.id);
+  if (options.compact) {
+    const compactLines = [
+      `Task: ${task.id}`,
+      `Title: ${task.title}`,
+      `Status: ${task.status}`,
+      `Priority: ${task.priority ?? "-"}`,
+      `Effective Priority: ${taskEffectivePriority(task, context.track)}`,
+      `Track: ${task.track ?? "-"}`,
+      `Delivery: ${task.delivery ?? "-"}`,
+      `Assignee: ${task.assignee ?? "-"}`,
+      `Depends On: ${stringify(task.depends_on)}`,
+      `Acceptance: ${task.acceptance && task.acceptance.length > 0 ? task.acceptance.join(" | ") : "-"}`,
+      `Tests Required: ${task.tests_required && task.tests_required.length > 0 ? task.tests_required.join(", ") : "-"}`,
+      `File: ${path22.relative(root, filePath)}`
+    ];
+    console.log(compactLines.join("\n"));
+    return;
+  }
   const lines = [
     `Task: ${task.id}`,
     `Title: ${task.title}`,
     `Status: ${task.status}`,
     `Type: ${task.type}`,
     `Priority: ${task.priority ?? "-"}`,
+    `Effective Priority: ${taskEffectivePriority(task, context.track)}`,
     `Track: ${task.track ?? "-"}`,
+    `Delivery Tracks: ${stringify(task.delivery_tracks)}`,
+    `Priority Context: ${stringify(task.priority_context)}`,
     `Assignee: ${task.assignee ?? "-"}`,
     `Delivery: ${task.delivery ?? "-"}`,
+    `Fix Versions: ${stringify(task.fix_versions)}`,
+    `Released In: ${stringify(task.released_in)}`,
+    `Story Points: ${task.story_points ?? "-"}`,
+    `Time: ${formatTimeSummary(task)}`,
     `Aliases: ${stringify(task.aliases)}`,
     `Depends On: ${stringify(task.depends_on)}`,
     `Tags: ${stringify(task.tags)}`,
     `Created: ${task.created}`,
     `Updated: ${task.updated}`,
-    `File: ${path20.relative(root, taskFile)}`,
+    `File: ${path22.relative(root, filePath)}`,
     ""
   ];
   pushListSection(lines, "Acceptance", task.acceptance);
@@ -5618,15 +6712,25 @@ function showTask(taskId) {
     lines.push(`- Promoted To: ${stringify(task.origin.promoted_to)}`);
     lines.push(`- Snapshot SHA256: ${task.origin.snapshot_sha256 ?? "-"}`);
   }
-  lines.push(
-    "",
-    "Body:",
-    body || "-",
-    "",
-    "Computed:"
-  );
+  lines.push("", "Comments:");
+  if (!task.comments || task.comments.length === 0) {
+    lines.push("- none");
+  } else {
+    for (const comment of task.comments) {
+      lines.push(`- ${comment.at} ${comment.author}: ${comment.body}`);
+    }
+  }
+  lines.push("", "Time Logs:");
+  if (!task.time?.logs || task.time.logs.length === 0) {
+    lines.push("- none");
+  } else {
+    for (const entry of task.time.logs) {
+      lines.push(`- ${entry.at} ${entry.actor} ${entry.kind} ${entry.hours}h${entry.note ? ` (${entry.note})` : ""}`);
+    }
+  }
+  lines.push("", "Body:", body || "-", "", "Computed:");
   if (!computed) {
-    lines.push(`index not built (${path20.relative(root, path20.join(coop, ".index", "tasks.json"))} missing)`);
+    lines.push(`index not built (${path22.relative(root, path22.join(ensureCoopInitialized(root), ".index", "tasks.json"))} missing)`);
   } else {
     for (const [key, value] of Object.entries(computed)) {
       lines.push(`- ${key}: ${stringify(value)}`);
@@ -5634,14 +6738,26 @@ function showTask(taskId) {
   }
   console.log(lines.join("\n"));
 }
-function showIdea(ideaId) {
+function showIdea(ideaId, options = {}) {
   const root = resolveRepoRoot();
-  ensureCoopInitialized(root);
   const target = resolveReference(root, ideaId, "idea");
-  const ideaFile = path20.join(root, ...target.file.split("/"));
-  const parsed = parseIdeaFile5(ideaFile);
+  const ideaFile = path22.join(root, ...target.file.split("/"));
+  const parsed = parseIdeaFile7(ideaFile);
   const idea = parsed.idea;
   const body = parsed.body.trim();
+  if (options.compact) {
+    console.log(
+      [
+        `Idea: ${idea.id}`,
+        `Title: ${idea.title}`,
+        `Status: ${idea.status}`,
+        `Tags: ${stringify(idea.tags)}`,
+        `Linked Tasks: ${stringify(idea.linked_tasks)}`,
+        `File: ${path22.relative(root, ideaFile)}`
+      ].join("\n")
+    );
+    return;
+  }
   const lines = [
     `Idea: ${idea.id}`,
     `Title: ${idea.title}`,
@@ -5652,29 +6768,81 @@ function showIdea(ideaId) {
     `Tags: ${stringify(idea.tags)}`,
     `Linked Tasks: ${stringify(idea.linked_tasks)}`,
     `Created: ${idea.created}`,
-    `File: ${path20.relative(root, ideaFile)}`,
+    `File: ${path22.relative(root, ideaFile)}`,
     "",
     "Body:",
     body || "-"
   ];
   console.log(lines.join("\n"));
 }
+function showDelivery(ref, options = {}) {
+  const root = resolveRepoRoot();
+  const { filePath, delivery, body } = resolveDeliveryEntry(root, ref);
+  if (options.compact) {
+    console.log(
+      [
+        `Delivery: ${delivery.id}`,
+        `Name: ${delivery.name}`,
+        `Status: ${delivery.status}`,
+        `Target Date: ${delivery.target_date ?? "-"}`,
+        `Scope Include: ${delivery.scope.include.length > 0 ? delivery.scope.include.join(", ") : "-"}`,
+        `File: ${path22.relative(root, filePath)}`
+      ].join("\n")
+    );
+    return;
+  }
+  const lines = [
+    `Delivery: ${delivery.id}`,
+    `Name: ${delivery.name}`,
+    `Status: ${delivery.status}`,
+    `Target Date: ${delivery.target_date ?? "-"}`,
+    `Started Date: ${delivery.started_date ?? "-"}`,
+    `Delivered Date: ${delivery.delivered_date ?? "-"}`,
+    `Capacity Profiles: ${delivery.capacity_profiles.length > 0 ? delivery.capacity_profiles.join(", ") : "-"}`,
+    `Scope Include: ${delivery.scope.include.length > 0 ? delivery.scope.include.join(", ") : "-"}`,
+    `Scope Exclude: ${delivery.scope.exclude.length > 0 ? delivery.scope.exclude.join(", ") : "-"}`,
+    `File: ${path22.relative(root, filePath)}`,
+    "",
+    "Body:",
+    body.trim() || "-"
+  ];
+  console.log(lines.join("\n"));
+}
+function showByReference(ref, options = {}) {
+  const root = resolveRepoRoot();
+  try {
+    const resolved = resolveReference(root, ref);
+    if (resolved.type === "task") {
+      showTask(ref, options);
+      return;
+    }
+    showIdea(ref, options);
+    return;
+  } catch {
+    showDelivery(ref, options);
+  }
+}
 function registerShowCommand(program) {
-  const show = program.command("show").description("Show detailed COOP entities");
-  show.command("task").description("Show task details").argument("<id>", "Task ID").action((id) => {
-    showTask(id);
+  const show = program.command("show").description("Show detailed COOP entities").argument("[ref]", "Task, idea, or delivery reference").option("--compact", "Show a smaller summary view").action((ref, options) => {
+    if (!ref?.trim()) {
+      throw new Error("Provide a task, idea, or delivery reference.");
+    }
+    showByReference(ref, options);
   });
-  show.command("idea").description("Show idea details").argument("<id>", "Idea ID").action((id) => {
-    showIdea(id);
+  show.command("task").description("Show task details").argument("<id>", "Task ID").option("--compact", "Show a smaller summary view").action((id, options) => {
+    showTask(id, options);
   });
-  show.command("delivery").description("Show delivery details (Phase 2)").argument("<name>", "Delivery name").action(() => {
-    printNotImplemented("coop show delivery", 2);
+  show.command("idea").description("Show idea details").argument("<id>", "Idea ID").option("--compact", "Show a smaller summary view").action((id, options) => {
+    showIdea(id, options);
+  });
+  show.command("delivery").description("Show delivery details").argument("<id>", "Delivery id or name").option("--compact", "Show a smaller summary view").action((id, options) => {
+    showDelivery(id, options);
   });
 }
 
 // src/commands/status.ts
 import chalk4 from "chalk";
-import { TaskStatus as TaskStatus4, analyze_feasibility as analyze_feasibility3, load_graph as load_graph8 } from "@kitsy/coop-core";
+import { TaskStatus as TaskStatus4, analyze_feasibility as analyze_feasibility3, load_graph as load_graph11 } from "@kitsy/coop-core";
 function countBy(values, keyFn) {
   const out = /* @__PURE__ */ new Map();
   for (const value of values) {
@@ -5695,10 +6863,16 @@ function completionSummary(done, totalTasks) {
   const percent = totalTasks > 0 ? Math.round(done / totalTasks * 100) : 0;
   return `${done}/${totalTasks} (${percent}%)`;
 }
+function workedHours(tasks) {
+  return tasks.reduce(
+    (sum, task) => sum + (task.time?.logs ?? []).filter((entry) => entry.kind === "worked").reduce((entrySum, entry) => entrySum + entry.hours, 0),
+    0
+  );
+}
 function registerStatusCommand(program) {
   program.command("status").description("Project dashboard overview").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action((options) => {
     const root = resolveRepoRoot();
-    const graph = load_graph8(coopDir(root));
+    const graph = load_graph11(coopDir(root));
     const today = options.today ?? /* @__PURE__ */ new Date();
     const tasks = Array.from(graph.nodes.values());
     const tasksByStatus = countBy(tasks, (task) => task.status);
@@ -5718,6 +6892,14 @@ function registerStatusCommand(program) {
     const trackRows = Array.from(tasksByTrack.entries()).sort((a, b) => a[0].localeCompare(b[0])).map(([track, count]) => [track, String(count)]);
     lines.push(formatTable(["Track", "Count"], trackRows));
     lines.push("");
+    const totalStoryPoints = tasks.reduce((sum, task) => sum + (task.story_points ?? 0), 0);
+    const totalPlannedHours = tasks.reduce((sum, task) => sum + (task.time?.planned_hours ?? 0), 0);
+    const totalWorkedHours = workedHours(tasks);
+    lines.push(chalk4.bold("Effort Snapshot"));
+    lines.push(`Story points: ${totalStoryPoints}`);
+    lines.push(`Planned hours: ${totalPlannedHours.toFixed(2)}`);
+    lines.push(`Worked hours: ${totalWorkedHours.toFixed(2)}`);
+    lines.push("");
     lines.push(chalk4.bold("Delivery Health"));
     const deliveryRows = [];
     const riskLines = [];
@@ -5769,8 +6951,8 @@ function registerTransitionCommand(program) {
 }
 
 // src/commands/taskflow.ts
-import path21 from "path";
-import { parseTaskFile as parseTaskFile14 } from "@kitsy/coop-core";
+import path23 from "path";
+import { parseTaskFile as parseTaskFile15 } from "@kitsy/coop-core";
 function normalizeExecutor(value) {
   if (!value?.trim()) return void 0;
   const normalized = value.trim().toLowerCase();
@@ -5807,8 +6989,8 @@ async function claimAndStart(root, taskId, options) {
     }
   }
   const reference = resolveReference(root, taskId, "task");
-  const filePath = path21.join(root, ...reference.file.split("/"));
-  const parsed = parseTaskFile14(filePath);
+  const filePath = path23.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile15(filePath);
   if (parsed.task.status === "in_progress") {
     console.log(`Task ${parsed.task.id} is already in_progress.`);
     return;
@@ -5820,10 +7002,37 @@ async function claimAndStart(root, taskId, options) {
   });
   console.log(`Updated ${transitioned.task.id}: ${transitioned.from} -> ${transitioned.to}`);
 }
+function maybePromote(root, taskId, options) {
+  if (!options.promote) {
+    return;
+  }
+  const context = readWorkingContext(root, resolveCoopHome());
+  const { filePath, parsed } = loadTaskEntry(root, taskId);
+  const promoted = promoteTaskForContext(parsed.task, {
+    track: options.track ?? context.track,
+    version: options.version ?? context.version
+  });
+  writeTaskEntry(filePath, parsed, promoted);
+  console.log(`Promoted ${promoted.id}`);
+}
+function printResolvedSelectionContext(root, options) {
+  if (!isVerboseRequested()) {
+    return;
+  }
+  const context = readWorkingContext(root, resolveCoopHome());
+  for (const line of formatResolvedContextMessage({
+    track: resolveContextValueWithSource(options.track, context.track, sharedDefault(root, "track")),
+    delivery: resolveContextValueWithSource(options.delivery, context.delivery, sharedDefault(root, "delivery")),
+    version: resolveContextValueWithSource(options.version, context.version, sharedDefault(root, "version"))
+  })) {
+    console.log(line);
+  }
+}
 function registerTaskFlowCommands(program) {
   const next = program.command("next").description("Select the next COOP work item");
-  next.command("task").description("Show the top ready task").option("--track <track>", "Filter by track, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action((options) => {
+  next.command("task").description("Show the top ready task").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action((options) => {
     const root = resolveRepoRoot();
+    printResolvedSelectionContext(root, options);
     const selected = selectTopReadyTask(root, {
       track: options.track,
       delivery: options.delivery,
@@ -5833,29 +7042,49 @@ function registerTaskFlowCommands(program) {
     console.log(formatSelectedTask(selected.entry, selected.selection));
   });
   const pick = program.command("pick").description("Pick the next COOP work item");
-  pick.command("task").description("Select the top ready task and move it into active work").option("--track <track>", "Filter by track, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--to <assignee>", "Assign the selected task before starting it").option("--claim", "Assign the selected task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (options) => {
+  pick.command("task").description("Select the top ready task and move it into active work").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the selected task before starting it").option("--claim", "Assign the selected task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
     const root = resolveRepoRoot();
-    const selected = selectTopReadyTask(root, {
+    printResolvedSelectionContext(root, options);
+    const selected = id?.trim() ? {
+      entry: {
+        task: loadTaskEntry(root, id).parsed.task,
+        score: 0,
+        readiness: statusToReadiness(loadTaskEntry(root, id).parsed.task.status),
+        fits_capacity: true,
+        fits_wip: true
+      },
+      selection: {
+        track: options.track,
+        delivery: options.delivery,
+        version: options.version,
+        executor: normalizeExecutor(options.executor),
+        today: options.today
+      }
+    } : selectTopReadyTask(root, {
       track: options.track,
       delivery: options.delivery,
+      version: options.version,
       executor: normalizeExecutor(options.executor),
       today: options.today
     });
     console.log(formatSelectedTask(selected.entry, selected.selection));
+    maybePromote(root, selected.entry.task.id, options);
     await claimAndStart(root, selected.entry.task.id, options);
   });
   const start = program.command("start").description("Start COOP work on a task");
-  start.command("task").description("Start a specific task, or the top ready task if no id is provided").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by track when no id is provided, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery when no id is provided").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid) when no id is provided").option("--today <date>", "Evaluation date (YYYY-MM-DD) when no id is provided").option("--to <assignee>", "Assign the task before starting it").option("--claim", "Assign the task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
+  start.command("task").description("Start a specific task, or the top ready task if no id is provided").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by the home/contributing track lens when no id is provided, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership when no id is provided").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid) when no id is provided").option("--today <date>", "Evaluation date (YYYY-MM-DD) when no id is provided").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the task before starting it").option("--claim", "Assign the task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
     const root = resolveRepoRoot();
+    printResolvedSelectionContext(root, options);
     const taskId = id?.trim() || selectTopReadyTask(root, {
       track: options.track,
       delivery: options.delivery,
+      version: options.version,
       executor: normalizeExecutor(options.executor),
       today: options.today
     }).entry.task.id;
     const reference = resolveReference(root, taskId, "task");
-    const filePath = path21.join(root, ...reference.file.split("/"));
-    const parsed = parseTaskFile14(filePath);
+    const filePath = path23.join(root, ...reference.file.split("/"));
+    const parsed = parseTaskFile15(filePath);
     console.log(
       formatSelectedTask(
         {
@@ -5868,29 +7097,31 @@ function registerTaskFlowCommands(program) {
         {
           track: options.track,
           delivery: options.delivery,
+          version: options.version,
           executor: normalizeExecutor(options.executor),
           today: options.today
         }
       )
     );
+    maybePromote(root, reference.id, options);
     await claimAndStart(root, reference.id, options);
   });
 }
 
 // src/commands/ui.ts
-import fs16 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path24 from "path";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { IndexManager as IndexManager4 } from "@kitsy/coop-core";
 function findPackageRoot(entryPath) {
-  let current = path22.dirname(entryPath);
+  let current = path24.dirname(entryPath);
   while (true) {
-    if (fs16.existsSync(path22.join(current, "package.json"))) {
+    if (fs19.existsSync(path24.join(current, "package.json"))) {
       return current;
     }
-    const parent = path22.dirname(current);
+    const parent = path24.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to locate package root for ${entryPath}.`);
     }
@@ -5939,9 +7170,9 @@ async function startUiServer(repoRoot, host, port, shouldOpen) {
   const project = resolveProject(repoRoot);
   ensureIndex(repoRoot);
   const uiRoot = resolveUiPackageRoot();
-  const requireFromUi = createRequire(path22.join(uiRoot, "package.json"));
+  const requireFromUi = createRequire(path24.join(uiRoot, "package.json"));
   const vitePackageJson = requireFromUi.resolve("vite/package.json");
-  const viteBin = path22.join(path22.dirname(vitePackageJson), "bin", "vite.js");
+  const viteBin = path24.join(path24.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)], {
@@ -5987,12 +7218,205 @@ function registerUiCommand(program) {
   });
 }
 
+// src/commands/update.ts
+import fs20 from "fs";
+import { IdeaStatus as IdeaStatus3, TaskPriority as TaskPriority3, TaskStatus as TaskStatus5, stringifyFrontmatter as stringifyFrontmatter5 } from "@kitsy/coop-core";
+function collect(value, previous = []) {
+  return [...previous, value];
+}
+function unique2(items) {
+  return [...new Set(items.map((item) => item.trim()).filter(Boolean))];
+}
+function removeValues(source, values) {
+  if (!source) return source;
+  const removals = new Set((values ?? []).map((value) => value.trim()));
+  const next = source.filter((entry) => !removals.has(entry));
+  return next.length > 0 ? next : void 0;
+}
+function addValues(source, values) {
+  const next = unique2([...source ?? [], ...values ?? []]);
+  return next.length > 0 ? next : void 0;
+}
+function loadBody(options) {
+  if (options.bodyFile) {
+    return fs20.readFileSync(options.bodyFile, "utf8");
+  }
+  if (options.bodyStdin) {
+    return fs20.readFileSync(0, "utf8");
+  }
+  return void 0;
+}
+function applyTrackPriorityOverrides(task, instructions) {
+  if (!instructions || instructions.length === 0) {
+    return task;
+  }
+  const next = { ...task.priority_context ?? {} };
+  for (const instruction of instructions) {
+    const [track, priority] = instruction.split(":", 2).map((part) => part?.trim() ?? "");
+    if (!track || !priority) {
+      throw new Error(`Invalid --priority-in value '${instruction}'. Expected <track>:<priority>.`);
+    }
+    if (!Object.values(TaskPriority3).includes(priority)) {
+      throw new Error(`Invalid priority '${priority}'. Expected one of ${Object.values(TaskPriority3).join(", ")}.`);
+    }
+    next[track] = priority;
+  }
+  return { ...task, priority_context: Object.keys(next).length > 0 ? next : void 0 };
+}
+function clearTrackPriorityOverrides(task, tracks) {
+  if (!tracks || tracks.length === 0 || !task.priority_context) {
+    return task;
+  }
+  const next = { ...task.priority_context };
+  for (const track of tracks) {
+    delete next[track];
+  }
+  return { ...task, priority_context: Object.keys(next).length > 0 ? next : void 0 };
+}
+function normalizeTaskStatus(status) {
+  const value = status.trim().toLowerCase();
+  if (!Object.values(TaskStatus5).includes(value)) {
+    throw new Error(`Invalid status '${status}'. Expected one of ${Object.values(TaskStatus5).join(", ")}.`);
+  }
+  return value;
+}
+function normalizeTaskPriority(priority) {
+  const value = priority.trim().toLowerCase();
+  if (!Object.values(TaskPriority3).includes(value)) {
+    throw new Error(`Invalid priority '${priority}'. Expected one of ${Object.values(TaskPriority3).join(", ")}.`);
+  }
+  return value;
+}
+function renderTaskPreview(task, body) {
+  return stringifyFrontmatter5(task, body);
+}
+function updateTask(id, options) {
+  const root = resolveRepoRoot();
+  const { filePath, parsed } = loadTaskEntry(root, id);
+  let next = {
+    ...parsed.task,
+    updated: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  };
+  if (options.title) next.title = options.title.trim();
+  if (options.priority) next.priority = normalizeTaskPriority(options.priority);
+  if (options.status) next.status = normalizeTaskStatus(options.status);
+  if (options.assign !== void 0) next.assignee = options.assign.trim() || null;
+  if (options.track) next.track = options.track.trim();
+  if (options.delivery !== void 0) next.delivery = options.delivery.trim() || null;
+  if (options.storyPoints !== void 0) next.story_points = Number(options.storyPoints);
+  if (options.plannedHours !== void 0) next = setTaskPlannedHours(next, Number(options.plannedHours));
+  next = {
+    ...next,
+    delivery_tracks: addValues(removeValues(next.delivery_tracks, options.removeDeliveryTrack), options.addDeliveryTrack),
+    depends_on: addValues(removeValues(next.depends_on, options.removeDep), options.addDep),
+    tags: addValues(removeValues(next.tags, options.removeTag), options.addTag),
+    fix_versions: addValues(removeValues(next.fix_versions, options.removeFixVersion), options.addFixVersion),
+    released_in: addValues(removeValues(next.released_in, options.removeReleasedIn), options.addReleasedIn),
+    acceptance: addValues(removeValues(next.acceptance, options.acceptanceRemove), options.acceptanceAdd),
+    tests_required: addValues(removeValues(next.tests_required, options.testsRemove), options.testsAdd)
+  };
+  next = clearTrackPriorityOverrides(applyTrackPriorityOverrides(next, options.priorityIn), options.clearPriorityIn);
+  validateTaskForWrite(next, filePath);
+  const nextBody = loadBody(options) ?? parsed.body;
+  if (options.dryRun) {
+    console.log(renderTaskPreview(next, nextBody).trimEnd());
+    return;
+  }
+  writeTaskEntry(filePath, parsed, next, nextBody);
+  console.log(`Updated ${next.id}`);
+}
+function updateIdea(id, options) {
+  const root = resolveRepoRoot();
+  const { filePath, parsed } = loadIdeaEntry(root, id);
+  const nextStatus = options.status?.trim().toLowerCase();
+  if (nextStatus && !Object.values(IdeaStatus3).includes(nextStatus)) {
+    throw new Error(`Invalid idea status '${options.status}'. Expected one of ${Object.values(IdeaStatus3).join(", ")}.`);
+  }
+  const next = {
+    ...parsed.idea,
+    title: options.title?.trim() || parsed.idea.title,
+    status: nextStatus || parsed.idea.status,
+    tags: addValues(removeValues(parsed.idea.tags, options.removeTag), options.addTag) ?? [],
+    linked_tasks: addValues(removeValues(parsed.idea.linked_tasks, options.removeLinkedTask), options.addLinkedTask) ?? []
+  };
+  const nextBody = loadBody(options) ?? parsed.body;
+  if (options.dryRun) {
+    console.log(stringifyFrontmatter5(next, nextBody).trimEnd());
+    return;
+  }
+  writeIdeaFile(filePath, parsed, next, nextBody);
+  console.log(`Updated ${next.id}`);
+}
+function registerUpdateCommand(program) {
+  program.command("update").description("Update an existing COOP task or idea").argument("<id-or-type>", "Task or idea id/alias, or an explicit entity type").argument("[id]", "Entity id when an explicit type is provided").option("--title <title>").option("--priority <priority>").option("--status <status>").option("--assign <user>").option("--track <id>", "Set the task home/origin track").option("--delivery <id>", "Set the task primary delivery id").option("--story-points <n>").option("--planned-hours <n>").option("--add-delivery-track <id>", "", collect, []).option("--remove-delivery-track <id>", "", collect, []).option("--priority-in <track:priority>", "", collect, []).option("--clear-priority-in <track>", "", collect, []).option("--add-dep <id>", "", collect, []).option("--remove-dep <id>", "", collect, []).option("--add-tag <tag>", "", collect, []).option("--remove-tag <tag>", "", collect, []).option("--add-fix-version <v>", "", collect, []).option("--remove-fix-version <v>", "", collect, []).option("--add-released-in <v>", "", collect, []).option("--remove-released-in <v>", "", collect, []).option("--acceptance-add <text>", "", collect, []).option("--acceptance-remove <text>", "", collect, []).option("--tests-add <text>", "", collect, []).option("--tests-remove <text>", "", collect, []).option("--add-linked-task <id>", "", collect, []).option("--remove-linked-task <id>", "", collect, []).option("--body-file <path>").option("--body-stdin").option("--dry-run").action((first, second, options) => {
+    let resolved = resolveOptionalEntityArg(first, second, ["task", "idea"], "task");
+    if (!second && resolved.entity === "task") {
+      try {
+        updateTask(resolved.id, options);
+        return;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("not found")) {
+          throw error;
+        }
+        resolved = { entity: "idea", id: first.trim() };
+      }
+    }
+    if (resolved.entity === "idea") {
+      updateIdea(resolved.id, options);
+      return;
+    }
+    updateTask(resolved.id, options);
+  });
+}
+
+// src/commands/use.ts
+function printContext(values) {
+  const track = values.track?.trim() || "unset";
+  const delivery = values.delivery?.trim() || "unset";
+  const version = values.version?.trim() || "unset";
+  console.log("Working Context:");
+  console.log(`- Track: ${track}`);
+  console.log(`- Delivery: ${delivery}`);
+  console.log(`- Version: ${version}`);
+  if (track === "unset" && delivery === "unset" && version === "unset") {
+    console.log("");
+    console.log("Hint: use `coop use track <id>`, `coop use delivery <id>`, or `coop use version <id>`.");
+  }
+}
+function registerUseCommand(program) {
+  const use = program.command("use").description("Manage user-local working defaults for the current COOP project");
+  use.command("show").description("Show the current working context").action(() => {
+    const root = resolveRepoRoot();
+    printContext(readWorkingContext(root, resolveCoopHome()));
+  });
+  use.command("track").description("Set the default working track").argument("<id>", "Track id").action((id) => {
+    const root = resolveRepoRoot();
+    printContext(updateWorkingContext(root, resolveCoopHome(), { track: id }));
+  });
+  use.command("delivery").description("Set the default working delivery").argument("<id>", "Delivery id").action((id) => {
+    const root = resolveRepoRoot();
+    printContext(updateWorkingContext(root, resolveCoopHome(), { delivery: id }));
+  });
+  use.command("version").description("Set the default working version").argument("<id>", "Version label").action((id) => {
+    const root = resolveRepoRoot();
+    printContext(updateWorkingContext(root, resolveCoopHome(), { version: id }));
+  });
+  use.command("clear").description("Clear one working-context key or all of them").argument("[scope]", "track|delivery|version|all", "all").action((scope) => {
+    if (scope !== "track" && scope !== "delivery" && scope !== "version" && scope !== "all") {
+      throw new Error(`Invalid scope '${scope}'. Expected track|delivery|version|all.`);
+    }
+    const root = resolveRepoRoot();
+    printContext(clearWorkingContext(root, resolveCoopHome(), scope));
+  });
+}
+
 // src/commands/view.ts
 import {
   analyze_feasibility as analyze_feasibility4,
   compute_velocity,
   load_completed_runs,
-  load_graph as load_graph9,
+  load_graph as load_graph12,
   simulate_schedule
 } from "@kitsy/coop-core";
 var STATUS_COLUMNS = [
@@ -6055,9 +7479,12 @@ function formatAccuracy(value) {
   if (value == null) return "-";
   return `${Math.round(value * 100)}%`;
 }
+function workedHours2(task) {
+  return (task.time?.logs ?? []).filter((entry) => entry.kind === "worked").reduce((sum, entry) => sum + entry.hours, 0);
+}
 function runKanban() {
   const root = resolveRepoRoot();
-  const graph = load_graph9(coopDir(root));
+  const graph = load_graph12(coopDir(root));
   const grouped = /* @__PURE__ */ new Map();
   for (const status of STATUS_COLUMNS) {
     grouped.set(status, []);
@@ -6089,11 +7516,19 @@ function runKanban() {
 }
 function runTimeline(options) {
   const root = resolveRepoRoot();
-  const graph = load_graph9(coopDir(root));
-  if (!options.delivery) {
-    throw new Error("view timeline requires --delivery <name>.");
+  const context = readWorkingContext(root, resolveCoopHome());
+  const graph = load_graph12(coopDir(root));
+  const resolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery, sharedDefault(root, "delivery"));
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({ delivery: resolvedDelivery })) {
+      console.log(line);
+    }
   }
-  const delivery = resolveDelivery(graph, options.delivery);
+  const deliveryRef = resolvedDelivery.value;
+  if (!deliveryRef) {
+    throw new Error("delivery is not set; pass --delivery <name> or set a default working delivery with `coop use delivery <id>`.");
+  }
+  const delivery = resolveDelivery(graph, deliveryRef);
   const include = new Set(delivery.scope.include);
   for (const id of delivery.scope.exclude) include.delete(id);
   const tasks = Array.from(include).map((id) => graph.nodes.get(id)).filter((task) => Boolean(task));
@@ -6134,7 +7569,7 @@ function runTimeline(options) {
 function runVelocity(options) {
   const root = resolveRepoRoot();
   const coopPath = coopDir(root);
-  const graph = load_graph9(coopPath);
+  const graph = load_graph12(coopPath);
   const config = readCoopConfig(root).raw;
   const scheduling = typeof config.scheduling === "object" && config.scheduling !== null ? config.scheduling : {};
   const configuredWeeks = Number(scheduling.velocity_window_weeks);
@@ -6144,12 +7579,19 @@ function runVelocity(options) {
     today: options.today ?? /* @__PURE__ */ new Date(),
     graph
   });
+  const completedTaskIds = new Set(runs.map((run) => run.task));
+  const completedTasks = Array.from(completedTaskIds).map((taskId) => graph.nodes.get(taskId)).filter((task) => Boolean(task));
+  const storyPointsTotal = completedTasks.reduce((sum, task) => sum + (task.story_points ?? 0), 0);
+  const plannedHoursTotal = completedTasks.reduce((sum, task) => sum + (task.time?.planned_hours ?? 0), 0);
+  const workedHoursTotal = completedTasks.reduce((sum, task) => sum + workedHours2(task), 0);
   console.log(`Velocity: last ${metrics.window_weeks} weeks`);
   console.log(`Trend: ${metrics.trend}`);
   console.log(`Completed runs: ${metrics.completed_runs}`);
   console.log(`Tasks/week: ${metrics.tasks_completed_per_week}`);
   console.log(`Hours/week: ${metrics.hours_delivered_per_week}`);
+  console.log(`Story points/week: ${Number((storyPointsTotal / metrics.window_weeks).toFixed(2))}`);
   console.log(`Accuracy: ${formatAccuracy(metrics.accuracy_ratio)}`);
+  console.log(`Planned vs Worked: ${plannedHoursTotal.toFixed(2)}h planned | ${workedHoursTotal.toFixed(2)}h worked`);
   console.log(`Sparkline: ${sparkline(metrics.points.map((point) => point.completed_tasks))}`);
   console.log("");
   console.log(
@@ -6165,12 +7607,20 @@ function runVelocity(options) {
 }
 function runBurndown(options) {
   const root = resolveRepoRoot();
+  const context = readWorkingContext(root, resolveCoopHome());
   const coopPath = coopDir(root);
-  const graph = load_graph9(coopPath);
-  if (!options.delivery) {
-    throw new Error("view burndown requires --delivery <name>.");
+  const graph = load_graph12(coopPath);
+  const resolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery, sharedDefault(root, "delivery"));
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({ delivery: resolvedDelivery })) {
+      console.log(line);
+    }
+  }
+  const deliveryRef = resolvedDelivery.value;
+  if (!deliveryRef) {
+    throw new Error("delivery is not set; pass --delivery <name> or set a default working delivery with `coop use delivery <id>`.");
   }
-  const delivery = resolveDelivery(graph, options.delivery);
+  const delivery = resolveDelivery(graph, deliveryRef);
   const include = new Set(delivery.scope.include);
   for (const id of delivery.scope.exclude) include.delete(id);
   const scopedTasks = Array.from(include).map((id) => graph.nodes.get(id)).filter((task) => Boolean(task));
@@ -6210,7 +7660,7 @@ function runBurndown(options) {
 }
 function runCapacity(options) {
   const root = resolveRepoRoot();
-  const graph = load_graph9(coopDir(root));
+  const graph = load_graph12(coopDir(root));
   const deliveries = Array.from(graph.deliveries.values()).sort((a, b) => a.id.localeCompare(b.id));
   if (deliveries.length === 0) {
     console.log("No deliveries found.");
@@ -6298,11 +7748,11 @@ function registerWebhookCommand(program) {
 }
 
 // src/merge-driver/merge-driver.ts
-import fs17 from "fs";
+import fs21 from "fs";
 import os2 from "os";
-import path23 from "path";
+import path25 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
-import { stringifyFrontmatter as stringifyFrontmatter4, parseFrontmatterContent as parseFrontmatterContent3, parseYamlContent as parseYamlContent3, stringifyYamlContent as stringifyYamlContent2 } from "@kitsy/coop-core";
+import { stringifyFrontmatter as stringifyFrontmatter6, parseFrontmatterContent as parseFrontmatterContent3, parseYamlContent as parseYamlContent3, stringifyYamlContent as stringifyYamlContent2 } from "@kitsy/coop-core";
 var STATUS_RANK = {
   blocked: 0,
   canceled: 0,
@@ -6359,16 +7809,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 output3 = {};
+  const output2 = {};
   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) {
-      output3[key] = merged;
+      output2[key] = merged;
     }
   }
-  return output3;
+  return output2;
 }
 function mergeTextWithGit(ancestor, ours, theirs) {
   const result = spawnSync5("git", ["merge-file", "-p", ours, ancestor, theirs], {
@@ -6383,33 +7833,33 @@ function mergeTextWithGit(ancestor, ours, theirs) {
   return { ok: false, output: stdout };
 }
 function mergeTaskFile(ancestorPath, oursPath, theirsPath) {
-  const ancestorRaw = fs17.readFileSync(ancestorPath, "utf8");
-  const oursRaw = fs17.readFileSync(oursPath, "utf8");
-  const theirsRaw = fs17.readFileSync(theirsPath, "utf8");
+  const ancestorRaw = fs21.readFileSync(ancestorPath, "utf8");
+  const oursRaw = fs21.readFileSync(oursPath, "utf8");
+  const theirsRaw = fs21.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 = fs17.mkdtempSync(path23.join(os2.tmpdir(), "coop-merge-body-"));
+  const tempDir = fs21.mkdtempSync(path25.join(os2.tmpdir(), "coop-merge-body-"));
   try {
-    const ancestorBody = path23.join(tempDir, "ancestor.md");
-    const oursBody = path23.join(tempDir, "ours.md");
-    const theirsBody = path23.join(tempDir, "theirs.md");
-    fs17.writeFileSync(ancestorBody, ancestor.body, "utf8");
-    fs17.writeFileSync(oursBody, ours.body, "utf8");
-    fs17.writeFileSync(theirsBody, theirs.body, "utf8");
+    const ancestorBody = path25.join(tempDir, "ancestor.md");
+    const oursBody = path25.join(tempDir, "ours.md");
+    const theirsBody = path25.join(tempDir, "theirs.md");
+    fs21.writeFileSync(ancestorBody, ancestor.body, "utf8");
+    fs21.writeFileSync(oursBody, ours.body, "utf8");
+    fs21.writeFileSync(theirsBody, theirs.body, "utf8");
     const mergedBody = mergeTextWithGit(ancestorBody, oursBody, theirsBody);
-    const output3 = stringifyFrontmatter4(mergedFrontmatter, mergedBody.output);
-    fs17.writeFileSync(oursPath, output3, "utf8");
+    const output2 = stringifyFrontmatter6(mergedFrontmatter, mergedBody.output);
+    fs21.writeFileSync(oursPath, output2, "utf8");
     return mergedBody.ok ? 0 : 1;
   } finally {
-    fs17.rmSync(tempDir, { recursive: true, force: true });
+    fs21.rmSync(tempDir, { recursive: true, force: true });
   }
 }
 function mergeDeliveryFile(ancestorPath, oursPath, theirsPath) {
-  const ancestor = parseYamlContent3(fs17.readFileSync(ancestorPath, "utf8"), ancestorPath);
-  const ours = parseYamlContent3(fs17.readFileSync(oursPath, "utf8"), oursPath);
-  const theirs = parseYamlContent3(fs17.readFileSync(theirsPath, "utf8"), theirsPath);
+  const ancestor = parseYamlContent3(fs21.readFileSync(ancestorPath, "utf8"), ancestorPath);
+  const ours = parseYamlContent3(fs21.readFileSync(oursPath, "utf8"), oursPath);
+  const theirs = parseYamlContent3(fs21.readFileSync(theirsPath, "utf8"), theirsPath);
   const oursUpdated = asTimestamp(ours.updated);
   const theirsUpdated = asTimestamp(theirs.updated);
   const base = ancestor;
@@ -6419,7 +7869,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;
   }
-  fs17.writeFileSync(oursPath, stringifyYamlContent2(merged), "utf8");
+  fs21.writeFileSync(oursPath, stringifyYamlContent2(merged), "utf8");
   return 0;
 }
 function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
@@ -6429,12 +7879,38 @@ function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
   return mergeTaskFile(ancestorPath, oursPath, theirsPath);
 }
 
+// src/utils/basic-help.ts
+function renderBasicHelp() {
+  return [
+    "COOP Basics",
+    "",
+    "Day-to-day commands:",
+    "- `coop current`: show working context, active work, and the next ready task",
+    "- `coop use track <id>` / `coop use delivery <id>`: set working scope defaults",
+    "- `coop next task` or `coop pick task`: choose work from COOP",
+    "- `coop show <id>`: inspect a task, idea, or delivery",
+    "- `coop list tasks --track <id>`: browse scoped work",
+    "- `coop update <id> --track <id> --delivery <id>`: update task metadata",
+    '- `coop comment <id> --message "..."`: append a task comment',
+    "- `coop log-time <id> --hours 2 --kind worked`: append time spent",
+    "- `coop review task <id>` / `coop complete task <id>`: move work through lifecycle",
+    "- `coop help-ai --initial-prompt --strict --repo C:/path/to/repo --delivery MVP --command coop.cmd`: hand off COOP context to an agent",
+    "",
+    "Use `coop <command> --help` for detailed flags."
+  ].join("\n");
+}
+
+// src/utils/not-implemented.ts
+function printNotImplemented(command, phase) {
+  console.log(`${command}: Not yet implemented - coming in Phase ${phase}.`);
+}
+
 // src/index.ts
 function readVersion() {
   const currentFile = fileURLToPath2(import.meta.url);
-  const packageJsonPath = path24.resolve(path24.dirname(currentFile), "..", "package.json");
+  const packageJsonPath = path26.resolve(path26.dirname(currentFile), "..", "package.json");
   try {
-    const parsed = JSON.parse(fs18.readFileSync(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(fs22.readFileSync(packageJsonPath, "utf8"));
     return parsed.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -6449,14 +7925,24 @@ function createProgram() {
   const program = new Command();
   program.name("coop");
   program.version(readVersion());
-  program.description("COOP CLI");
+  program.description("COOP CLI for Git-native planning, backlog management, task execution, and delivery workflows.");
   program.option("--verbose", "Print stack traces for command errors");
   program.option("-p, --project <id>", "Select the active COOP project");
+  program.addHelpText("after", `
+Common day-to-day commands:
+  coop basics
+  coop current
+  coop next task
+  coop show <id>
+`);
   registerInitCommand(program);
   registerCreateCommand(program);
+  registerCurrentCommand(program);
   registerAssignCommand(program);
+  registerCommentCommand(program);
   registerAliasCommand(program);
   registerConfigCommand(program);
+  registerDepsCommand(program);
   registerListCommand(program);
   registerShowCommand(program);
   registerTransitionCommand(program);
@@ -6465,19 +7951,28 @@ function createProgram() {
   registerHelpAiCommand(program);
   registerIndexCommand(program);
   registerLogCommand(program);
+  registerLogTimeCommand(program);
   registerLifecycleCommands(program);
   registerMigrateCommand(program);
   registerNamingCommand(program);
   registerPlanCommand(program);
+  registerPromoteCommand(program);
   registerProjectCommand(program);
+  registerPromptCommand(program);
   registerRefineCommand(program);
   registerRunCommand(program);
+  registerSearchCommand(program);
   registerServeCommand(program);
   registerStatusCommand(program);
   registerUiCommand(program);
+  registerUpdateCommand(program);
+  registerUseCommand(program);
   registerViewCommand(program);
   registerWebhookCommand(program);
   registerPhasePlaceholder(program, "ext", 3, "Plugin extension commands");
+  program.command("basics").alias("help-basic").description("Show the small set of COOP commands that cover most day-to-day work").action(() => {
+    console.log(renderBasicHelp());
+  });
   const hooks = program.command("hook");
   hooks.command("pre-commit").option("--repo <path>", "Repository root", process.cwd()).action((options) => {
     const repoRoot = options.repo ?? process.cwd();
@@ -6534,7 +8029,7 @@ async function runCli(argv = process.argv) {
 function isMainModule() {
   const entry = process.argv[1];
   if (!entry) return false;
-  return path24.resolve(entry) === fileURLToPath2(import.meta.url);
+  return path26.resolve(entry) === fileURLToPath2(import.meta.url);
 }
 if (isMainModule()) {
   await runCli(process.argv);