@kitsy/coop 2.2.5 → 2.3.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs22 from "fs";
+import fs23 from "fs";
 import path26 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
@@ -260,7 +260,11 @@ function readNamingTokens(rawConfig) {
         valuesRecord.values.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => normalizeNamingTokenValue(entry))
       )
     ).sort((a, b) => a.localeCompare(b)) : [];
-    tokens[name] = { values };
+    const defaultValue = typeof valuesRecord.default === "string" && valuesRecord.default.trim().length > 0 ? normalizeNamingTokenValue(valuesRecord.default) : void 0;
+    if (defaultValue && values.length > 0 && !values.includes(defaultValue)) {
+      throw new Error(`Naming token '${name}' default '${defaultValue}' is not present in its allowed values.`);
+    }
+    tokens[name] = { values, default: defaultValue };
   }
   return tokens;
 }
@@ -480,7 +484,13 @@ function buildIdContext(root, config, context) {
     NAME_SLUG: slugifyLower(name || "item"),
     RAND: randomToken()
   };
-  for (const [key, value] of Object.entries(fields)) {
+  const resolvedFields = { ...fields };
+  for (const [tokenName, tokenConfig] of Object.entries(config.idTokens)) {
+    if (!resolvedFields[tokenName] && tokenConfig.default) {
+      resolvedFields[tokenName] = tokenConfig.default;
+    }
+  }
+  for (const [key, value] of Object.entries(resolvedFields)) {
     if (!value || !value.trim()) continue;
     const tokenName = normalizeNamingTokenName(key);
     const upper = tokenName.toUpperCase();
@@ -549,7 +559,7 @@ function namingTokensForRoot(root) {
 function requiredCustomNamingTokens(root, entityType) {
   const config = readCoopConfig(root);
   const template = config.idNamingTemplates[entityType];
-  return extractTemplateTokens(template).filter((token) => !isBuiltInNamingToken(token)).map((token) => token.toLowerCase());
+  return extractTemplateTokens(template).filter((token) => !isBuiltInNamingToken(token)).map((token) => token.toLowerCase()).filter((token) => !config.idTokens[token]?.default);
 }
 function generateStableShortId(root, entityType, primaryId, existingShortIds = []) {
   const config = readCoopConfig(root);
@@ -630,7 +640,9 @@ function generateConfiguredId(root, existingIds, context) {
     if (!config.idTokens[token.toLowerCase()]) {
       throw new Error(`Naming template references unknown token <${token}>.`);
     }
-    if (!context.fields || !Object.keys(context.fields).some((key) => normalizeNamingTokenName(key) === token.toLowerCase())) {
+    const normalizedToken = token.toLowerCase();
+    const hasField = context.fields && Object.keys(context.fields).some((key) => normalizeNamingTokenName(key) === normalizedToken);
+    if (!hasField && !config.idTokens[normalizedToken]?.default) {
       throw new Error(`Naming template requires token <${token}>. Pass --${token.toLowerCase()} <value>.`);
     }
   }
@@ -1071,10 +1083,12 @@ function registerAliasCommand(program) {
 }
 
 // src/utils/taskflow.ts
+import fs5 from "fs";
 import path5 from "path";
 import {
   TaskStatus,
   check_permission,
+  resolveTaskTransitions,
   load_auth_config,
   load_graph as load_graph2,
   parseTaskFile as parseTaskFile5,
@@ -1082,6 +1096,7 @@ import {
   schedule_next,
   transition as transition2,
   validateStructural as validateStructural3,
+  writeYamlFile as writeYamlFile4,
   writeTask as writeTask4
 } from "@kitsy/coop-core";
 
@@ -1534,7 +1549,8 @@ async function transitionTaskFromGithub(root, parsed, actor, options = {}) {
   }
   const result = transition(parsed.task, "done", {
     actor,
-    dependencyStatuses: dependencyStatuses(root, parsed.task.id)
+    dependencyStatuses: dependencyStatuses(root, parsed.task.id),
+    config: readCoopConfig(root).raw
   });
   if (!result.success) {
     throw new Error(result.error ?? `Failed to transition task '${parsed.task.id}' to done.`);
@@ -2025,6 +2041,7 @@ function formatResolvedContextMessage(values) {
 }
 
 // src/utils/taskflow.ts
+var UNIVERSAL_RECOVERY_STATES = /* @__PURE__ */ new Set(["todo", "blocked", "canceled"]);
 function configDefaultTrack(root) {
   return sharedDefault(root, "track");
 }
@@ -2137,7 +2154,8 @@ async function assignTaskByReference(root, id, options) {
     throw new Error(`Task '${reference.id}' not found.`);
   }
   const user = options.user?.trim() || defaultCoopAuthor(root);
-  const auth = load_auth_config(readCoopConfig(root).raw);
+  const configView = readCoopConfig(root);
+  const auth = load_auth_config(configView.raw);
   const allowed = check_permission(user, "assign_task", { config: auth });
   if (!allowed) {
     if (!options.force) {
@@ -2210,6 +2228,96 @@ function dependencyStatusMapForTask(taskId, graph) {
   }
   return statuses;
 }
+function isDirectlyAllowed(from, to, transitions) {
+  return transitions.get(from)?.has(to) ?? false;
+}
+function findRecoveryPaths(from, to, transitions) {
+  const queue = [[from]];
+  const paths = [];
+  const bestDepth = /* @__PURE__ */ new Map([[from, 0]]);
+  let shortest = null;
+  while (queue.length > 0) {
+    const currentPath = queue.shift();
+    const current = currentPath[currentPath.length - 1];
+    const depth = currentPath.length - 1;
+    if (shortest !== null && depth >= shortest) {
+      continue;
+    }
+    for (const next of transitions.get(current) ?? []) {
+      if (next !== to && !UNIVERSAL_RECOVERY_STATES.has(next)) {
+        continue;
+      }
+      if (currentPath.includes(next)) {
+        continue;
+      }
+      const nextPath = [...currentPath, next];
+      if (next === to) {
+        shortest = nextPath.length - 1;
+        paths.push(nextPath);
+        continue;
+      }
+      const best = bestDepth.get(next);
+      if (best !== void 0 && best <= depth + 1) {
+        continue;
+      }
+      bestDepth.set(next, depth + 1);
+      queue.push(nextPath);
+    }
+  }
+  return shortest === null ? [] : paths.filter((path27) => path27.length - 1 === shortest);
+}
+function findUniqueRecoveryPath(from, to, transitions) {
+  const paths = findRecoveryPaths(from, to, transitions);
+  if (paths.length === 0) {
+    return null;
+  }
+  if (paths.length > 1) {
+    throw new Error(
+      `No unique safe recovery path for ${from} -> ${to}. Manual sequence candidates: ${paths.map((path27) => path27.join(" -> ")).join(" | ")}.`
+    );
+  }
+  return paths[0];
+}
+function writeTransitionAuditRecord(root, task, command, requestedTarget, pathTaken, actor) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const fileSafeTimestamp = timestamp.replace(/[:.]/g, "-");
+  const auditDir = path5.join(coopDir(root), "audits", "transitions", task.id);
+  fs5.mkdirSync(auditDir, { recursive: true });
+  const filePath = path5.join(auditDir, `${fileSafeTimestamp}.yml`);
+  writeYamlFile4(filePath, {
+    task_id: task.id,
+    actor,
+    requested_command: command,
+    requested_target_status: requestedTarget,
+    actual_transition_path: pathTaken,
+    timestamp,
+    source: "auto_hop_recovery"
+  });
+  return filePath;
+}
+async function emitTransitionPluginEvent(root, coopPath, task, fromStatus, toStatus, actor) {
+  const event = {
+    type: "task.transitioned",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    payload: {
+      task_id: task.id,
+      from: fromStatus,
+      to: toStatus,
+      actor
+    }
+  };
+  const pluginResults = await run_plugins_for_event2(coopPath, event, {
+    graph: load_graph2(coopPath),
+    action_handlers: {
+      github_pr: async (plugin, trigger, action) => executeGitHubPluginAction(root, plugin, trigger, action, task.id)
+    }
+  });
+  for (const pluginResult of pluginResults) {
+    if (!pluginResult.success) {
+      console.warn(`[COOP][plugin:${pluginResult.plugin_id}] ${pluginResult.error ?? "trigger execution failed."}`);
+    }
+  }
+}
 async function transitionTaskByReference(root, id, status, options) {
   const target = status.toLowerCase();
   if (!Object.values(TaskStatus).includes(target)) {
@@ -2223,7 +2331,8 @@ async function transitionTaskByReference(root, id, status, options) {
     throw new Error(`Task '${reference.id}' not found.`);
   }
   const user = options.user?.trim() || defaultCoopAuthor(root);
-  const auth = load_auth_config(readCoopConfig(root).raw);
+  const configView = readCoopConfig(root);
+  const auth = load_auth_config(configView.raw);
   const allowed = check_permission(user, "transition_task", {
     config: auth,
     taskOwner: existing.assignee ?? null
@@ -2238,7 +2347,8 @@ async function transitionTaskByReference(root, id, status, options) {
   const parsed = parseTaskFile5(filePath);
   const result = transition2(parsed.task, target, {
     actor: options.actor ?? user,
-    dependencyStatuses: dependencyStatusMapForTask(reference.id, graph)
+    dependencyStatuses: dependencyStatusMapForTask(reference.id, graph),
+    config: configView.raw
   });
   if (!result.success) {
     throw new Error(result.error ?? "Transition failed.");
@@ -2254,28 +2364,87 @@ ${errors}`);
     raw: parsed.raw,
     filePath
   });
-  const event = {
-    type: "task.transitioned",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    payload: {
-      task_id: result.task.id,
-      from: parsed.task.status,
-      to: result.task.status,
-      actor: options.actor ?? user
-    }
-  };
-  const pluginResults = await run_plugins_for_event2(coopPath, event, {
-    graph: load_graph2(coopPath),
-    action_handlers: {
-      github_pr: async (plugin, trigger, action) => executeGitHubPluginAction(root, plugin, trigger, action, result.task.id)
-    }
+  await emitTransitionPluginEvent(root, coopPath, result.task, parsed.task.status, result.task.status, options.actor ?? user);
+  return { task: result.task, from: parsed.task.status, to: result.task.status };
+}
+async function lifecycleTransitionTaskByReference(root, id, command, targetStatus, options) {
+  const coopPath = coopDir(root);
+  const graph = load_graph2(coopPath);
+  const reference = resolveReference(root, id, "task");
+  const existing = graph.nodes.get(reference.id);
+  if (!existing) {
+    throw new Error(`Task '${reference.id}' not found.`);
+  }
+  const user = options.user?.trim() || defaultCoopAuthor(root);
+  const actor = options.actor?.trim() || user;
+  const configView = readCoopConfig(root);
+  const auth = load_auth_config(configView.raw);
+  const allowed = check_permission(user, "transition_task", {
+    config: auth,
+    taskOwner: existing.assignee ?? null
   });
-  for (const pluginResult of pluginResults) {
-    if (!pluginResult.success) {
-      console.warn(`[COOP][plugin:${pluginResult.plugin_id}] ${pluginResult.error ?? "trigger execution failed."}`);
+  if (!allowed) {
+    if (!options.force) {
+      throw new Error(`User '${user}' is not permitted to transition task '${reference.id}'. Re-run with --force to override.`);
     }
+    console.warn(`[COOP][auth] override: user '${user}' forced transition_task on '${reference.id}'.`);
   }
-  return { task: result.task, from: parsed.task.status, to: result.task.status };
+  const filePath = path5.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile5(filePath);
+  const transitions = resolveTaskTransitions(configView.raw);
+  const fromStatus = parsed.task.status;
+  if (isDirectlyAllowed(fromStatus, targetStatus, transitions)) {
+    const direct = await transitionTaskByReference(root, id, targetStatus, options);
+    return { ...direct };
+  }
+  if (!UNIVERSAL_RECOVERY_STATES.has(targetStatus)) {
+    const direct = await transitionTaskByReference(root, id, targetStatus, options);
+    return { ...direct };
+  }
+  const recoveryPath = findUniqueRecoveryPath(fromStatus, targetStatus, transitions);
+  if (!recoveryPath || recoveryPath.length < 2) {
+    const allowedTargets = Array.from(transitions.get(fromStatus) ?? []);
+    throw new Error(
+      `Invalid transition ${fromStatus} -> ${targetStatus}. Allowed: ${allowedTargets.join(", ") || "none"}.`
+    );
+  }
+  if (recoveryPath.length === 2) {
+    const direct = await transitionTaskByReference(root, id, targetStatus, options);
+    return { ...direct };
+  }
+  let currentTask = parsed.task;
+  const dependencyStatuses2 = dependencyStatusMapForTask(reference.id, graph);
+  for (const nextStatus of recoveryPath.slice(1)) {
+    const result = transition2(currentTask, nextStatus, {
+      actor,
+      dependencyStatuses: dependencyStatuses2,
+      config: configView.raw
+    });
+    if (!result.success) {
+      throw new Error(result.error ?? "Transition failed.");
+    }
+    currentTask = result.task;
+  }
+  const structuralIssues = validateStructural3(currentTask, { filePath });
+  if (structuralIssues.length > 0) {
+    const errors = structuralIssues.map((issue) => `- ${issue.message}`).join("\n");
+    throw new Error(`Updated task is structurally invalid:
+${errors}`);
+  }
+  writeTask4(currentTask, {
+    body: parsed.body,
+    raw: parsed.raw,
+    filePath
+  });
+  const auditPath = writeTransitionAuditRecord(root, currentTask, command, targetStatus, recoveryPath, actor);
+  await emitTransitionPluginEvent(root, coopPath, currentTask, parsed.task.status, currentTask.status, actor);
+  return {
+    task: currentTask,
+    from: parsed.task.status,
+    to: currentTask.status,
+    path: recoveryPath,
+    auditPath
+  };
 }
 
 // src/commands/assign.ts
@@ -2316,6 +2485,124 @@ function registerCommentCommand(program) {
   });
 }
 
+// src/utils/workflow.ts
+import { TaskStatus as TaskStatus2, resolveTaskTransitions as resolveTaskTransitions2, validateResolvedTaskTransitions } from "@kitsy/coop-core";
+function allTaskStatuses() {
+  return Object.values(TaskStatus2);
+}
+function normalizeTaskStatusesCsv(value) {
+  const entries = value.split(",").map((entry) => entry.trim().toLowerCase()).filter(Boolean);
+  return normalizeTaskStatuses(entries);
+}
+function normalizeTaskStatuses(values) {
+  const unique4 = Array.from(new Set(values.map((value) => value.trim().toLowerCase()).filter(Boolean)));
+  for (const entry of unique4) {
+    if (!allTaskStatuses().includes(entry)) {
+      throw new Error(`Invalid task status '${entry}'. Expected one of ${allTaskStatuses().join(", ")}.`);
+    }
+  }
+  return unique4;
+}
+function assertTaskStatus(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!allTaskStatuses().includes(normalized)) {
+    throw new Error(`Invalid task status '${value}'. Expected one of ${allTaskStatuses().join(", ")}.`);
+  }
+  return normalized;
+}
+function currentWorkflowConfig(root) {
+  const rawConfig = readCoopConfig(root).raw;
+  const workflow = typeof rawConfig.workflow === "object" && rawConfig.workflow !== null ? { ...rawConfig.workflow } : {};
+  return { rawConfig, workflow };
+}
+function validateWorkflowConfigOrThrow(config) {
+  const resolved = resolveTaskTransitions2(config);
+  const errors = validateResolvedTaskTransitions(resolved);
+  if (errors.length > 0) {
+    throw new Error(errors.join("\n"));
+  }
+}
+function readEffectiveWorkflowTransitions(root) {
+  return resolveTaskTransitions2(readCoopConfig(root).raw);
+}
+function readWorkflowTransitionOverrides(root) {
+  const workflow = typeof readCoopConfig(root).raw.workflow === "object" && readCoopConfig(root).raw.workflow !== null ? readCoopConfig(root).raw.workflow : {};
+  return { ...workflow.task_transitions ?? {} };
+}
+function setWorkflowTransitionTargets(root, fromStatus, targets) {
+  const from = assertTaskStatus(fromStatus);
+  const normalizedTargets = normalizeTaskStatuses(targets);
+  const { rawConfig, workflow } = currentWorkflowConfig(root);
+  const nextTransitions = { ...workflow.task_transitions ?? {} };
+  nextTransitions[from] = normalizedTargets;
+  const nextWorkflow = {
+    ...workflow,
+    task_transitions: nextTransitions,
+    track_overrides: workflow.track_overrides ?? {}
+  };
+  const nextConfig = {
+    ...rawConfig,
+    workflow: nextWorkflow
+  };
+  validateWorkflowConfigOrThrow(nextConfig);
+  writeCoopConfig(root, nextConfig);
+  return normalizedTargets;
+}
+function addWorkflowTransitionTarget(root, fromStatus, toStatus) {
+  const from = assertTaskStatus(fromStatus);
+  const target = assertTaskStatus(toStatus);
+  const effective = readEffectiveWorkflowTransitions(root);
+  const next = Array.from(/* @__PURE__ */ new Set([...effective.get(from) ?? [], target]));
+  return setWorkflowTransitionTargets(root, from, next);
+}
+function removeWorkflowTransitionTarget(root, fromStatus, toStatus) {
+  const from = assertTaskStatus(fromStatus);
+  const target = assertTaskStatus(toStatus);
+  const effective = readEffectiveWorkflowTransitions(root);
+  const next = Array.from(effective.get(from) ?? []).filter((status) => status !== target);
+  return setWorkflowTransitionTargets(root, from, next);
+}
+function resetWorkflowTransitionStatus(root, fromStatus) {
+  const from = assertTaskStatus(fromStatus);
+  const { rawConfig, workflow } = currentWorkflowConfig(root);
+  const nextTransitions = { ...workflow.task_transitions ?? {} };
+  delete nextTransitions[from];
+  const nextWorkflow = {
+    ...workflow,
+    task_transitions: nextTransitions,
+    track_overrides: workflow.track_overrides ?? {}
+  };
+  const nextConfig = {
+    ...rawConfig,
+    workflow: nextWorkflow
+  };
+  validateWorkflowConfigOrThrow(nextConfig);
+  writeCoopConfig(root, nextConfig);
+}
+function resetAllWorkflowTransitions(root) {
+  const { rawConfig, workflow } = currentWorkflowConfig(root);
+  const nextWorkflow = {
+    ...workflow,
+    task_transitions: {},
+    track_overrides: workflow.track_overrides ?? {}
+  };
+  const nextConfig = {
+    ...rawConfig,
+    workflow: nextWorkflow
+  };
+  validateWorkflowConfigOrThrow(nextConfig);
+  writeCoopConfig(root, nextConfig);
+}
+function formatWorkflowTransitions(transitions, fromStatus) {
+  const lines = [];
+  const statuses = fromStatus ? [assertTaskStatus(fromStatus)] : allTaskStatuses();
+  for (const status of statuses) {
+    const targets = Array.from(transitions.get(status) ?? []);
+    lines.push(`${status}: ${targets.join(", ") || "(none)"}`);
+  }
+  return lines.join("\n");
+}
+
 // src/commands/config.ts
 var INDEX_DATA_KEY = "index.data";
 var ID_NAMING_KEY = "id.naming";
@@ -2325,6 +2612,7 @@ var ARTIFACTS_DIR_KEY = "artifacts.dir";
 var PROJECT_NAME_KEY = "project.name";
 var PROJECT_ID_KEY = "project.id";
 var PROJECT_ALIASES_KEY = "project.aliases";
+var WORKFLOW_TASK_TRANSITIONS_KEY = "workflow.task-transitions";
 var SUPPORTED_KEYS = [
   INDEX_DATA_KEY,
   ID_NAMING_KEY,
@@ -2333,8 +2621,12 @@ var SUPPORTED_KEYS = [
   ARTIFACTS_DIR_KEY,
   PROJECT_NAME_KEY,
   PROJECT_ID_KEY,
-  PROJECT_ALIASES_KEY
+  PROJECT_ALIASES_KEY,
+  WORKFLOW_TASK_TRANSITIONS_KEY
 ];
+function isWorkflowTaskTransitionsKey(keyPath) {
+  return keyPath === WORKFLOW_TASK_TRANSITIONS_KEY || keyPath.startsWith(`${WORKFLOW_TASK_TRANSITIONS_KEY}.`);
+}
 function readIndexDataValue(root) {
   const { indexDataFormat } = readCoopConfig(root);
   return indexDataFormat;
@@ -2368,6 +2660,15 @@ function readProjectAliasesValue(root) {
   const aliases = readCoopConfig(root).projectAliases;
   return aliases.length > 0 ? aliases.join(",") : "(unset)";
 }
+function readWorkflowTaskTransitionsValue(root, keyPath) {
+  const transitions = readWorkflowTransitionOverrides(root);
+  if (keyPath === WORKFLOW_TASK_TRANSITIONS_KEY) {
+    return JSON.stringify(transitions, null, 2);
+  }
+  const fromStatus = keyPath.slice(`${WORKFLOW_TASK_TRANSITIONS_KEY}.`.length);
+  const allowed = Array.isArray(transitions[fromStatus]) ? transitions[fromStatus] : [];
+  return allowed.filter((entry) => typeof entry === "string").join(",");
+}
 function writeIndexDataValue(root, value) {
   const nextValue = value.trim().toLowerCase();
   if (nextValue !== "yaml" && nextValue !== "json") {
@@ -2471,12 +2772,17 @@ function writeProjectAliasesValue(root, value) {
   next.project = projectRaw;
   writeCoopConfig(root, next);
 }
+function writeWorkflowTaskTransitionsValue(root, keyPath, value) {
+  const fromStatus = keyPath.slice(`${WORKFLOW_TASK_TRANSITIONS_KEY}.`.length).trim().toLowerCase();
+  const transitions = normalizeTaskStatusesCsv(value);
+  setWorkflowTransitionTargets(root, fromStatus, transitions);
+}
 function registerConfigCommand(program) {
   program.command("config").description("Read or update COOP config values").argument("<key>", "Config key path").argument("[value]", "Optional value to set").action((key, value) => {
     const root = resolveRepoRoot();
     ensureCoopInitialized(root);
     const keyPath = key.trim();
-    if (!SUPPORTED_KEYS.includes(keyPath)) {
+    if (!SUPPORTED_KEYS.includes(keyPath) && !isWorkflowTaskTransitionsKey(keyPath)) {
       throw new Error(`Unsupported config key '${keyPath}'. Supported keys: ${SUPPORTED_KEYS.join(", ")}`);
     }
     if (value === void 0) {
@@ -2508,6 +2814,10 @@ function registerConfigCommand(program) {
         console.log(`${PROJECT_ALIASES_KEY}=${readProjectAliasesValue(root)}`);
         return;
       }
+      if (isWorkflowTaskTransitionsKey(keyPath)) {
+        console.log(`${keyPath}=${readWorkflowTaskTransitionsValue(root, keyPath)}`);
+        return;
+      }
       console.log(`${AI_MODEL_KEY}=${readAiModelValue(root)}`);
       return;
     }
@@ -2546,26 +2856,31 @@ function registerConfigCommand(program) {
       console.log(`${PROJECT_ALIASES_KEY}=${readProjectAliasesValue(root)}`);
       return;
     }
+    if (isWorkflowTaskTransitionsKey(keyPath)) {
+      writeWorkflowTaskTransitionsValue(root, keyPath, value);
+      console.log(`${keyPath}=${readWorkflowTaskTransitionsValue(root, keyPath)}`);
+      return;
+    }
     writeAiModelValue(root, value);
     console.log(`${AI_MODEL_KEY}=${readAiModelValue(root)}`);
   });
 }
 
 // src/commands/create.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path8 from "path";
 import {
   DeliveryStatus,
   IdeaStatus as IdeaStatus2,
   parseIdeaFile as parseIdeaFile3,
-  TaskStatus as TaskStatus3,
+  TaskStatus as TaskStatus4,
   TaskType as TaskType2,
   check_permission as check_permission2,
   load_auth_config as load_auth_config2,
   parseDeliveryFile as parseDeliveryFile2,
   parseTaskFile as parseTaskFile7,
   parseYamlFile as parseYamlFile3,
-  writeYamlFile as writeYamlFile4,
+  writeYamlFile as writeYamlFile5,
   stringifyFrontmatter as stringifyFrontmatter4,
   writeTask as writeTask6
 } from "@kitsy/coop-core";
@@ -2657,7 +2972,7 @@ async function select(question, choices, defaultIndex = 0) {
 }
 
 // src/utils/idea-drafts.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path6 from "path";
 import {
   IdeaStatus,
@@ -2744,15 +3059,15 @@ function writeIdeaFromDraft(root, projectDir, draft) {
     linked_tasks: draft.linked_tasks ?? []
   };
   const filePath = path6.join(projectDir, "ideas", `${id}.md`);
-  if (fs5.existsSync(filePath)) {
+  if (fs6.existsSync(filePath)) {
     throw new Error(`Idea '${id}' already exists.`);
   }
-  fs5.writeFileSync(filePath, stringifyFrontmatter3(frontmatter, draft.body ?? ""), "utf8");
+  fs6.writeFileSync(filePath, stringifyFrontmatter3(frontmatter, draft.body ?? ""), "utf8");
   return filePath;
 }
 
 // src/utils/refinement-drafts.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 import {
   IndexManager,
@@ -2795,7 +3110,7 @@ function formatIgnoredFieldWarning2(source, context, keys) {
 }
 function refinementDir(projectDir) {
   const dir = path7.join(projectDir, "tmp", "refinements");
-  fs6.mkdirSync(dir, { recursive: true });
+  fs7.mkdirSync(dir, { recursive: true });
   return dir;
 }
 function draftPath(projectDir, mode, sourceId) {
@@ -2833,8 +3148,8 @@ function assignCreateProposalIds(root, draft) {
 }
 function writeDraftFile(root, projectDir, draft, outputFile) {
   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");
+  fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+  fs7.writeFileSync(filePath, stringifyYamlContent(draft), "utf8");
   return filePath;
 }
 function printDraftSummary(root, draft, filePath) {
@@ -2966,7 +3281,7 @@ function applyCreateProposal(projectDir, proposal) {
     throw new Error(`Create proposal '${proposal.title}' is missing id.`);
   }
   const filePath = path7.join(projectDir, "tasks", `${id}.md`);
-  if (fs6.existsSync(filePath)) {
+  if (fs7.existsSync(filePath)) {
     throw new Error(`Task '${id}' already exists.`);
   }
   const task = taskFromProposal({ ...proposal, id }, (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
@@ -3028,7 +3343,7 @@ function applyRefinementDraft(root, projectDir, draft) {
 async function readDraftContent(root, options) {
   if (options.fromFile?.trim()) {
     const filePath = path7.resolve(root, options.fromFile.trim());
-    return { content: fs6.readFileSync(filePath, "utf8"), source: filePath };
+    return { content: fs7.readFileSync(filePath, "utf8"), source: filePath };
   }
   if (options.stdin) {
     return { content: await readStdinText(), source: "<stdin>" };
@@ -3229,7 +3544,7 @@ function updateIdeaLinkedTasks(filePath, idea, raw, body, linked) {
     ...raw,
     linked_tasks: next
   };
-  fs7.writeFileSync(filePath, stringifyFrontmatter4(nextRaw, body), "utf8");
+  fs8.writeFileSync(filePath, stringifyFrontmatter4(nextRaw, body), "utf8");
 }
 function makeTaskDraft(input2) {
   return {
@@ -3247,7 +3562,7 @@ function makeTaskDraft(input2) {
 }
 function registerCreateCommand(program) {
   const create = program.command("create").description("Create COOP entities");
-  create.command("task").description("Create a task").allowUnknownOption().allowExcessArguments().argument("[title]", "Task title").option("--id <id>", "Task id").option("--from <idea>", "Create task(s) from an idea id/alias").option("--ai", "Use AI-assisted decomposition for --from").option("--title <title>", "Task title").option("--type <type>", `Task type (${Object.values(TaskType2).join(", ")})`).option("--status <status>", `Task status (${Object.values(TaskStatus3).join(", ")})`).option("--track <track>", "Home/origin track id").option("--delivery <delivery>", "Primary delivery id").option("--priority <priority>", "Task priority").option("--body <body>", "Markdown body").option("--acceptance <text>", "Acceptance criterion; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--tests-required <text>", "Required test; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--authority-ref <ref>", "Authority document reference; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--derived-ref <ref>", "Derived planning document reference; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--from-file <path>", "Create task(s) from task draft/refinement draft file").option("--stdin", "Read task draft/refinement draft from stdin").option("--interactive", "Prompt for optional fields").action(async (titleArg, options) => {
+  create.command("task").description("Create a task").allowUnknownOption().allowExcessArguments().argument("[title]", "Task title").option("--id <id>", "Task id").option("--from <idea>", "Create task(s) from an idea id/alias").option("--ai", "Use AI-assisted decomposition for --from").option("--title <title>", "Task title").option("--type <type>", `Task type (${Object.values(TaskType2).join(", ")})`).option("--status <status>", `Task status (${Object.values(TaskStatus4).join(", ")})`).option("--track <track>", "Home/origin track id").option("--delivery <delivery>", "Primary delivery id").option("--priority <priority>", "Task priority").option("--body <body>", "Markdown body").option("--acceptance <text>", "Acceptance criterion; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--tests-required <text>", "Required test; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--authority-ref <ref>", "Authority document reference; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--derived-ref <ref>", "Derived planning document reference; repeat the flag to add multiple entries", collectRepeatedValue, []).option("--from-file <path>", "Create task(s) from task draft/refinement draft file").option("--stdin", "Read task draft/refinement draft from stdin").option("--interactive", "Prompt for optional fields").action(async (titleArg, options) => {
     const root = resolveRepoRoot();
     const coop = ensureCoopInitialized(root);
     const interactive = Boolean(options.interactive);
@@ -3509,7 +3824,7 @@ function registerCreateCommand(program) {
       throw new Error(`Invalid idea status '${status}'.`);
     }
     const filePath = path8.join(coop, "ideas", `${id}.md`);
-    fs7.writeFileSync(filePath, stringifyFrontmatter4(frontmatter, body), "utf8");
+    fs8.writeFileSync(filePath, stringifyFrontmatter4(frontmatter, body), "utf8");
     console.log(`Created idea: ${path8.relative(root, filePath)}`);
   });
   create.command("track").description("Create a track").allowUnknownOption().allowExcessArguments().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) => {
@@ -3566,7 +3881,7 @@ function registerCreateCommand(program) {
       }
     };
     const filePath = path8.join(coop, "tracks", `${id}.yml`);
-    writeYamlFile4(filePath, payload);
+    writeYamlFile5(filePath, payload);
     console.log(`Created track: ${path8.relative(root, filePath)}`);
   });
   create.command("delivery").description("Create a delivery").allowUnknownOption().allowExcessArguments().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) => {
@@ -3700,7 +4015,7 @@ function registerCreateCommand(program) {
       }
     };
     const filePath = path8.join(coop, "deliveries", `${id}.yml`);
-    writeYamlFile4(filePath, payload);
+    writeYamlFile5(filePath, payload);
     console.log(`Created delivery: ${path8.relative(root, filePath)}`);
   });
 }
@@ -3991,10 +4306,12 @@ var catalog = {
   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.",
+    "When a command accepts an entity reference, the entity noun is optional: `coop show PM-100` and `coop show task PM-100` are equivalent. Keep the explicit noun only when it clarifies intent or when no shorthand exists yet.",
     "Before assigning `track` or `delivery` values to tasks, inspect or create named entities with `coop list tracks`, `coop list deliveries`, `coop create track`, and `coop create delivery`.",
     "Track and delivery references accept exact ids, stable short ids, and unique case-insensitive names.",
-    "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 graph next --delivery <delivery>` or `coop next` to choose work. Do not reprioritize outside COOP unless the user explicitly overrides it.",
     "Commands resolve selection scope from: explicit CLI arg, then `coop use` working context, then shared project defaults.",
+    "Use `coop list tasks --all` to ignore current `coop use` task-scope defaults temporarily while browsing the full backlog.",
     "Use `--track` for the workstream lens (home track or delivery_tracks). Use `--delivery` for release/scope membership.",
     "Use `coop show <id>` or `coop show task <id>` before implementation to read acceptance, tests_required, dependencies, origin refs, and task metadata.",
     "Use `coop refine idea` or `coop refine task` when the task lacks planning detail. COOP owns canonical writes; agents should not edit `.coop` files directly."
@@ -4006,20 +4323,33 @@ var catalog = {
     "Canonical storage is under `.coop/projects/<project.id>/...`."
   ],
   allowed_lifecycle_commands: [
+    "coop start <id>",
     "coop start task <id>",
+    "coop review <id>",
     "coop review task <id>",
+    "coop complete <id>",
     "coop complete task <id>",
+    "coop block <id>",
     "coop block task <id>",
+    "coop unblock <id>",
     "coop unblock task <id>",
+    "coop cancel <id>",
     "coop cancel task <id>",
+    "coop reopen <id>",
     "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."
+    "`coop start <id>` and `coop start task <id>` move a ready task into `in_progress`.",
+    "`coop start <id>` can also resume a blocked task directly into `in_progress` when `blocked -> in_progress` is allowed; that is a direct transition, not an auto-hop.",
+    "`coop review <id>` / `coop review task <id>` require the task to already be `in_progress` and move it to `in_review`.",
+    "`coop complete <id>` / `coop complete task <id>` requires the task to already be `in_review` and moves it to `done`.",
+    "`coop block <id>`, `coop unblock <id>`, `coop cancel <id>`, and `coop reopen <id>` target universal recovery states by default.",
+    "`coop unblock <id>` always means `blocked -> todo`; it does not restore a previous status.",
+    "Actual multi-step recovery auto-hops write a transition audit record; ordinary direct transitions do not.",
+    "Task status transitions can be customized per workspace through `coop workflow transitions ...` or `workflow.task_transitions` in COOP config.",
+    "Do not call `coop complete task <id>` directly from `in_progress` unless COOP explicitly adds that transition later.",
+    "Commands without an entity reference, such as `coop next`, remain task-first workflow surfaces rather than generic entity actions."
   ],
   unsupported_command_warnings: [
     "Do not invent COOP commands such as `coop complete` when they are not present in `help-ai` output.",
@@ -4061,7 +4391,13 @@ var catalog = {
         { usage: "coop naming token create proj", purpose: "Create a custom naming token." },
         { usage: "coop naming token remove proj", purpose: "Delete a custom naming token." },
         { usage: "coop naming token value add proj UX", purpose: "Register an allowed value for a naming token." },
-        { usage: "coop naming token value remove proj UX", purpose: "Remove an allowed value from a naming token." }
+        { usage: "coop naming token value remove proj UX", purpose: "Remove an allowed value from a naming token." },
+        { usage: "coop naming token default set proj UX", purpose: "Set a default value for a custom naming token so create/preview can omit the CLI flag." },
+        { usage: "coop naming token default clear proj", purpose: "Clear a default custom-token value." },
+        { usage: "coop config workflow.task-transitions.in_review done,todo,blocked", purpose: "Customize allowed task transitions for one source status." },
+        { usage: "coop workflow transitions show", purpose: "Show the effective task transition map for the workspace." },
+        { usage: "coop workflow transitions add blocked in_progress", purpose: "Add a task transition edge without editing config by hand." },
+        { usage: "coop workflow transitions reset --all", purpose: "Reset all transition overrides back to the built-in defaults." }
       ]
     },
     {
@@ -4100,18 +4436,19 @@ var catalog = {
       name: "Select And Start",
       description: "Pick the next ready task and move it into execution.",
       commands: [
-        { usage: "coop next task", purpose: "Show the top ready task using the default track or full workspace context." },
+        { usage: "coop next", 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 --promote --claim --actor dev1 --user lead-user", purpose: "Start a specific task or the top ready task if no id is provided." },
+        { usage: "coop pick 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 --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 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; the promoted task moves to the top of that selection lens." },
-        { 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." },
-        { usage: "coop unblock task PM-101", purpose: "Move a blocked task back to todo." },
-        { usage: "coop cancel task PM-101", purpose: "Cancel a task." },
-        { usage: "coop reopen task PM-101", purpose: "Move a canceled task back to todo." }
+        { usage: "coop review PM-101", purpose: "Move an in-progress task into in_review using a DX-friendly verb." },
+        { usage: "coop complete PM-101", purpose: "Move a task in review into done using a DX-friendly verb." },
+        { usage: "coop block PM-101", purpose: "Mark a task as blocked." },
+        { usage: "coop unblock PM-101", purpose: "Move a blocked task back to todo." },
+        { usage: "coop cancel PM-101", purpose: "Cancel a task." },
+        { usage: "coop reopen PM-101", purpose: "Move a canceled task back to todo." },
+        { usage: "coop workflow transitions show blocked", purpose: "Inspect the currently effective allowed targets for a source status." }
       ]
     },
     {
@@ -4119,6 +4456,8 @@ 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 --completed", purpose: "List done tasks with a convenience flag instead of `--status done`." },
+        { usage: "coop list tasks --all", purpose: "List tasks across all tracks/deliveries/versions without applying current `coop use` defaults." },
         { usage: "coop list tracks", purpose: "List valid named tracks." },
         { usage: "coop list deliveries", purpose: "List valid named deliveries." },
         { usage: "coop list tasks --track MVP --delivery MVP --ready --columns id,title,p,assignee,score", purpose: "List ready tasks with lean columns and score visible." },
@@ -4139,6 +4478,7 @@ var catalog = {
         { usage: "coop update PM-101 --authority-ref-set docs/spec.md#auth --derived-ref-set docs/plan.md#scope", purpose: "Replace the full origin reference lists without editing task files directly." },
         { usage: "coop update PM-101 --deps-set PM-201 --deps-set PM-202 --delivery-tracks-set MVP", purpose: "Replace identifier-based list fields such as depends_on and delivery_tracks." },
         { usage: "coop update IDEA-101 --linked-tasks-set PM-101 --linked-tasks-set PM-102", purpose: "Replace the full linked_tasks list on an idea." },
+        { usage: "coop rename PM-101 APPS-TRUTH-TABLE", purpose: "Add a stable human-facing alias without changing the canonical id or breaking existing references." },
         { 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 alias remove PM-101 PAY.UPI", purpose: "Remove an alias from a task or idea." },
@@ -4314,9 +4654,9 @@ function formatSelectionCommand(commandName, delivery, track) {
     return `${commandName} graph next --delivery ${delivery}`;
   }
   if (track) {
-    return `${commandName} next task --track ${track}`;
+    return `${commandName} next --track ${track}`;
   }
-  return `${commandName} next task`;
+  return `${commandName} next`;
 }
 function renderInitialPrompt(options = {}) {
   const rigour = options.rigour ?? "balanced";
@@ -4578,13 +4918,13 @@ function registerIndexCommand(program) {
 }
 
 // src/commands/init.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path13 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 import { CURRENT_SCHEMA_VERSION, write_schema_version } from "@kitsy/coop-core";
 
 // src/hooks/pre-commit.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path11 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import { detect_cycle, parseTaskContent, parseTaskFile as parseTaskFile8, validateStructural as validateStructural5 } from "@kitsy/coop-core";
@@ -4625,12 +4965,12 @@ function projectRootFromRelativePath(repoRoot, relativePath) {
 }
 function listTaskFilesForProject(projectRoot) {
   const tasksDir = path11.join(projectRoot, "tasks");
-  if (!fs8.existsSync(tasksDir)) return [];
+  if (!fs9.existsSync(tasksDir)) return [];
   const out = [];
   const stack = [tasksDir];
   while (stack.length > 0) {
     const current = stack.pop();
-    const entries = fs8.readdirSync(current, { withFileTypes: true });
+    const entries = fs9.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path11.join(current, entry.name);
       if (entry.isDirectory()) {
@@ -4784,7 +5124,7 @@ function hookScriptBlock() {
 function installPreCommitHook(repoRoot) {
   const hookPath = path11.join(repoRoot, ".git", "hooks", "pre-commit");
   const hookDir = path11.dirname(hookPath);
-  if (!fs8.existsSync(hookDir)) {
+  if (!fs9.existsSync(hookDir)) {
     return {
       installed: false,
       hookPath,
@@ -4792,18 +5132,18 @@ function installPreCommitHook(repoRoot) {
     };
   }
   const block = hookScriptBlock();
-  if (!fs8.existsSync(hookPath)) {
+  if (!fs9.existsSync(hookPath)) {
     const content = ["#!/bin/sh", "", block].join("\n");
-    fs8.writeFileSync(hookPath, content, "utf8");
+    fs9.writeFileSync(hookPath, content, "utf8");
   } else {
-    const existing = fs8.readFileSync(hookPath, "utf8");
+    const existing = fs9.readFileSync(hookPath, "utf8");
     if (!existing.includes(HOOK_BLOCK_START)) {
       const suffix = existing.endsWith("\n") ? "" : "\n";
-      fs8.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
+      fs9.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
     }
   }
   try {
-    fs8.chmodSync(hookPath, 493);
+    fs9.chmodSync(hookPath, 493);
   } catch {
   }
   return {
@@ -4814,7 +5154,7 @@ function installPreCommitHook(repoRoot) {
 }
 
 // src/hooks/post-merge-validate.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path12 from "path";
 import { list_projects } from "@kitsy/coop-core";
 import { load_graph as load_graph5, validate_graph as validate_graph2 } from "@kitsy/coop-core";
@@ -4822,7 +5162,7 @@ var HOOK_BLOCK_START2 = "# COOP_POST_MERGE_START";
 var HOOK_BLOCK_END2 = "# COOP_POST_MERGE_END";
 function runPostMergeValidate(repoRoot) {
   const workspaceDir = path12.join(repoRoot, ".coop");
-  if (!fs9.existsSync(workspaceDir)) {
+  if (!fs10.existsSync(workspaceDir)) {
     return {
       ok: true,
       warnings: ["[COOP] Skipped post-merge validation (.coop not found)."]
@@ -4876,7 +5216,7 @@ function postMergeHookBlock() {
 function installPostMergeHook(repoRoot) {
   const hookPath = path12.join(repoRoot, ".git", "hooks", "post-merge");
   const hookDir = path12.dirname(hookPath);
-  if (!fs9.existsSync(hookDir)) {
+  if (!fs10.existsSync(hookDir)) {
     return {
       installed: false,
       hookPath,
@@ -4884,17 +5224,17 @@ function installPostMergeHook(repoRoot) {
     };
   }
   const block = postMergeHookBlock();
-  if (!fs9.existsSync(hookPath)) {
-    fs9.writeFileSync(hookPath, ["#!/bin/sh", "", block].join("\n"), "utf8");
+  if (!fs10.existsSync(hookPath)) {
+    fs10.writeFileSync(hookPath, ["#!/bin/sh", "", block].join("\n"), "utf8");
   } else {
-    const existing = fs9.readFileSync(hookPath, "utf8");
+    const existing = fs10.readFileSync(hookPath, "utf8");
     if (!existing.includes(HOOK_BLOCK_START2)) {
       const suffix = existing.endsWith("\n") ? "" : "\n";
-      fs9.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
+      fs10.writeFileSync(hookPath, `${existing}${suffix}${block}`, "utf8");
     }
   }
   try {
-    fs9.chmodSync(hookPath, 493);
+    fs10.chmodSync(hookPath, 493);
   } catch {
   }
   return {
@@ -5088,40 +5428,40 @@ tmp/
 *.tmp
 `;
 function ensureDir(dirPath) {
-  fs10.mkdirSync(dirPath, { recursive: true });
+  fs11.mkdirSync(dirPath, { recursive: true });
 }
 function writeIfMissing(filePath, content) {
-  if (!fs10.existsSync(filePath)) {
-    fs10.writeFileSync(filePath, content, "utf8");
+  if (!fs11.existsSync(filePath)) {
+    fs11.writeFileSync(filePath, content, "utf8");
   }
 }
 function ensureGitignoreEntry(root, entry) {
   const gitignorePath = path13.join(root, ".gitignore");
-  if (!fs10.existsSync(gitignorePath)) {
-    fs10.writeFileSync(gitignorePath, `${entry}
+  if (!fs11.existsSync(gitignorePath)) {
+    fs11.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs10.readFileSync(gitignorePath, "utf8");
+  const content = fs11.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}
+    fs11.writeFileSync(gitignorePath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
 function ensureGitattributesEntry(root, entry) {
   const attrsPath = path13.join(root, ".gitattributes");
-  if (!fs10.existsSync(attrsPath)) {
-    fs10.writeFileSync(attrsPath, `${entry}
+  if (!fs11.existsSync(attrsPath)) {
+    fs11.writeFileSync(attrsPath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs10.readFileSync(attrsPath, "utf8");
+  const content = fs11.readFileSync(attrsPath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (!lines.includes(entry)) {
     const suffix = content.endsWith("\n") ? "" : "\n";
-    fs10.writeFileSync(attrsPath, `${content}${suffix}${entry}
+    fs11.writeFileSync(attrsPath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
@@ -5222,7 +5562,7 @@ function registerInitCommand(program) {
       path13.join(projectRoot, "config.yml"),
       buildProjectConfig(projectId, identity.projectName, identity.projectAliases, identity.namingTemplate)
     );
-    if (!fs10.existsSync(path13.join(projectRoot, "schema-version"))) {
+    if (!fs11.existsSync(path13.join(projectRoot, "schema-version"))) {
       write_schema_version(projectRoot, CURRENT_SCHEMA_VERSION);
     }
     writeIfMissing(path13.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
@@ -5315,12 +5655,22 @@ function currentTaskSelection(root, id) {
 }
 function registerLifecycleCommands(program) {
   for (const verb of lifecycleVerbs) {
-    program.command(verb.name).description(verb.description).command("task").description(`${verb.description} by task id or alias`).argument("<id>", "Task ID or alias").option("--actor <actor>", "Actor performing the transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
+    const runTransition = async (id, options) => {
       const root = resolveRepoRoot();
       console.log(currentTaskSelection(root, id));
-      const result = await transitionTaskByReference(root, id, verb.targetStatus, options);
+      const result = verb.name === "block" || verb.name === "unblock" || verb.name === "reopen" || verb.name === "cancel" ? await lifecycleTransitionTaskByReference(root, id, verb.name, verb.targetStatus, options) : await transitionTaskByReference(root, id, verb.targetStatus, options);
       console.log(`Updated ${result.task.id}: ${result.from} -> ${result.to}`);
-    });
+      const maybePath = "path" in result ? result.path : void 0;
+      if (Array.isArray(maybePath) && maybePath.length > 2) {
+        console.log(`Auto-hop path: ${maybePath.join(" -> ")}`);
+      }
+      const maybeAuditPath = "auditPath" in result ? result.auditPath : void 0;
+      if (typeof maybeAuditPath === "string" && maybeAuditPath.length > 0) {
+        console.log(`Transition audit: ${maybeAuditPath}`);
+      }
+    };
+    const command = program.command(verb.name).description(verb.description).argument("<id>", "Task ID or alias").option("--actor <actor>", "Actor performing the transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(runTransition);
+    command.command("task").description(`${verb.description} by task id or alias`).argument("<id>", "Task ID or alias").option("--actor <actor>", "Actor performing the transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(runTransition);
   }
 }
 
@@ -5616,8 +5966,8 @@ function listTasks(options) {
   ensureCoopInitialized(root);
   const context = readWorkingContext(root, resolveCoopHome());
   const graph = load_graph6(coopDir(root));
-  const rawResolvedTrack = resolveContextValueWithSource(options.track, context.track);
-  const rawResolvedDelivery = resolveContextValueWithSource(options.delivery, context.delivery);
+  const rawResolvedTrack = options.all ? {} : resolveContextValueWithSource(options.track, context.track);
+  const rawResolvedDelivery = options.all ? {} : resolveContextValueWithSource(options.delivery, context.delivery);
   const resolvedTrack = {
     ...rawResolvedTrack,
     value: rawResolvedTrack.value ? resolveExistingTrackId(root, rawResolvedTrack.value) ?? rawResolvedTrack.value : void 0
@@ -5626,7 +5976,12 @@ function listTasks(options) {
     ...rawResolvedDelivery,
     value: rawResolvedDelivery.value ? resolveExistingDeliveryId(root, rawResolvedDelivery.value) ?? rawResolvedDelivery.value : void 0
   };
-  const resolvedVersion = resolveContextValueWithSource(options.version, context.version);
+  const resolvedVersion = options.all ? {} : resolveContextValueWithSource(options.version, context.version);
+  const statusFilters = /* @__PURE__ */ new Set();
+  if (options.status?.trim()) statusFilters.add(options.status.trim());
+  if (options.completed) statusFilters.add("done");
+  if (options.todo) statusFilters.add("todo");
+  if (options.blocked) statusFilters.add("blocked");
   const assignee = options.mine ? defaultCoopAuthor(root) : options.assignee?.trim();
   const deliveryScope = resolvedDelivery.value ? new Set(graph.deliveries.get(resolvedDelivery.value)?.scope.include ?? []) : null;
   const defaultSort = options.ready || resolvedTrack.value || resolvedDelivery.value ? "score" : "id";
@@ -5650,7 +6005,7 @@ function listTasks(options) {
   const scoreMap = new Map(scoredEntries.map((entry) => [entry.task.id, entry.score]));
   const rows = loadTasks2(root).filter(({ task }) => {
     if (readyIds && !readyIds.has(task.id)) return false;
-    if (options.status && task.status !== options.status) return false;
+    if (statusFilters.size > 0 && !statusFilters.has(task.status)) return false;
     if (resolvedTrack.value && task.track !== resolvedTrack.value && !(task.delivery_tracks ?? []).includes(resolvedTrack.value)) {
       return false;
     }
@@ -5804,7 +6159,7 @@ function listTracks() {
 }
 function registerListCommand(program) {
   const list = program.command("list").description("List COOP entities");
-  list.command("tasks").alias("task").description("List tasks").option("--status <status>", "Filter by status").option("--track <track>", "Filter by home/contributing track lens, using `coop use track` if omitted").option("--delivery <delivery>", "Filter by delivery membership, using `coop use delivery` if omitted").option("--priority <priority>", "Filter by effective priority").option("--assignee <assignee>", "Filter by assignee").option("--version <version>", "Filter by fix/released version, using `coop use version` if omitted").option("--mine", "Filter to the current default COOP author").option("--ready", "Only list ready tasks in scored order").option("--sort <sort>", "Sort by id|priority|status|title|updated|created|score").option("--columns <columns>", "Columns: id,short,title,status,priority,assignee,track,delivery,score,file or all").action((options) => {
+  list.command("tasks").alias("task").description("List tasks").option("--status <status>", "Filter by status").option("--track <track>", "Filter by home/contributing track lens, using `coop use track` if omitted").option("--delivery <delivery>", "Filter by delivery membership, using `coop use delivery` if omitted").option("--priority <priority>", "Filter by effective priority").option("--assignee <assignee>", "Filter by assignee").option("--version <version>", "Filter by fix/released version, using `coop use version` if omitted").option("--mine", "Filter to the current default COOP author").option("--ready", "Only list ready tasks in scored order").option("--all", "Ignore current `coop use` task-scope filters and list across all tracks/deliveries/versions").option("--completed", "Filter to done tasks").option("--todo", "Filter to todo tasks").option("--blocked", "Filter to blocked tasks").option("--sort <sort>", "Sort by id|priority|status|title|updated|created|score").option("--columns <columns>", "Columns: id,short,title,status,priority,assignee,track,delivery,score,file or all").action((options) => {
     listTasks(options);
   });
   list.command("ideas").alias("idea").description("List ideas").option("--status <status>", "Filter by status").option("--sort <sort>", "Sort by id|status|title|updated|created").option("--columns <columns>", "Columns: id,short,title,status,file or all").action((options) => {
@@ -5822,7 +6177,7 @@ function registerListCommand(program) {
 }
 
 // src/utils/logger.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import os2 from "os";
 import path16 from "path";
 function resolveWorkspaceRoot(start = process.cwd()) {
@@ -5833,11 +6188,11 @@ function resolveWorkspaceRoot(start = process.cwd()) {
     const gitDir = path16.join(current, ".git");
     const coopDir2 = coopWorkspaceDir(current);
     const workspaceConfig = path16.join(coopDir2, "config.yml");
-    if (fs11.existsSync(gitDir)) {
+    if (fs12.existsSync(gitDir)) {
       return current;
     }
     const resolvedCoopDir = path16.resolve(coopDir2);
-    if (resolvedCoopDir !== configuredCoopHome && resolvedCoopDir !== defaultCoopHome && fs11.existsSync(workspaceConfig)) {
+    if (resolvedCoopDir !== configuredCoopHome && resolvedCoopDir !== defaultCoopHome && fs12.existsSync(workspaceConfig)) {
       return current;
     }
     const parent = path16.dirname(current);
@@ -5856,8 +6211,8 @@ function resolveCliLogFile(start = process.cwd()) {
   return path16.join(resolveCoopHome(), "logs", "cli.log");
 }
 function appendLogEntry(entry, logFile) {
-  fs11.mkdirSync(path16.dirname(logFile), { recursive: true });
-  fs11.appendFileSync(logFile, `${JSON.stringify(entry)}
+  fs12.mkdirSync(path16.dirname(logFile), { recursive: true });
+  fs12.appendFileSync(logFile, `${JSON.stringify(entry)}
 `, "utf8");
 }
 function logCliError(error, start = process.cwd()) {
@@ -5896,8 +6251,8 @@ function parseLogLine(line) {
 }
 function readLastCliLog(start = process.cwd()) {
   const logFile = resolveCliLogFile(start);
-  if (!fs11.existsSync(logFile)) return null;
-  const content = fs11.readFileSync(logFile, "utf8");
+  if (!fs12.existsSync(logFile)) return null;
+  const content = fs12.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] ?? "");
@@ -5960,11 +6315,11 @@ function registerLogTimeCommand(program) {
 }
 
 // src/commands/migrate.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path17 from "path";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
-import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager3, migrate_repository, parseYamlFile as parseYamlFile5, writeYamlFile as writeYamlFile5 } from "@kitsy/coop-core";
+import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager3, migrate_repository, parseYamlFile as parseYamlFile5, writeYamlFile as writeYamlFile6 } from "@kitsy/coop-core";
 var COOP_IGNORE_TEMPLATE2 = `.index/
 logs/
 tmp/
@@ -5980,22 +6335,22 @@ function parseTargetVersion(raw) {
   return parsed;
 }
 function writeIfMissing2(filePath, content) {
-  if (!fs12.existsSync(filePath)) {
-    fs12.writeFileSync(filePath, content, "utf8");
+  if (!fs13.existsSync(filePath)) {
+    fs13.writeFileSync(filePath, content, "utf8");
   }
 }
 function ensureGitignoreEntry2(root, entry) {
   const gitignorePath = path17.join(root, ".gitignore");
-  if (!fs12.existsSync(gitignorePath)) {
-    fs12.writeFileSync(gitignorePath, `${entry}
+  if (!fs13.existsSync(gitignorePath)) {
+    fs13.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
     return;
   }
-  const content = fs12.readFileSync(gitignorePath, "utf8");
+  const content = fs13.readFileSync(gitignorePath, "utf8");
   const lines = content.split(/\r?\n/).map((line) => line.trim());
   if (!lines.includes(entry)) {
     const suffix = content.endsWith("\n") ? "" : "\n";
-    fs12.writeFileSync(gitignorePath, `${content}${suffix}${entry}
+    fs13.writeFileSync(gitignorePath, `${content}${suffix}${entry}
 `, "utf8");
   }
 }
@@ -6020,7 +6375,7 @@ function legacyWorkspaceProjectEntries(root) {
     "backlog",
     "plans",
     "releases"
-  ].filter((entry) => fs12.existsSync(path17.join(workspaceDir, entry)));
+  ].filter((entry) => fs13.existsSync(path17.join(workspaceDir, entry)));
 }
 function normalizeProjectId2(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
@@ -6085,19 +6440,19 @@ async function migrateWorkspaceLayout(root, options) {
     throw new Error(`Unsupported workspace-layout target '${options.to ?? ""}'. Expected 'v2'.`);
   }
   const workspaceDir = coopWorkspaceDir(root);
-  if (!fs12.existsSync(workspaceDir)) {
+  if (!fs13.existsSync(workspaceDir)) {
     throw new Error("Missing .coop directory. Run 'coop init' first.");
   }
   const projectsDir = path17.join(workspaceDir, "projects");
   const legacyEntries = legacyWorkspaceProjectEntries(root);
-  if (legacyEntries.length === 0 && fs12.existsSync(projectsDir)) {
+  if (legacyEntries.length === 0 && fs13.existsSync(projectsDir)) {
     console.log("[COOP] workspace layout already uses v2.");
     return;
   }
   const identity = await resolveMigrationIdentity(root, options);
   const projectId = identity.projectId;
   const projectRoot = path17.join(projectsDir, projectId);
-  if (fs12.existsSync(projectRoot) && !options.force) {
+  if (fs13.existsSync(projectRoot) && !options.force) {
     throw new Error(`Project destination '${path17.relative(root, projectRoot)}' already exists. Re-run with --force.`);
   }
   const changed = legacyEntries.map((entry) => `${path17.join(".coop", entry)} -> ${path17.join(".coop", "projects", projectId, entry)}`);
@@ -6116,21 +6471,21 @@ async function migrateWorkspaceLayout(root, options) {
     console.log("- no files were modified.");
     return;
   }
-  fs12.mkdirSync(projectsDir, { recursive: true });
-  fs12.mkdirSync(projectRoot, { recursive: true });
+  fs13.mkdirSync(projectsDir, { recursive: true });
+  fs13.mkdirSync(projectRoot, { recursive: true });
   for (const entry of legacyEntries) {
     const source = path17.join(workspaceDir, entry);
     const destination = path17.join(projectRoot, entry);
-    if (fs12.existsSync(destination)) {
+    if (fs13.existsSync(destination)) {
       if (!options.force) {
         throw new Error(`Destination '${path17.relative(root, destination)}' already exists.`);
       }
-      fs12.rmSync(destination, { recursive: true, force: true });
+      fs13.rmSync(destination, { recursive: true, force: true });
     }
-    fs12.renameSync(source, destination);
+    fs13.renameSync(source, destination);
   }
   const movedConfigPath = path17.join(projectRoot, "config.yml");
-  if (fs12.existsSync(movedConfigPath)) {
+  if (fs13.existsSync(movedConfigPath)) {
     const movedConfig = parseYamlFile5(movedConfigPath);
     const nextProject = typeof movedConfig.project === "object" && movedConfig.project !== null ? { ...movedConfig.project } : {};
     nextProject.name = identity.projectName;
@@ -6139,7 +6494,7 @@ async function migrateWorkspaceLayout(root, options) {
     const nextHooks = typeof movedConfig.hooks === "object" && movedConfig.hooks !== null ? { ...movedConfig.hooks } : {};
     nextHooks.on_task_transition = `.coop/projects/${projectId}/hooks/on-task-transition.sh`;
     nextHooks.on_delivery_complete = `.coop/projects/${projectId}/hooks/on-delivery-complete.sh`;
-    writeYamlFile5(movedConfigPath, {
+    writeYamlFile6(movedConfigPath, {
       ...movedConfig,
       project: nextProject,
       hooks: nextHooks
@@ -6238,7 +6593,7 @@ function printNamingOverview() {
     console.log("- none");
   } else {
     for (const [token, definition] of Object.entries(tokens)) {
-      console.log(`- <${token.toUpperCase()}>: ${definition.values.length > 0 ? definition.values.join(", ") : "(no values)"}`);
+      console.log(`- <${token.toUpperCase()}>: ${definition.values.length > 0 ? definition.values.join(", ") : "(no values)"}${definition.default ? ` | default=${definition.default}` : ""}`);
     }
   }
   console.log("Examples:");
@@ -6305,7 +6660,7 @@ function listTokens() {
     return;
   }
   for (const [token, definition] of Object.entries(tokens)) {
-    console.log(`${token}: ${definition.values.length > 0 ? definition.values.join(", ") : "(no values)"}`);
+    console.log(`${token}: ${definition.values.length > 0 ? definition.values.join(", ") : "(no values)"}${definition.default ? ` | default=${definition.default}` : ""}`);
   }
 }
 function registerNamingCommand(program) {
@@ -6403,6 +6758,53 @@ function registerNamingCommand(program) {
     console.log(`Deleted naming token: ${normalizedToken}`);
   });
   const tokenValue = token.command("value").description("Manage allowed values for a naming token");
+  const tokenDefault = token.command("default").description("Manage default values for a naming token");
+  tokenDefault.command("show").description("Show the default value for a naming token").argument("<token>", "Token name").action((tokenName) => {
+    const normalizedToken = normalizeNamingTokenName(tokenName);
+    const tokens = namingTokensForRoot(resolveRepoRoot());
+    const tokenConfig = tokens[normalizedToken];
+    if (!tokenConfig) {
+      throw new Error(`Naming token '${normalizedToken}' does not exist.`);
+    }
+    console.log(tokenConfig.default ?? "(unset)");
+  });
+  tokenDefault.command("set").description("Set a default value for a naming token").argument("<token>", "Token name").argument("<value>", "Default token value").action((tokenName, value) => {
+    const root = resolveRepoRoot();
+    const normalizedToken = normalizeNamingTokenName(tokenName);
+    const normalizedValue = normalizeNamingTokenValue(value);
+    const tokens = namingTokensForRoot(root);
+    const tokenConfig = tokens[normalizedToken];
+    if (!tokenConfig) {
+      throw new Error(`Naming token '${normalizedToken}' does not exist.`);
+    }
+    if (tokenConfig.values.length > 0 && !tokenConfig.values.includes(normalizedValue)) {
+      throw new Error(`Invalid value '${value}' for naming token '${normalizedToken}'. Allowed values: ${tokenConfig.values.join(", ")}.`);
+    }
+    writeNamingConfig(root, (config) => {
+      const { next, tokens: tokensRaw } = ensureTokenRecord(config);
+      const current = typeof tokensRaw[normalizedToken] === "object" && tokensRaw[normalizedToken] !== null ? { ...tokensRaw[normalizedToken] } : { values: [] };
+      current.default = normalizedValue;
+      tokensRaw[normalizedToken] = current;
+      return next;
+    });
+    console.log(`Default naming token value: ${normalizedToken}=${normalizedValue}`);
+  });
+  tokenDefault.command("clear").description("Clear the default value for a naming token").argument("<token>", "Token name").action((tokenName) => {
+    const root = resolveRepoRoot();
+    const normalizedToken = normalizeNamingTokenName(tokenName);
+    const tokens = namingTokensForRoot(root);
+    if (!tokens[normalizedToken]) {
+      throw new Error(`Naming token '${normalizedToken}' does not exist.`);
+    }
+    writeNamingConfig(root, (config) => {
+      const { next, tokens: tokensRaw } = ensureTokenRecord(config);
+      const current = typeof tokensRaw[normalizedToken] === "object" && tokensRaw[normalizedToken] !== null ? { ...tokensRaw[normalizedToken] } : { values: [] };
+      delete current.default;
+      tokensRaw[normalizedToken] = current;
+      return next;
+    });
+    console.log(`Cleared naming token default: ${normalizedToken}`);
+  });
   tokenValue.command("list").description("List allowed values for a naming token").argument("<token>", "Token name").action((tokenName) => {
     const normalizedToken = normalizeNamingTokenName(tokenName);
     const tokens = namingTokensForRoot(resolveRepoRoot());
@@ -6452,6 +6854,9 @@ function registerNamingCommand(program) {
       }
       const values = Array.isArray(tokenRecord.values) ? tokenRecord.values.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => normalizeNamingTokenValue(entry)).filter((entry) => entry !== normalizedValue) : [];
       tokenRecord.values = Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+      if (tokenRecord.default === normalizedValue) {
+        delete tokenRecord.default;
+      }
       tokens[normalizedToken] = tokenRecord;
       return next;
     });
@@ -6730,7 +7135,7 @@ function registerPromoteCommand(program) {
 }
 
 // src/commands/project.ts
-import fs13 from "fs";
+import fs14 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 = `---
@@ -6846,11 +7251,11 @@ var PROJECT_DIRS = [
   ".index"
 ];
 function ensureDir2(dirPath) {
-  fs13.mkdirSync(dirPath, { recursive: true });
+  fs14.mkdirSync(dirPath, { recursive: true });
 }
 function writeIfMissing3(filePath, content) {
-  if (!fs13.existsSync(filePath)) {
-    fs13.writeFileSync(filePath, content, "utf8");
+  if (!fs14.existsSync(filePath)) {
+    fs14.writeFileSync(filePath, content, "utf8");
   }
 }
 function normalizeProjectId3(value) {
@@ -6864,7 +7269,7 @@ function createProject(root, projectId, projectName, namingTemplate = DEFAULT_ID
     ensureDir2(path18.join(projectRoot, dir));
   }
   writeIfMissing3(path18.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName, namingTemplate));
-  if (!fs13.existsSync(path18.join(projectRoot, "schema-version"))) {
+  if (!fs14.existsSync(path18.join(projectRoot, "schema-version"))) {
     write_schema_version2(projectRoot, CURRENT_SCHEMA_VERSION3);
   }
   writeIfMissing3(path18.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
@@ -6933,7 +7338,7 @@ function registerProjectCommand(program) {
 }
 
 // src/commands/prompt.ts
-import fs14 from "fs";
+import fs15 from "fs";
 function buildPayload(root, id) {
   const { parsed } = loadTaskEntry(root, id);
   const context = readWorkingContext(root, resolveCoopHome());
@@ -7018,7 +7423,7 @@ function registerPromptCommand(program) {
       output2 = renderMarkdown(payload);
     }
     if (options.save) {
-      fs14.writeFileSync(options.save, output2, "utf8");
+      fs15.writeFileSync(options.save, output2, "utf8");
     }
     if (isVerboseRequested()) {
       for (const line of formatResolvedContextMessage({
@@ -7033,8 +7438,23 @@ function registerPromptCommand(program) {
   });
 }
 
+// src/commands/rename.ts
+function registerRenameCommand(program) {
+  program.command("rename").description("Add a stable alias without changing the canonical COOP id").argument("<id-or-type>", "Task or idea id/alias, or an explicit entity type").argument("<id-or-alias>", "Entity id when an explicit type is provided, else the new alias").argument("[next-alias]", "New alias when an explicit type is provided").action((first, second, third) => {
+    const resolved = resolveOptionalEntityArg(first, third ? second : void 0, ["task", "idea"], "task");
+    const nextAlias = (third ?? second).trim();
+    if (!nextAlias) {
+      throw new Error("Provide the new alias. Example: coop rename TASK-123 APPS-TRUTH-TABLE");
+    }
+    const root = resolveRepoRoot();
+    const result = addAliases(root, resolved.id, [nextAlias]);
+    const alias = result.added[0] ?? nextAlias;
+    console.log(`Added alias ${alias} to ${result.target.type} ${result.target.id}. Canonical id unchanged.`);
+  });
+}
+
 // src/commands/refine.ts
-import fs15 from "fs";
+import fs16 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";
@@ -7048,7 +7468,7 @@ function resolveIdeaFile3(root, idOrAlias) {
 }
 async function readSupplementalInput(root, options) {
   if (options.inputFile?.trim()) {
-    return fs15.readFileSync(path19.resolve(root, options.inputFile.trim()), "utf8");
+    return fs16.readFileSync(path19.resolve(root, options.inputFile.trim()), "utf8");
   }
   if (options.stdin) {
     return readStdinText();
@@ -7067,10 +7487,10 @@ function loadAuthorityContext(root, refs) {
     const filePart = extractRefFile(ref);
     if (!filePart) continue;
     const fullPath = path19.resolve(root, filePart);
-    if (!fs15.existsSync(fullPath) || !fs15.statSync(fullPath).isFile()) continue;
+    if (!fs16.existsSync(fullPath) || !fs16.statSync(fullPath).isFile()) continue;
     out.push({
       ref,
-      content: fs15.readFileSync(fullPath, "utf8")
+      content: fs16.readFileSync(fullPath, "utf8")
     });
   }
   return out;
@@ -7143,7 +7563,7 @@ function registerRefineCommand(program) {
 }
 
 // src/commands/run.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path20 from "path";
 import { load_graph as load_graph8, parseTaskFile as parseTaskFile12 } from "@kitsy/coop-core";
 import {
@@ -7155,7 +7575,7 @@ import {
 function loadTask(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
   const taskFile = path20.join(root, ...target.file.split("/"));
-  if (!fs16.existsSync(taskFile)) {
+  if (!fs17.existsSync(taskFile)) {
     throw new Error(`Task file not found: ${target.file}`);
   }
   return parseTaskFile12(taskFile).task;
@@ -7322,7 +7742,7 @@ ${parsed.body}`, query)) continue;
 }
 
 // src/server/api.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import http2 from "http";
 import path21 from "path";
 import {
@@ -7371,8 +7791,8 @@ function taskSummary(graph, task, external = []) {
 }
 function taskFileById(root, id) {
   const tasksDir = path21.join(resolveProject(root).root, "tasks");
-  if (!fs17.existsSync(tasksDir)) return null;
-  const entries = fs17.readdirSync(tasksDir, { withFileTypes: true });
+  if (!fs18.existsSync(tasksDir)) return null;
+  const entries = fs18.readdirSync(tasksDir, { withFileTypes: true });
   const target = `${id}.md`.toLowerCase();
   const match = entries.find((entry) => entry.isFile() && entry.name.toLowerCase() === target);
   return match ? path21.join(tasksDir, match.name) : null;
@@ -7553,7 +7973,7 @@ function registerServeCommand(program) {
 }
 
 // src/commands/show.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path22 from "path";
 import { parseIdeaFile as parseIdeaFile7 } from "@kitsy/coop-core";
 function stringify(value) {
@@ -7574,12 +7994,12 @@ function pushListSection(lines, title, values) {
 }
 function loadComputedFromIndex(root, taskId) {
   const indexPath = path22.join(ensureCoopInitialized(root), ".index", "tasks.json");
-  if (!fs18.existsSync(indexPath)) {
+  if (!fs19.existsSync(indexPath)) {
     return null;
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs18.readFileSync(indexPath, "utf8"));
+    parsed = JSON.parse(fs19.readFileSync(indexPath, "utf8"));
   } catch {
     return null;
   }
@@ -7848,7 +8268,7 @@ function registerShowCommand(program) {
 
 // src/commands/status.ts
 import chalk4 from "chalk";
-import { TaskStatus as TaskStatus4, analyze_feasibility as analyze_feasibility3, load_graph as load_graph11 } from "@kitsy/coop-core";
+import { TaskStatus as TaskStatus5, 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) {
@@ -7887,7 +8307,7 @@ function registerStatusCommand(program) {
     lines.push(chalk4.bold("COOP Status Dashboard"));
     lines.push("");
     lines.push(chalk4.bold("Tasks By Status"));
-    const statusRows = Object.values(TaskStatus4).map((status) => [
+    const statusRows = Object.values(TaskStatus5).map((status) => [
       status,
       String(tasksByStatus.get(status) ?? 0)
     ]);
@@ -8036,7 +8456,7 @@ function printResolvedSelectionContext(root, options) {
 }
 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 the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action((options) => {
+  const nextAction = (options) => {
     const root = resolveRepoRoot();
     printResolvedSelectionContext(root, options);
     const selected = selectTopReadyTask(root, {
@@ -8046,9 +8466,11 @@ function registerTaskFlowCommands(program) {
       today: options.today
     });
     console.log(formatSelectedTask(selected.entry, selected.selection));
-  });
+  };
+  next.description("Show the top ready task").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action(nextAction);
+  next.command("task").description("Show the top ready task").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").action(nextAction);
   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").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the selected task before starting it").option("--claim", "Assign the selected task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
+  const pickAction = async (id, options) => {
     const root = resolveRepoRoot();
     printResolvedSelectionContext(root, options);
     const selected = id?.trim() ? {
@@ -8076,9 +8498,11 @@ function registerTaskFlowCommands(program) {
     console.log(formatSelectedTask(selected.entry, selected.selection));
     maybePromote(root, selected.entry.task.id, options);
     await claimAndStart(root, selected.entry.task.id, options);
-  });
+  };
+  pick.argument("[id]", "Task ID or alias").description("Select the top ready task and move it into active work").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the selected task before starting it").option("--claim", "Assign the selected task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(pickAction);
+  pick.command("task").description("Select the top ready task and move it into active work").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by the home/contributing track lens, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid)").option("--today <date>", "Evaluation date (YYYY-MM-DD)").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the selected task before starting it").option("--claim", "Assign the selected task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(pickAction);
   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 the home/contributing track lens when no id is provided, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership when no id is provided").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid) when no id is provided").option("--today <date>", "Evaluation date (YYYY-MM-DD) when no id is provided").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the task before starting it").option("--claim", "Assign the task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(async (id, options) => {
+  const startAction = async (id, options) => {
     const root = resolveRepoRoot();
     printResolvedSelectionContext(root, options);
     const taskId = id?.trim() || selectTopReadyTask(root, {
@@ -8111,11 +8535,13 @@ function registerTaskFlowCommands(program) {
     );
     maybePromote(root, reference.id, options);
     await claimAndStart(root, reference.id, options);
-  });
+  };
+  start.argument("[id]", "Task ID or alias").description("Start a specific task, or the top ready task if no id is provided").option("--track <track>", "Filter by the home/contributing track lens when no id is provided, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership when no id is provided").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid) when no id is provided").option("--today <date>", "Evaluation date (YYYY-MM-DD) when no id is provided").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the task before starting it").option("--claim", "Assign the task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(startAction);
+  start.command("task").description("Start a specific task, or the top ready task if no id is provided").argument("[id]", "Task ID or alias").option("--track <track>", "Filter by the home/contributing track lens when no id is provided, else config.defaults.track if set").option("--delivery <delivery>", "Filter by delivery membership when no id is provided").option("--executor <executor>", "Filter by executor (human|ai|ci|hybrid) when no id is provided").option("--today <date>", "Evaluation date (YYYY-MM-DD) when no id is provided").option("--promote", "Promote the task in the current track/version context before starting it").option("--to <assignee>", "Assign the task before starting it").option("--claim", "Assign the task to the actor/user/default author before starting it").option("--actor <actor>", "Actor performing assignment/transition").option("--user <user>", "Current user for advisory authorization checks").option("--force", "Override advisory authorization checks").action(startAction);
 }
 
 // src/commands/ui.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import path24 from "path";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
@@ -8124,7 +8550,7 @@ import { IndexManager as IndexManager4 } from "@kitsy/coop-core";
 function findPackageRoot(entryPath) {
   let current = path24.dirname(entryPath);
   while (true) {
-    if (fs19.existsSync(path24.join(current, "package.json"))) {
+    if (fs20.existsSync(path24.join(current, "package.json"))) {
       return current;
     }
     const parent = path24.dirname(current);
@@ -8225,8 +8651,8 @@ 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";
+import fs21 from "fs";
+import { IdeaStatus as IdeaStatus3, TaskPriority as TaskPriority3, TaskStatus as TaskStatus6, stringifyFrontmatter as stringifyFrontmatter5 } from "@kitsy/coop-core";
 function collect(value, previous = []) {
   return [...previous, value];
 }
@@ -8252,10 +8678,10 @@ function setValues(values) {
 }
 function loadBody(options) {
   if (options.bodyFile) {
-    return fs20.readFileSync(options.bodyFile, "utf8");
+    return fs21.readFileSync(options.bodyFile, "utf8");
   }
   if (options.bodyStdin) {
-    return fs20.readFileSync(0, "utf8");
+    return fs21.readFileSync(0, "utf8");
   }
   return void 0;
 }
@@ -8288,8 +8714,8 @@ function clearTrackPriorityOverrides(task, tracks) {
 }
 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(", ")}.`);
+  if (!Object.values(TaskStatus6).includes(value)) {
+    throw new Error(`Invalid status '${status}'. Expected one of ${Object.values(TaskStatus6).join(", ")}.`);
   }
   return value;
 }
@@ -8798,8 +9224,51 @@ function registerWebhookCommand(program) {
   });
 }
 
+// src/commands/workflow.ts
+function registerWorkflowCommand(program) {
+  const workflow = program.command("workflow").description("Configure workflow rules and lifecycle behavior");
+  const transitions = workflow.command("transitions").description("Inspect or customize task transition rules");
+  transitions.command("show").description("Show the effective task transition map").argument("[from]", "Optional source status").action((from) => {
+    const root = resolveRepoRoot();
+    ensureCoopInitialized(root);
+    console.log(formatWorkflowTransitions(readEffectiveWorkflowTransitions(root), from));
+  });
+  transitions.command("set").description("Replace the allowed targets for one source status").argument("<from>", "Source task status").argument("<to_csv>", "Comma-separated target statuses").action((from, toCsv) => {
+    const root = resolveRepoRoot();
+    ensureCoopInitialized(root);
+    const targets = setWorkflowTransitionTargets(root, from, toCsv.split(","));
+    console.log(`${from.trim().toLowerCase()}: ${targets.join(", ")}`);
+  });
+  transitions.command("add").description("Add one allowed target status for a source status").argument("<from>", "Source task status").argument("<to>", "Target task status").action((from, to) => {
+    const root = resolveRepoRoot();
+    ensureCoopInitialized(root);
+    const targets = addWorkflowTransitionTarget(root, from, to);
+    console.log(`${from.trim().toLowerCase()}: ${targets.join(", ")}`);
+  });
+  transitions.command("remove").description("Remove one allowed target status for a source status").argument("<from>", "Source task status").argument("<to>", "Target task status").action((from, to) => {
+    const root = resolveRepoRoot();
+    ensureCoopInitialized(root);
+    const targets = removeWorkflowTransitionTarget(root, from, to);
+    console.log(`${from.trim().toLowerCase()}: ${targets.join(", ") || "(none)"}`);
+  });
+  transitions.command("reset").description("Reset transition overrides for one status or the whole workspace").argument("[from]", "Optional source task status").option("--all", "Reset all task transition overrides").action((from, options) => {
+    const root = resolveRepoRoot();
+    ensureCoopInitialized(root);
+    if (options.all) {
+      resetAllWorkflowTransitions(root);
+      console.log("Reset all workflow transition overrides.");
+      return;
+    }
+    if (!from?.trim()) {
+      throw new Error("Provide <from> or pass --all.");
+    }
+    resetWorkflowTransitionStatus(root, from);
+    console.log(`Reset workflow transition override for ${from.trim().toLowerCase()}.`);
+  });
+}
+
 // src/merge-driver/merge-driver.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import os3 from "os";
 import path25 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
@@ -8884,33 +9353,33 @@ function mergeTextWithGit(ancestor, ours, theirs) {
   return { ok: false, output: stdout };
 }
 function mergeTaskFile(ancestorPath, oursPath, theirsPath) {
-  const ancestorRaw = fs21.readFileSync(ancestorPath, "utf8");
-  const oursRaw = fs21.readFileSync(oursPath, "utf8");
-  const theirsRaw = fs21.readFileSync(theirsPath, "utf8");
+  const ancestorRaw = fs22.readFileSync(ancestorPath, "utf8");
+  const oursRaw = fs22.readFileSync(oursPath, "utf8");
+  const theirsRaw = fs22.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 = fs21.mkdtempSync(path25.join(os3.tmpdir(), "coop-merge-body-"));
+  const tempDir = fs22.mkdtempSync(path25.join(os3.tmpdir(), "coop-merge-body-"));
   try {
     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");
+    fs22.writeFileSync(ancestorBody, ancestor.body, "utf8");
+    fs22.writeFileSync(oursBody, ours.body, "utf8");
+    fs22.writeFileSync(theirsBody, theirs.body, "utf8");
     const mergedBody = mergeTextWithGit(ancestorBody, oursBody, theirsBody);
     const output2 = stringifyFrontmatter6(mergedFrontmatter, mergedBody.output);
-    fs21.writeFileSync(oursPath, output2, "utf8");
+    fs22.writeFileSync(oursPath, output2, "utf8");
     return mergedBody.ok ? 0 : 1;
   } finally {
-    fs21.rmSync(tempDir, { recursive: true, force: true });
+    fs22.rmSync(tempDir, { recursive: true, force: true });
   }
 }
 function mergeDeliveryFile(ancestorPath, oursPath, 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 ancestor = parseYamlContent3(fs22.readFileSync(ancestorPath, "utf8"), ancestorPath);
+  const ours = parseYamlContent3(fs22.readFileSync(oursPath, "utf8"), oursPath);
+  const theirs = parseYamlContent3(fs22.readFileSync(theirsPath, "utf8"), theirsPath);
   const oursUpdated = asTimestamp(ours.updated);
   const theirsUpdated = asTimestamp(theirs.updated);
   const base = ancestor;
@@ -8920,7 +9389,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;
   }
-  fs21.writeFileSync(oursPath, stringifyYamlContent2(merged), "utf8");
+  fs22.writeFileSync(oursPath, stringifyYamlContent2(merged), "utf8");
   return 0;
 }
 function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
@@ -8935,25 +9404,34 @@ function renderBasicHelp() {
   return [
     "COOP Basics",
     "",
+    "Command shape rule:",
+    "- If a command accepts an entity reference, the entity noun is optional: `coop show PM-100` and `coop show task PM-100` are equivalent.",
+    "- Commands without an entity reference, such as `coop next`, remain task-first workflow surfaces.",
+    "",
     "Day-to-day commands:",
     "- `coop current`: show working context, active work, and the next ready task",
     "- `coop use track <id>` / `coop use delivery <id>` / `coop use reset`: manage working scope defaults",
     "- `coop list tracks` / `coop list deliveries`: inspect valid named values before assigning them",
     "- `coop naming`: inspect per-entity ID rules and naming tokens",
+    "- `coop naming token default set <token> <value>` / `clear`: store default custom-token values used during auto-naming when CLI args are omitted",
     '- `coop naming preview "Title" --entity task`: preview the generated ID before creating an item; templates support `TITLE##` like `TITLE18`, `TITLE8`, or `TITLE08`',
     "- `coop naming reset task`: reset one entity's naming template to the default",
     "- `coop create task --from-file draft.yml` / `coop create idea --stdin`: ingest structured drafts; COOP keeps only recognized fields, fills metadata, and warns on ignored fields",
-    "- `coop next task` or `coop pick task`: choose work from COOP",
+    "- `coop next` or `coop pick [id]`: choose work from COOP (`next` shorthand is task-only)",
     "- `coop promote <id>`: move a task to the top of the current working track/version selection lens",
     "- `coop show <id>`: inspect a task, idea, or delivery",
-    "- `coop list tasks --track <id>`: browse scoped work",
+    "- `coop rename <id> <alias>`: add a stable human-facing name without changing the canonical id",
+    "- `coop list tasks --track <id>` / `--completed` / `--all`: browse scoped work, done work, or ignore current `coop use` filters",
     "- `coop update <id> --track <id> --delivery <id>`: update task metadata",
     '- `coop update <id> --acceptance-set "..." --acceptance-set "..."`: replace the whole acceptance list cleanly when an old task was created with the wrong parsing',
     "- `coop update <id> --tests-set ... --authority-ref-set ... --deps-set ...`: the same full-replace pattern works for other mutable list fields too",
     '- `coop comment <id> --message "..."`: append a task comment',
     "- `coop log-time <id> --hours 2 --kind worked`: append time spent",
     "- `coop alias remove <id> <alias>`: remove a shorthand alias from a task or idea",
-    "- `coop review task <id>` / `coop complete task <id>`: move work through lifecycle",
+    "- `coop review <id>` / `coop complete <id>`: move work through lifecycle (`... task <id>` still works too)",
+    "- `coop block <id>` / `coop unblock <id>`: use the universal recovery states; `unblock` always lands on `todo`",
+    "- `coop workflow transitions show`: inspect the effective lifecycle map",
+    "- `coop workflow transitions add <from> <to>` / `remove` / `reset`: customize transition rules without hand-editing config",
     "- `coop help-ai --initial-prompt --strict --repo C:/path/to/repo --delivery MVP --command coop.cmd`: hand off COOP context to an agent",
     "",
     "Use `coop <command> --help` for detailed flags."
@@ -8970,7 +9448,7 @@ function readVersion() {
   const currentFile = fileURLToPath2(import.meta.url);
   const packageJsonPath = path26.resolve(path26.dirname(currentFile), "..", "package.json");
   try {
-    const parsed = JSON.parse(fs22.readFileSync(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(fs23.readFileSync(packageJsonPath, "utf8"));
     return parsed.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -8992,9 +9470,11 @@ function createProgram() {
 Common day-to-day commands:
   coop basics
   coop current
-  coop next task
+  coop next
   coop show <id>
+  coop rename <id> <alias>
   coop naming
+  coop workflow transitions show
 `);
   registerInitCommand(program);
   registerCreateCommand(program);
@@ -9020,6 +9500,7 @@ Common day-to-day commands:
   registerPromoteCommand(program);
   registerProjectCommand(program);
   registerPromptCommand(program);
+  registerRenameCommand(program);
   registerRefineCommand(program);
   registerRunCommand(program);
   registerSearchCommand(program);
@@ -9030,6 +9511,7 @@ Common day-to-day commands:
   registerUseCommand(program);
   registerViewCommand(program);
   registerWebhookCommand(program);
+  registerWorkflowCommand(program);
   registerPhasePlaceholder(program, "ext", 3, "Plugin extension commands");
   program.command("basics").alias("help-basic").description("Show the small set of COOP commands that cover most day-to-day work").action(() => {
     console.log(renderBasicHelp());