@kitsy/coop 2.1.1 → 2.2.0

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);
@@ -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
@@ -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 output3 = stringifyFrontmatter2({ ...parsed.raw, ...idea }, body);
+  fs3.writeFileSync(filePath, output3, "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, contextValue, sharedDefault2) {
+  if (explicit?.trim()) {
+    return { value: explicit.trim(), source: "arg" };
+  }
+  if (contextValue?.trim()) {
+    return { value: contextValue.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,21 +2124,21 @@ 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";
 
@@ -1907,13 +2157,13 @@ async function ask(question, defaultValue = "") {
 }
 
 // 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 +2207,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 +2228,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 +2273,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 +2311,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 +2326,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 +2410,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 +2428,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 +2446,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 +2472,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 +2568,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,7 +2578,7 @@ 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) {
   return {
@@ -2365,7 +2615,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;
     }
@@ -2383,8 +2633,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 +2706,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];
@@ -2491,19 +2741,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 +2780,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 +2790,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 +2814,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 +2842,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 +2863,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 +2918,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 +2947,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 +2976,66 @@ ${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 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(`Track: ${context.track ?? "-"}`);
+    console.log(`Delivery: ${context.delivery ?? "-"}`);
+    console.log(`Version: ${context.version ?? "-"}`);
+    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(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").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}`);
+    console.log(`Depends On: ${task.depends_on && task.depends_on.length > 0 ? task.depends_on.join(", ") : "-"}`);
+    console.log(`Required By: ${reverse.length > 0 ? reverse.join(", ") : "-"}`);
   });
 }
 
@@ -2737,7 +3044,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
@@ -2790,7 +3098,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 +3113,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 +3140,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 +3170,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 +3215,15 @@ 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 `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: [
@@ -2924,6 +3242,12 @@ var catalog = {
     "coop reopen task <id>",
     "coop transition task <id> <status>"
   ],
+  lifecycle_requirements: [
+    "`coop start task <id>` moves a ready task into `in_progress`.",
+    "`coop review task <id>` requires the task to already be `in_progress` and moves it to `in_review`.",
+    "`coop complete task <id>` requires the task to already be `in_review` and moves it to `done`.",
+    "Do not call `coop complete task <id>` directly from `in_progress` unless COOP explicitly adds that transition later."
+  ],
   unsupported_command_warnings: [
     "Do not invent COOP commands such as `coop complete` when they are not present in `help-ai` output.",
     "If a desired lifecycle action is not represented by an allowed command, state that explicitly instead of paraphrasing.",
@@ -2949,6 +3273,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." }
       ]
@@ -2987,8 +3316,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." },
@@ -3002,8 +3333,18 @@ 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", purpose: "List ready tasks with track and delivery filtering." },
+        { 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 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." },
+        { 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 --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." },
@@ -3014,7 +3355,13 @@ var catalog = {
       name: "Execute And Integrate",
       description: "Hand execution to an AI provider or code-agent CLI and expose COOP through MCP/API.",
       commands: [
+        { usage: "coop help-ai --selection --format markdown", purpose: "Show the focused rules for deterministic task selection and workspace resolution." },
+        { usage: "coop help-ai --state-transitions --format json", purpose: "Show exact lifecycle commands, prerequisites, and warnings against invented transitions." },
+        { usage: "coop help-ai --artifacts --format markdown", purpose: "Show where contract-review, audit, and planning artifacts must be written." },
+        { usage: "coop help-ai --post-execution --format markdown", purpose: "Show what an agent must do after finishing the selected task." },
+        { usage: "coop help-ai --naming --format markdown", purpose: "Show naming guidance when IDs and naming templates matter." },
         { usage: "coop help-ai --initial-prompt --strict --repo C:/path/to/repo --delivery MVP --command coop.cmd", purpose: "Generate a strict agent bootstrap prompt for a repository and delivery." },
+        { usage: "coop help-ai --initial-prompt --rigour balanced --repo C:/path/to/repo --delivery MVP --command coop.cmd", purpose: "Generate the recommended balanced agent bootstrap prompt for day-to-day implementation work." },
         { usage: "coop config ai.provider codex_cli", purpose: "Use the installed Codex CLI as the execution/refinement backend." },
         { usage: "coop config ai.provider claude_cli", purpose: "Use the installed Claude CLI as the execution/refinement backend." },
         { usage: "coop config ai.provider gemini_cli", purpose: "Use the installed Gemini CLI as the execution/refinement backend." },
@@ -3040,12 +3387,124 @@ 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."
+  ],
+  post_execution_rules: [
+    "After completing the currently selected task, stop and wait instead of automatically selecting the next task.",
+    "Do not auto-start a second task in the same run unless the user explicitly asks you to continue.",
+    "If you changed task state in COOP, report the exact command used and the resulting new state before doing anything else."
   ]
 };
+function renderTopicPayload(topic) {
+  if (topic === "state-transitions") {
+    return {
+      topic,
+      allowed_lifecycle_commands: catalog.allowed_lifecycle_commands,
+      lifecycle_requirements: catalog.lifecycle_requirements,
+      warnings: catalog.unsupported_command_warnings
+    };
+  }
+  if (topic === "artifacts") {
+    return {
+      topic,
+      artifact_policy: catalog.artifact_policy
+    };
+  }
+  if (topic === "post-execution") {
+    return {
+      topic,
+      post_execution_rules: catalog.post_execution_rules
+    };
+  }
+  if (topic === "selection") {
+    return {
+      topic,
+      selection_rules: catalog.selection_rules,
+      workspace_rules: catalog.workspace_rules
+    };
+  }
+  return {
+    topic,
+    naming_guidance: [
+      "Use `coop naming` to inspect the current naming template and token behavior.",
+      'Use `coop naming preview "<title>"` before creating a new idea, task, or delivery if predictable IDs matter.',
+      "Use `coop config id.naming ...` to override the default semantic naming template."
+    ]
+  };
+}
+function renderAiHelpTopic(format, topic) {
+  const payload = renderTopicPayload(topic);
+  if (format === "json") {
+    return `${JSON.stringify(payload, null, 2)}
+`;
+  }
+  const lines = [];
+  const bullet = (value) => `- ${value}`;
+  const title = topic.split("-").map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ");
+  lines.push(format === "markdown" ? `# COOP AI Help: ${title}` : `COOP AI Help: ${title}`, "");
+  if (topic === "state-transitions") {
+    lines.push(format === "markdown" ? "## Allowed Lifecycle Commands" : "Allowed Lifecycle Commands");
+    for (const item of catalog.allowed_lifecycle_commands) {
+      lines.push(bullet(`\`${item}\``));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Lifecycle Requirements" : "Lifecycle Requirements");
+    for (const item of catalog.lifecycle_requirements) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Warnings" : "Warnings");
+    for (const item of catalog.unsupported_command_warnings) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "artifacts") {
+    lines.push(bullet(`Config key: \`${catalog.artifact_policy.config_key}\``));
+    lines.push(bullet(`Default dir: \`${catalog.artifact_policy.default_dir}\``));
+    lines.push(bullet(`Required for: ${catalog.artifact_policy.required_for.join(", ")}`));
+    for (const item of catalog.artifact_policy.guidance) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "post-execution") {
+    for (const item of catalog.post_execution_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "selection") {
+    lines.push(format === "markdown" ? "## Selection Rules" : "Selection Rules");
+    for (const item of catalog.selection_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Workspace Rules" : "Workspace Rules");
+    for (const item of catalog.workspace_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  for (const item of renderTopicPayload("naming").naming_guidance) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
 function normalizeRepoPath(repoPath) {
-  return repoPath ? path7.resolve(repoPath) : process.cwd();
+  return repoPath ? path9.resolve(repoPath) : process.cwd();
 }
 function formatSelectionCommand(commandName, delivery, track) {
   if (delivery) {
@@ -3082,22 +3541,33 @@ function renderInitialPrompt(options = {}) {
     "",
     "Rules:",
     "- Learn COOP capabilities from `coop help-ai` before proposing commands.",
+    `- If you are unsure how to pick work, run \`${commandName} help-ai --selection --format markdown\`.`,
+    `- 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") {
     lines.push(
       "- Before mentioning a COOP command, verify the exact command name from `coop help-ai --format json`.",
       "- If a needed workflow is not supported by an exact COOP command, say that explicitly instead of inventing one.",
-      "- Do not switch to another task unless COOP state changes or the user explicitly redirects you."
+      "- Do not switch to another task unless COOP state changes or the user explicitly redirects you.",
+      "- After executing or completing the selected task, stop and wait for user confirmation before picking another task."
     );
   } else if (rigour === "balanced") {
     lines.push(
       "- Prefer exact COOP commands from `coop help-ai --format json` when describing next actions.",
-      "- If COOP lacks a named command for a desired action, state the limitation plainly."
+      "- If COOP lacks a named command for a desired action, state the limitation plainly.",
+      "- After finishing the selected task, report the resulting COOP state before proposing follow-up work."
     );
   } else {
     lines.push("- Keep COOP as the authority for task selection and lifecycle state.");
@@ -3141,6 +3611,11 @@ function renderAiHelp(format) {
     lines.push(bullet(`\`${item}\``));
   }
   lines.push("");
+  lines.push(format === "markdown" ? "## Lifecycle Requirements" : "Lifecycle Requirements");
+  for (const item of catalog.lifecycle_requirements) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
   lines.push(format === "markdown" ? "## Unsupported / Invented Command Warnings" : "Unsupported / Invented Command Warnings");
   for (const item of catalog.unsupported_command_warnings) {
     lines.push(bullet(item));
@@ -3173,6 +3648,11 @@ function renderAiHelp(format) {
     lines.push(bullet(item));
   }
   lines.push("");
+  lines.push(format === "markdown" ? "## Post-Execution Rules" : "Post-Execution Rules");
+  for (const item of catalog.post_execution_rules) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
   return `${lines.join("\n")}
 `;
 }
@@ -3182,7 +3662,7 @@ function renderAiInitialPrompt(options = {}) {
 
 // src/commands/help-ai.ts
 function registerHelpAiCommand(program) {
-  program.command("help-ai").description("Print AI-oriented COOP capability and usage help").option("--format <format>", "Output format: text | json | markdown", "text").option("--initial-prompt", "Print an agent bootstrap prompt instead of the capability catalog").option("--repo <path>", "Repository path to embed in the initial prompt").option("--delivery <delivery>", "Delivery to embed in the initial prompt").option("--track <track>", "Track to embed in the initial prompt").option("--command <name>", "Command name to embed, e.g. coop or coop.cmd", "coop").option("--rigour <level>", "Prompt rigour: strict | balanced | light", "balanced").option("--strict", "Shortcut for --rigour strict").option("--balanced", "Shortcut for --rigour balanced").option("--light", "Shortcut for --rigour light").action((options) => {
+  program.command("help-ai").description("Print AI-oriented COOP capability and usage help").option("--format <format>", "Output format: text | json | markdown", "text").option("--initial-prompt", "Print an agent bootstrap prompt instead of the capability catalog").option("--topic <topic>", "Focused help topic: state-transitions | artifacts | post-execution | selection | naming").option("--state-transitions", "Focused help for lifecycle and state transition usage").option("--artifacts", "Focused help for artifact placement and policy").option("--post-execution", "Focused help for what to do after finishing the selected task").option("--selection", "Focused help for task selection and workspace resolution").option("--naming", "Focused help for naming IDs and naming templates").option("--repo <path>", "Repository path to embed in the initial prompt").option("--delivery <delivery>", "Delivery to embed in the initial prompt").option("--track <track>", "Track to embed in the initial prompt").option("--command <name>", "Command name to embed, e.g. coop or coop.cmd", "coop").option("--rigour <level>", "Prompt rigour: strict | balanced | light", "balanced").option("--strict", "Shortcut for --rigour strict").option("--balanced", "Shortcut for --rigour balanced").option("--light", "Shortcut for --rigour light").action((options) => {
     const format = options.format ?? "text";
     if (format !== "text" && format !== "json" && format !== "markdown") {
       throw new Error(`Unsupported help-ai format '${format}'. Expected text|json|markdown.`);
@@ -3191,6 +3671,7 @@ function registerHelpAiCommand(program) {
     if (rigour !== "strict" && rigour !== "balanced" && rigour !== "light") {
       throw new Error(`Unsupported help-ai rigour '${rigour}'. Expected strict|balanced|light.`);
     }
+    const topic = resolveHelpTopic(options);
     let artifactsDir = "docs";
     const repoRoot = options.repo ? resolveRepoRoot(options.repo) : resolveRepoRoot();
     try {
@@ -3206,13 +3687,43 @@ function registerHelpAiCommand(program) {
       commandName: options.command,
       rigour,
       artifactsDir
-    }) : renderAiHelp(format);
+    }) : topic ? renderAiHelpTopic(format, topic) : renderAiHelp(format);
     console.log(output3.trimEnd());
   });
 }
+function resolveHelpTopic(options) {
+  const requestedTopics = [];
+  if (options.topic) {
+    requestedTopics.push(options.topic);
+  }
+  if (options.stateTransitions) {
+    requestedTopics.push("state-transitions");
+  }
+  if (options.artifacts) {
+    requestedTopics.push("artifacts");
+  }
+  if (options.postExecution) {
+    requestedTopics.push("post-execution");
+  }
+  if (options.selection) {
+    requestedTopics.push("selection");
+  }
+  if (options.naming) {
+    requestedTopics.push("naming");
+  }
+  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 = 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.`);
+  }
+  return topic;
+}
 
 // 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();
@@ -3222,7 +3733,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}`);
   }
@@ -3245,7 +3756,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");
@@ -3261,18 +3772,18 @@ 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) {
@@ -3301,28 +3812,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);
       }
     }
@@ -3341,7 +3852,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) {
@@ -3356,7 +3867,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}`);
     }
@@ -3405,13 +3916,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;
 }
@@ -3435,7 +3946,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) {
@@ -3467,9 +3978,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,
@@ -3477,18 +3988,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 {
@@ -3499,15 +4010,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)."]
@@ -3523,7 +4034,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}`);
@@ -3559,9 +4070,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,
@@ -3569,17 +4080,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 {
@@ -3745,40 +4256,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");
   }
 }
@@ -3864,7 +4375,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",
@@ -3880,23 +4391,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/");
@@ -3906,18 +4417,18 @@ 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:");
@@ -3928,8 +4439,8 @@ function registerInitCommand(program) {
 }
 
 // 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",
@@ -3964,8 +4475,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,
@@ -3989,16 +4500,9 @@ 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 { 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":
@@ -4018,49 +4522,81 @@ function statusColor(status) {
 function sortByIdAsc(items) {
   return [...items].sort((a, b) => a.id.localeCompare(b.id));
 }
-function loadTasks(root) {
+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, sharedDefault(root, "track"));
+  const resolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery, sharedDefault(root, "delivery"));
+  const assignee = options.mine ? defaultCoopAuthor(root) : options.assignee?.trim();
+  const deliveryScope = resolvedDelivery.value ? new Set(graph.deliveries.get(resolvedDelivery.value)?.scope.include ?? []) : null;
+  if (isVerboseRequested()) {
+    for (const line of formatResolvedContextMessage({
+      track: resolvedTrack,
+      delivery: resolvedDelivery
+    })) {
+      console.log(line);
+    }
+  }
+  const readyEntries = options.ready ? schedule_next3(load_graph6(ensureCoopInitialized(root)), {
+    track: resolvedTrack.value,
+    delivery: resolvedDelivery.value
+  }) : null;
+  const readyIds = readyEntries ? new Set(readyEntries.map((entry) => entry.task.id)) : null;
+  const readyOrder = readyEntries ? new Map(readyEntries.map((entry, index) => [entry.task.id, index])) : null;
+  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 (options.version && !(task.fix_versions ?? []).includes(options.version) && !(task.released_in ?? []).includes(options.version)) {
+      return false;
+    }
     return true;
   }).map(({ task, filePath }) => ({
     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 = readyOrder ? [...rows].sort((a, b) => (readyOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (readyOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER)) : sortByIdAsc(rows);
   if (sorted.length === 0) {
     console.log("No tasks found.");
     return;
   }
   console.log(
     formatTable(
-      ["ID", "Title", "Status", "Priority", "Track", "File"],
+      ["ID", "Title", "Status", "Priority", "Track", "Assignee", "Delivery", "File"],
       sorted.map((entry) => [
         entry.id,
         entry.title,
         statusColor(entry.status),
         entry.priority,
         entry.track,
-        path13.relative(root, entry.filePath)
+        entry.assignee,
+        entry.delivery,
+        path15.relative(root, entry.filePath)
       ])
     )
   );
@@ -4095,16 +4631,31 @@ function listIdeas(options) {
         statusColor(entry.status),
         entry.priority,
         entry.track,
-        path13.relative(root, entry.filePath)
+        path15.relative(root, entry.filePath)
       ])
     )
   );
   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 track, using `coop use track` if omitted").option("--delivery <delivery>", "Filter by delivery, 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").action((options) => {
     listTasks(options);
   });
   list.command("ideas").description("List ideas").option("--status <status>", "Filter by status").action((options) => {
@@ -4113,32 +4664,32 @@ function registerListCommand(program) {
   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";
+import fs11 from "fs";
+import path16 from "path";
 function resolveRepoSafe(start = process.cwd()) {
   try {
     return resolveRepoRoot(start);
   } catch {
-    return path14.resolve(start);
+    return path16.resolve(start);
   }
 }
 function resolveCliLogFile(start = process.cwd()) {
   const root = resolveRepoSafe(start);
   const workspace = coopWorkspaceDir(root);
-  if (fs9.existsSync(workspace)) {
-    return path14.join(workspace, "logs", "cli.log");
+  if (fs11.existsSync(workspace)) {
+    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()) {
@@ -4177,8 +4728,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] ?? "");
@@ -4212,9 +4763,37 @@ 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 fs12 from "fs";
+import path17 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import { stdin as input2, stdout as output2 } from "process";
 import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager3, migrate_repository, parseYamlFile as parseYamlFile2, writeYamlFile as writeYamlFile4 } from "@kitsy/coop-core";
@@ -4233,22 +4812,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");
   }
 }
@@ -4273,7 +4852,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, "-");
@@ -4318,7 +4897,7 @@ 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
   };
@@ -4338,22 +4917,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`);
@@ -4369,21 +4948,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;
@@ -4400,13 +4979,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) => {
@@ -4425,7 +5004,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) {
@@ -4519,7 +5098,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";
@@ -4583,8 +5162,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(
@@ -4699,7 +5289,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) {
@@ -4739,17 +5329,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
@@ -4858,11 +5474,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) {
@@ -4870,17 +5486,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) {
@@ -4908,7 +5524,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) => {
@@ -4940,26 +5556,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 output3 = "";
+    if (format === "json") {
+      output3 = `${JSON.stringify(payload, null, 2)}
+`;
+    } else {
+      output3 = renderMarkdown(payload);
+    }
+    if (options.save) {
+      fs14.writeFileSync(options.save, output3, "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(output3.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();
@@ -4977,11 +5694,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;
@@ -4991,8 +5708,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(
@@ -5015,8 +5732,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(
@@ -5044,15 +5761,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,
@@ -5061,11 +5778,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));
@@ -5078,7 +5795,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);
@@ -5101,26 +5818,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) {
@@ -5162,12 +5994,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;
@@ -5233,7 +6065,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) ?? []));
@@ -5248,7 +6080,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),
@@ -5257,7 +6089,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;
@@ -5345,9 +6177,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(", ") : "-";
@@ -5365,13 +6197,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;
   }
@@ -5406,12 +6238,16 @@ function loadComputedFromIndex(root, taskId) {
   }
   return null;
 }
+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) {
   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);
@@ -5421,15 +6257,22 @@ function showTask(taskId) {
     `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);
@@ -5446,15 +6289,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)}`);
@@ -5464,10 +6317,9 @@ function showTask(taskId) {
 }
 function showIdea(ideaId) {
   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();
   const lines = [
@@ -5480,29 +6332,68 @@ 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) {
+  const root = resolveRepoRoot();
+  const { filePath, delivery, body } = resolveDeliveryEntry(root, ref);
+  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) {
+  const root = resolveRepoRoot();
+  try {
+    const resolved = resolveReference(root, ref);
+    if (resolved.type === "task") {
+      showTask(ref);
+      return;
+    }
+    showIdea(ref);
+    return;
+  } catch {
+    showDelivery(ref);
+  }
+}
 function registerShowCommand(program) {
-  const show = program.command("show").description("Show detailed COOP entities");
+  const show = program.command("show").description("Show detailed COOP entities").argument("[ref]", "Task, idea, or delivery reference").action((ref) => {
+    if (!ref?.trim()) {
+      throw new Error("Provide a task, idea, or delivery reference.");
+    }
+    showByReference(ref);
+  });
   show.command("task").description("Show task details").argument("<id>", "Task ID").action((id) => {
     showTask(id);
   });
   show.command("idea").description("Show idea details").argument("<id>", "Idea ID").action((id) => {
     showIdea(id);
   });
-  show.command("delivery").description("Show delivery details (Phase 2)").argument("<name>", "Delivery name").action(() => {
-    printNotImplemented("coop show delivery", 2);
+  show.command("delivery").description("Show delivery details").argument("<id>", "Delivery id or name").action((id) => {
+    showDelivery(id);
   });
 }
 
 // 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) {
@@ -5523,10 +6414,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);
@@ -5546,6 +6443,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 = [];
@@ -5597,8 +6502,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();
@@ -5635,8 +6540,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;
@@ -5648,10 +6553,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) => {
     const root = resolveRepoRoot();
+    printResolvedSelectionContext(root, options);
     const selected = selectTopReadyTask(root, {
       track: options.track,
       delivery: options.delivery,
@@ -5661,29 +6593,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 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("--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 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("--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(
         {
@@ -5696,29 +6648,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}.`);
     }
@@ -5767,9 +6721,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)], {
@@ -5815,12 +6769,197 @@ 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>").option("--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) {
+  console.log(`Track: ${values.track ?? "-"}`);
+  console.log(`Delivery: ${values.delivery ?? "-"}`);
+  console.log(`Version: ${values.version ?? "-"}`);
+}
+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 = [
@@ -5883,9 +7022,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, []);
@@ -5917,11 +7059,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 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 tasks = Array.from(include).map((id) => graph.nodes.get(id)).filter((task) => Boolean(task));
@@ -5962,7 +7112,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);
@@ -5972,12 +7122,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(
@@ -5993,12 +7150,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));
@@ -6038,7 +7203,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.");
@@ -6126,11 +7291,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,
@@ -6211,33 +7376,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 output3 = stringifyFrontmatter6(mergedFrontmatter, mergedBody.output);
+    fs21.writeFileSync(oursPath, output3, "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;
@@ -6247,7 +7412,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) {
@@ -6257,12 +7422,17 @@ function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
   return mergeTaskFile(ancestorPath, oursPath, theirsPath);
 }
 
+// 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";
@@ -6282,9 +7452,12 @@ function createProgram() {
   program.option("-p, --project <id>", "Select the active COOP project");
   registerInitCommand(program);
   registerCreateCommand(program);
+  registerCurrentCommand(program);
   registerAssignCommand(program);
+  registerCommentCommand(program);
   registerAliasCommand(program);
   registerConfigCommand(program);
+  registerDepsCommand(program);
   registerListCommand(program);
   registerShowCommand(program);
   registerTransitionCommand(program);
@@ -6293,16 +7466,22 @@ 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");
@@ -6362,7 +7541,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);