@kitsy/coop 2.1.0 → 2.1.2

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import fs18 from "fs";
-import path22 from "path";
+import path24 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command } from "commander";
 
@@ -29,6 +29,28 @@ import {
   writeYamlFile
 } from "@kitsy/coop-core";
 var SEQ_MARKER = "COOPSEQTOKEN";
+var DEFAULT_ID_NAMING_TEMPLATE = "<TYPE>-<TITLE16>-<SEQ>";
+var DEFAULT_ARTIFACTS_DIR = "docs";
+var DEFAULT_TITLE_TOKEN_LENGTH = 16;
+var SEMANTIC_WORD_MAX = 4;
+var SEMANTIC_STOP_WORDS = /* @__PURE__ */ new Set([
+  "A",
+  "AN",
+  "AND",
+  "AS",
+  "AT",
+  "BY",
+  "FOR",
+  "FROM",
+  "IN",
+  "INTO",
+  "OF",
+  "ON",
+  "OR",
+  "THE",
+  "TO",
+  "WITH"
+]);
 function resolveCoopHome() {
   const configured = process.env.COOP_HOME?.trim();
   if (configured) {
@@ -103,8 +125,9 @@ function readCoopConfig(root, projectId = resolveRequestedProject()) {
       ideaPrefix: "IDEA",
       taskPrefix: "PM",
       indexDataFormat: "yaml",
-      idNamingTemplate: "<TYPE>-<USER>-<YYMMDD>-<RAND>",
+      idNamingTemplate: DEFAULT_ID_NAMING_TEMPLATE,
       idSeqPadding: 0,
+      artifactsDir: DEFAULT_ARTIFACTS_DIR,
       projectName: repoName || "COOP Workspace",
       projectId: repoName || "workspace",
       projectAliases: [],
@@ -126,15 +149,18 @@ function readCoopConfig(root, projectId = resolveRequestedProject()) {
   const indexDataFormat = indexDataRaw === "json" ? "json" : "yaml";
   const idRaw = typeof config.id === "object" && config.id !== null ? config.id : {};
   const idNamingTemplateRaw = idRaw.naming;
-  const idNamingTemplate = typeof idNamingTemplateRaw === "string" && idNamingTemplateRaw.trim().length > 0 ? idNamingTemplateRaw.trim() : "<TYPE>-<USER>-<YYMMDD>-<RAND>";
+  const idNamingTemplate = typeof idNamingTemplateRaw === "string" && idNamingTemplateRaw.trim().length > 0 ? idNamingTemplateRaw.trim() : DEFAULT_ID_NAMING_TEMPLATE;
   const idSeqPaddingRaw = idRaw.seq_padding;
   const idSeqPadding = Number.isInteger(idSeqPaddingRaw) && Number(idSeqPaddingRaw) >= 0 ? Number(idSeqPaddingRaw) : 0;
+  const artifactsRaw = typeof config.artifacts === "object" && config.artifacts !== null ? config.artifacts : {};
+  const artifactsDir = typeof artifactsRaw.dir === "string" && artifactsRaw.dir.trim().length > 0 ? artifactsRaw.dir.trim() : DEFAULT_ARTIFACTS_DIR;
   return {
     ideaPrefix,
     taskPrefix,
     indexDataFormat,
     idNamingTemplate,
     idSeqPadding,
+    artifactsDir,
     projectName: projectName || "COOP Workspace",
     projectId: resolvedProjectId || "workspace",
     projectAliases,
@@ -249,6 +275,59 @@ function sanitizeTemplateValue(input3, fallback = "X") {
   const normalized = input3.toUpperCase().replace(/[^A-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
   return normalized || fallback;
 }
+function sanitizeSemanticWord(input3) {
+  return input3.toUpperCase().replace(/[^A-Z0-9]+/g, "").trim();
+}
+function semanticWords(input3) {
+  const rawWords = input3.split(/[^a-zA-Z0-9]+/g).map(sanitizeSemanticWord).filter(Boolean);
+  if (rawWords.length <= 1) {
+    return rawWords;
+  }
+  const filtered = rawWords.filter((word) => !SEMANTIC_STOP_WORDS.has(word));
+  return filtered.length > 0 ? filtered : rawWords;
+}
+function semanticTitleToken(input3, maxLength = DEFAULT_TITLE_TOKEN_LENGTH) {
+  const safeMaxLength = Number.isFinite(maxLength) ? Math.max(4, Math.floor(maxLength)) : DEFAULT_TITLE_TOKEN_LENGTH;
+  const words = semanticWords(input3);
+  if (words.length === 0) {
+    return "UNTITLED";
+  }
+  if (words.length === 1) {
+    return words[0].slice(0, safeMaxLength) || "UNTITLED";
+  }
+  const segments = [];
+  let used = 0;
+  for (const word of words) {
+    const remaining = safeMaxLength - used - (segments.length > 0 ? 1 : 0);
+    if (remaining < 2) {
+      break;
+    }
+    const segment = word.slice(0, Math.min(SEMANTIC_WORD_MAX, remaining));
+    if (!segment) {
+      continue;
+    }
+    segments.push(segment);
+    used += segment.length + (segments.length > 1 ? 1 : 0);
+  }
+  if (segments.length > 0) {
+    return segments.join("-");
+  }
+  return words[0].slice(0, safeMaxLength) || "UNTITLED";
+}
+function namingTokenExamples(title = "Natural-language COOP command recommender") {
+  return {
+    "<TYPE>": "IDEA",
+    "<TITLE>": semanticTitleToken(title, DEFAULT_TITLE_TOKEN_LENGTH),
+    "<TITLE16>": semanticTitleToken(title, 16),
+    "<TITLE24>": semanticTitleToken(title, 24),
+    "<TRACK>": "MVP",
+    "<SEQ>": "1",
+    "<USER>": "PKVSI",
+    "<YYMMDD>": "260320",
+    "<RAND>": "AB12CD34",
+    "<PREFIX>": "PM"
+  };
+}
 function sequenceForPattern(existingIds, prefix, suffix) {
   const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const escapedSuffix = suffix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -284,7 +363,9 @@ function buildIdContext(root, config, context) {
     ENTITY: sanitizeTemplateValue(entityType, entityType),
     USER: normalizeIdPart(actor, "USER", 16),
     YYMMDD: shortDateToken(now),
-    TITLE: sanitizeTemplateValue(title, "UNTITLED"),
+    TITLE: semanticTitleToken(title, DEFAULT_TITLE_TOKEN_LENGTH),
+    TITLE16: semanticTitleToken(title, 16),
+    TITLE24: semanticTitleToken(title, 24),
     TRACK: sanitizeTemplateValue(track || "UNASSIGNED", "UNASSIGNED"),
     STATUS: sanitizeTemplateValue(status || "TODO", "TODO"),
     TASK_TYPE: sanitizeTemplateValue(taskType || "FEATURE", "FEATURE"),
@@ -307,6 +388,9 @@ function replaceTemplateToken(token, contextMap) {
   if (upper === "USER") return contextMap.USER;
   if (upper === "TYPE" || upper === "ENTITY") return contextMap.TYPE;
   if (upper === "TITLE") return contextMap.TITLE;
+  if (/^TITLE\d+$/.test(upper)) {
+    return contextMap[upper] || contextMap.TITLE;
+  }
   if (upper === "TRACK") return contextMap.TRACK;
   if (upper === "TASK_TYPE") return contextMap.TASK_TYPE;
   if (upper === "STATUS") return contextMap.STATUS;
@@ -316,7 +400,7 @@ function replaceTemplateToken(token, contextMap) {
   return sanitizeTemplateValue(upper);
 }
 function renderNamingTemplate(template, contextMap) {
-  const normalizedTemplate = template.trim().length > 0 ? template : "<TYPE>-<USER>-<YYMMDD>-<RAND>";
+  const normalizedTemplate = template.trim().length > 0 ? template : DEFAULT_ID_NAMING_TEMPLATE;
   const replaced = normalizedTemplate.replace(/<([^>]+)>/g, (_, token) => replaceTemplateToken(token, contextMap));
   return sanitizeTemplateValue(replaced, "COOP-ID");
 }
@@ -324,6 +408,17 @@ function defaultCoopAuthor(root) {
   const actor = inferActor(root);
   return actor.trim() || "unknown";
 }
+function previewNamingTemplate(template, context, root = process.cwd()) {
+  const config = readCoopConfig(root);
+  const contextMap = buildIdContext(root, config, context);
+  const rendered = renderNamingTemplate(template, {
+    ...contextMap,
+    RAND: "AB12CD34",
+    YYMMDD: "260320",
+    USER: "PKVSI"
+  });
+  return rendered.replace(SEQ_MARKER, "1");
+}
 function generateConfiguredId(root, existingIds, context) {
   const config = readCoopConfig(root);
   const contextMap = buildIdContext(root, config, context);
@@ -1550,6 +1645,7 @@ var INDEX_DATA_KEY = "index.data";
 var ID_NAMING_KEY = "id.naming";
 var AI_PROVIDER_KEY = "ai.provider";
 var AI_MODEL_KEY = "ai.model";
+var ARTIFACTS_DIR_KEY = "artifacts.dir";
 var PROJECT_NAME_KEY = "project.name";
 var PROJECT_ID_KEY = "project.id";
 var PROJECT_ALIASES_KEY = "project.aliases";
@@ -1558,6 +1654,7 @@ var SUPPORTED_KEYS = [
   ID_NAMING_KEY,
   AI_PROVIDER_KEY,
   AI_MODEL_KEY,
+  ARTIFACTS_DIR_KEY,
   PROJECT_NAME_KEY,
   PROJECT_ID_KEY,
   PROJECT_ALIASES_KEY
@@ -1585,6 +1682,9 @@ function readAiModelValue(root) {
 function readProjectNameValue(root) {
   return readCoopConfig(root).projectName;
 }
+function readArtifactsDirValue(root) {
+  return readCoopConfig(root).artifactsDir;
+}
 function readProjectIdValue(root) {
   return readCoopConfig(root).projectId;
 }
@@ -1653,6 +1753,18 @@ function writeProjectNameValue(root, value) {
   next.project = projectRaw;
   writeCoopConfig(root, next);
 }
+function writeArtifactsDirValue(root, value) {
+  const nextValue = value.trim().replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!nextValue) {
+    throw new Error("Invalid value for artifacts.dir. Provide a non-empty relative path.");
+  }
+  const config = readCoopConfig(root).raw;
+  const next = { ...config };
+  const artifactsRaw = typeof next.artifacts === "object" && next.artifacts !== null ? { ...next.artifacts } : {};
+  artifactsRaw.dir = nextValue;
+  next.artifacts = artifactsRaw;
+  writeCoopConfig(root, next);
+}
 function writeProjectIdValue(root, value) {
   const nextValue = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
   if (!nextValue) {
@@ -1702,6 +1814,10 @@ function registerConfigCommand(program) {
         console.log(`${AI_PROVIDER_KEY}=${readAiProviderValue(root)}`);
         return;
       }
+      if (keyPath === ARTIFACTS_DIR_KEY) {
+        console.log(`${ARTIFACTS_DIR_KEY}=${readArtifactsDirValue(root)}`);
+        return;
+      }
       if (keyPath === PROJECT_NAME_KEY) {
         console.log(`${PROJECT_NAME_KEY}=${readProjectNameValue(root)}`);
         return;
@@ -1732,6 +1848,11 @@ function registerConfigCommand(program) {
       console.log(`${AI_PROVIDER_KEY}=${readAiProviderValue(root)}`);
       return;
     }
+    if (keyPath === ARTIFACTS_DIR_KEY) {
+      writeArtifactsDirValue(root, value);
+      console.log(`${ARTIFACTS_DIR_KEY}=${readArtifactsDirValue(root)}`);
+      return;
+    }
     if (keyPath === PROJECT_NAME_KEY) {
       writeProjectNameValue(root, value);
       console.log(`${PROJECT_NAME_KEY}=${readProjectNameValue(root)}`);
@@ -2778,6 +2899,7 @@ function registerGraphCommand(program) {
 }
 
 // src/utils/ai-help.ts
+import path7 from "path";
 var catalog = {
   purpose: "COOP is a Git-native planning, backlog, execution, and orchestration CLI. It stores canonical data in .coop/projects/<project.id>/ and should be treated as the source of truth for work selection and lifecycle state.",
   selection_rules: [
@@ -2792,15 +2914,49 @@ var catalog = {
     "Multi-project workspaces require `--project <id>` or `coop project use <id>`.",
     "Canonical storage is under `.coop/projects/<project.id>/...`."
   ],
+  allowed_lifecycle_commands: [
+    "coop start task <id>",
+    "coop review task <id>",
+    "coop complete task <id>",
+    "coop block task <id>",
+    "coop unblock task <id>",
+    "coop cancel task <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."
+  ],
+  unsupported_command_warnings: [
+    "Do not invent COOP commands such as `coop complete` when they are not present in `help-ai` output.",
+    "If a desired lifecycle action is not represented by an allowed command, state that explicitly instead of paraphrasing.",
+    "Quote exact COOP command names from `coop help-ai --format json` before proposing them."
+  ],
+  artifact_policy: {
+    config_key: "artifacts.dir",
+    default_dir: "docs",
+    required_for: ["contract reviews", "spike findings", "audit notes", "planning artifacts"],
+    guidance: [
+      "Write agent-produced artifacts under the configured artifact directory.",
+      "If `artifacts.dir` is unset, use `docs`.",
+      "Do not invent ad hoc artifact paths outside the configured directory unless the user explicitly asks for a different location."
+    ]
+  },
   command_groups: [
     {
       name: "Workspace",
       description: "Initialize and select the active COOP project.",
       commands: [
         { usage: "coop init --yes", purpose: "Initialize a COOP workspace with repo-name defaults." },
+        { usage: "coop init --naming <TYPE>-<TITLE16>-<SEQ>", purpose: "Initialize a workspace with an explicit ID naming template." },
         { usage: "coop project list", purpose: "List projects in the current workspace." },
         { usage: "coop project show", purpose: "Show the active project id, name, path, and layout." },
-        { usage: "coop project use <id>", purpose: "Switch the active project in a multi-project workspace." }
+        { usage: "coop project use <id>", purpose: "Switch the active project in a multi-project workspace." },
+        { usage: "coop naming", purpose: "Explain the current naming template, tokens, and examples." },
+        { usage: 'coop naming preview "Natural-language COOP command recommender"', purpose: "Preview a semantic ID before creating an item." }
       ]
     },
     {
@@ -2838,7 +2994,13 @@ var catalog = {
         { usage: "coop next task", purpose: "Show the top ready task using the default track or full workspace context." },
         { usage: "coop graph next --delivery MVP", purpose: "Show the ready queue for a delivery with scores and blockers." },
         { usage: "coop pick task --delivery MVP --claim --actor dev1 --user lead-user", purpose: "Select the top ready task, optionally assign it, and move it to in_progress." },
-        { usage: "coop start task PM-101 --claim --actor dev1 --user lead-user", purpose: "Start a specific task or the top ready task if no id is provided." }
+        { usage: "coop start task PM-101 --claim --actor dev1 --user lead-user", purpose: "Start a specific task or the top ready task if no id is provided." },
+        { 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." }
       ]
     },
     {
@@ -2858,6 +3020,13 @@ var catalog = {
       name: "Execute And Integrate",
       description: "Hand execution to an AI provider or code-agent CLI and expose COOP through MCP/API.",
       commands: [
+        { usage: "coop help-ai --selection --format markdown", purpose: "Show the focused rules for deterministic task selection and workspace resolution." },
+        { usage: "coop help-ai --state-transitions --format json", purpose: "Show exact lifecycle commands, prerequisites, and warnings against invented transitions." },
+        { usage: "coop help-ai --artifacts --format markdown", purpose: "Show where contract-review, audit, and planning artifacts must be written." },
+        { usage: "coop help-ai --post-execution --format markdown", purpose: "Show what an agent must do after finishing the selected task." },
+        { usage: "coop help-ai --naming --format markdown", purpose: "Show naming guidance when IDs and naming templates matter." },
+        { usage: "coop help-ai --initial-prompt --strict --repo C:/path/to/repo --delivery MVP --command coop.cmd", purpose: "Generate a strict agent bootstrap prompt for a repository and delivery." },
+        { usage: "coop help-ai --initial-prompt --rigour balanced --repo C:/path/to/repo --delivery MVP --command coop.cmd", purpose: "Generate the recommended balanced agent bootstrap prompt for day-to-day implementation work." },
         { usage: "coop config ai.provider codex_cli", purpose: "Use the installed Codex CLI as the execution/refinement backend." },
         { usage: "coop config ai.provider claude_cli", purpose: "Use the installed Claude CLI as the execution/refinement backend." },
         { usage: "coop config ai.provider gemini_cli", purpose: "Use the installed Gemini CLI as the execution/refinement backend." },
@@ -2883,9 +3052,201 @@ var catalog = {
   execution_model: [
     "Agents or services may send drafts through files or stdin, but COOP owns canonical writes.",
     "Use `coop create ... --from-file|--stdin` and `coop apply draft` instead of editing `.coop` task or idea files directly.",
-    "Use `coop log --last --verbose` when command execution fails and the concise error points to a stack trace."
+    "Use `coop log --last --verbose` when command execution fails and the concise error points to a stack trace.",
+    "If a workflow depends on stable human-readable IDs, inspect `coop naming` or `coop config id.naming` before creating items."
+  ],
+  post_execution_rules: [
+    "After completing the currently selected task, stop and wait instead of automatically selecting the next task.",
+    "Do not auto-start a second task in the same run unless the user explicitly asks you to continue.",
+    "If you changed task state in COOP, report the exact command used and the resulting new state before doing anything else."
   ]
 };
+function renderTopicPayload(topic) {
+  if (topic === "state-transitions") {
+    return {
+      topic,
+      allowed_lifecycle_commands: catalog.allowed_lifecycle_commands,
+      lifecycle_requirements: catalog.lifecycle_requirements,
+      warnings: catalog.unsupported_command_warnings
+    };
+  }
+  if (topic === "artifacts") {
+    return {
+      topic,
+      artifact_policy: catalog.artifact_policy
+    };
+  }
+  if (topic === "post-execution") {
+    return {
+      topic,
+      post_execution_rules: catalog.post_execution_rules
+    };
+  }
+  if (topic === "selection") {
+    return {
+      topic,
+      selection_rules: catalog.selection_rules,
+      workspace_rules: catalog.workspace_rules
+    };
+  }
+  return {
+    topic,
+    naming_guidance: [
+      "Use `coop naming` to inspect the current naming template and token behavior.",
+      'Use `coop naming preview "<title>"` before creating a new idea, task, or delivery if predictable IDs matter.',
+      "Use `coop config id.naming ...` to override the default semantic naming template."
+    ]
+  };
+}
+function renderAiHelpTopic(format, topic) {
+  const payload = renderTopicPayload(topic);
+  if (format === "json") {
+    return `${JSON.stringify(payload, null, 2)}
+`;
+  }
+  const lines = [];
+  const bullet = (value) => `- ${value}`;
+  const title = topic.split("-").map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ");
+  lines.push(format === "markdown" ? `# COOP AI Help: ${title}` : `COOP AI Help: ${title}`, "");
+  if (topic === "state-transitions") {
+    lines.push(format === "markdown" ? "## Allowed Lifecycle Commands" : "Allowed Lifecycle Commands");
+    for (const item of catalog.allowed_lifecycle_commands) {
+      lines.push(bullet(`\`${item}\``));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Lifecycle Requirements" : "Lifecycle Requirements");
+    for (const item of catalog.lifecycle_requirements) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Warnings" : "Warnings");
+    for (const item of catalog.unsupported_command_warnings) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "artifacts") {
+    lines.push(bullet(`Config key: \`${catalog.artifact_policy.config_key}\``));
+    lines.push(bullet(`Default dir: \`${catalog.artifact_policy.default_dir}\``));
+    lines.push(bullet(`Required for: ${catalog.artifact_policy.required_for.join(", ")}`));
+    for (const item of catalog.artifact_policy.guidance) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "post-execution") {
+    for (const item of catalog.post_execution_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  if (topic === "selection") {
+    lines.push(format === "markdown" ? "## Selection Rules" : "Selection Rules");
+    for (const item of catalog.selection_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    lines.push(format === "markdown" ? "## Workspace Rules" : "Workspace Rules");
+    for (const item of catalog.workspace_rules) {
+      lines.push(bullet(item));
+    }
+    lines.push("");
+    return `${lines.join("\n")}
+`;
+  }
+  for (const item of renderTopicPayload("naming").naming_guidance) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+function normalizeRepoPath(repoPath) {
+  return repoPath ? path7.resolve(repoPath) : process.cwd();
+}
+function formatSelectionCommand(commandName, delivery, track) {
+  if (delivery) {
+    return `${commandName} graph next --delivery ${delivery}`;
+  }
+  if (track) {
+    return `${commandName} next task --track ${track}`;
+  }
+  return `${commandName} next task`;
+}
+function renderInitialPrompt(options = {}) {
+  const rigour = options.rigour ?? "balanced";
+  const repoPath = normalizeRepoPath(options.repoPath);
+  const commandName = options.commandName?.trim() || "coop";
+  const artifactsDir = options.artifactsDir?.trim() || "docs";
+  const selectionCommand = formatSelectionCommand(commandName, options.delivery, options.track);
+  const planningCommand = options.delivery ? `${commandName} plan delivery ${options.delivery}` : `${commandName} status`;
+  const scopeLine = options.delivery ? `- Active delivery: ${options.delivery}` : options.track ? `- Active track: ${options.track}` : "- Work scope: use the workspace default track or delivery context from COOP";
+  const lines = [
+    `You are working in:`,
+    repoPath,
+    "",
+    "COOP is the source of truth for backlog, planning, and execution in this repository.",
+    "",
+    "Before doing anything else:",
+    `1. Run \`${commandName} help-ai --format markdown\``,
+    `2. Run \`${commandName} project show\``,
+    `3. Run \`${selectionCommand}\``,
+    `4. Run \`${planningCommand}\``,
+    "",
+    "Context:",
+    scopeLine,
+    `- Artifact directory: ${artifactsDir}`,
+    "",
+    "Rules:",
+    "- Learn COOP capabilities from `coop help-ai` before proposing commands.",
+    `- If you are unsure how to pick work, run \`${commandName} help-ai --selection --format markdown\`.`,
+    `- If you are unsure about lifecycle changes, run \`${commandName} help-ai --state-transitions --format markdown\`.`,
+    `- If you are unsure where artifacts should go, run \`${commandName} help-ai --artifacts --format markdown\`.`,
+    `- If you are unsure whether to continue after a task, run \`${commandName} help-ai --post-execution --format markdown\`.`,
+    "- Use only commands that actually exist in COOP. Do not invent command names.",
+    "- Do not reprioritize work outside COOP unless the user explicitly overrides it.",
+    "- Select only the first ready task from the COOP readiness output.",
+    "- Inspect the selected task with `coop show task <id>` before implementation.",
+    "- Do not create, edit, move, or normalize files directly inside `.coop/`; use COOP commands, MCP, or API surfaces so COOP remains the canonical writer.",
+    "- Respect lifecycle prerequisites: use `coop review task <id>` before `coop complete task <id>`; do not complete directly from `in_progress`.",
+    `- Write any contract-review, audit, or planning artifact under \`${artifactsDir}\` unless the user explicitly chooses another location.`
+  ];
+  if (rigour === "strict") {
+    lines.push(
+      "- Before mentioning a COOP command, verify the exact command name from `coop help-ai --format json`.",
+      "- If a needed workflow is not supported by an exact COOP command, say that explicitly instead of inventing one.",
+      "- Do not switch to another task unless COOP state changes or the user explicitly redirects you.",
+      "- After executing or completing the selected task, stop and wait for user confirmation before picking another task."
+    );
+  } else if (rigour === "balanced") {
+    lines.push(
+      "- Prefer exact COOP commands from `coop help-ai --format json` when describing next actions.",
+      "- If COOP lacks a named command for a desired action, state the limitation plainly.",
+      "- After finishing the selected task, report the resulting COOP state before proposing follow-up work."
+    );
+  } else {
+    lines.push("- Keep COOP as the authority for task selection and lifecycle state.");
+  }
+  lines.push(
+    "",
+    "Output format:",
+    "- Active project",
+    "- Selected task",
+    "- Why selected",
+    "- Task acceptance/tests/refs summary",
+    "- Immediate implementation steps",
+    "",
+    "Do not start code changes until you have reported the selected task and plan."
+  );
+  return `${lines.join("\n")}
+`;
+}
 function renderAiHelp(format) {
   if (format === "json") {
     return `${JSON.stringify(catalog, null, 2)}
@@ -2906,6 +3267,29 @@ function renderAiHelp(format) {
     lines.push(bullet(rule));
   }
   lines.push("");
+  lines.push(format === "markdown" ? "## Allowed Lifecycle Commands" : "Allowed Lifecycle Commands");
+  for (const item of catalog.allowed_lifecycle_commands) {
+    lines.push(bullet(`\`${item}\``));
+  }
+  lines.push("");
+  lines.push(format === "markdown" ? "## Lifecycle Requirements" : "Lifecycle Requirements");
+  for (const item of catalog.lifecycle_requirements) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
+  lines.push(format === "markdown" ? "## Unsupported / Invented Command Warnings" : "Unsupported / Invented Command Warnings");
+  for (const item of catalog.unsupported_command_warnings) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
+  lines.push(format === "markdown" ? "## Artifact Policy" : "Artifact Policy");
+  lines.push(`${format === "markdown" ? "- " : "- "}Config key: \`${catalog.artifact_policy.config_key}\``);
+  lines.push(`${format === "markdown" ? "- " : "- "}Default dir: \`${catalog.artifact_policy.default_dir}\``);
+  lines.push(`${format === "markdown" ? "- " : "- "}Required for: ${catalog.artifact_policy.required_for.join(", ")}`);
+  for (const item of catalog.artifact_policy.guidance) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
   for (const group of catalog.command_groups) {
     lines.push(format === "markdown" ? `## ${group.name}` : group.name);
     lines.push(group.description);
@@ -2925,23 +3309,82 @@ function renderAiHelp(format) {
     lines.push(bullet(item));
   }
   lines.push("");
+  lines.push(format === "markdown" ? "## Post-Execution Rules" : "Post-Execution Rules");
+  for (const item of catalog.post_execution_rules) {
+    lines.push(bullet(item));
+  }
+  lines.push("");
   return `${lines.join("\n")}
 `;
 }
+function renderAiInitialPrompt(options = {}) {
+  return renderInitialPrompt(options);
+}
 
 // src/commands/help-ai.ts
 function registerHelpAiCommand(program) {
-  program.command("help-ai").description("Print AI-oriented COOP capability and usage help").option("--format <format>", "Output format: text | json | markdown", "text").action((options) => {
+  program.command("help-ai").description("Print AI-oriented COOP capability and usage help").option("--format <format>", "Output format: text | json | markdown", "text").option("--initial-prompt", "Print an agent bootstrap prompt instead of the capability catalog").option("--topic <topic>", "Focused help topic: state-transitions | artifacts | post-execution | selection | naming").option("--state-transitions", "Focused help for lifecycle and state transition usage").option("--artifacts", "Focused help for artifact placement and policy").option("--post-execution", "Focused help for what to do after finishing the selected task").option("--selection", "Focused help for task selection and workspace resolution").option("--naming", "Focused help for naming IDs and naming templates").option("--repo <path>", "Repository path to embed in the initial prompt").option("--delivery <delivery>", "Delivery to embed in the initial prompt").option("--track <track>", "Track to embed in the initial prompt").option("--command <name>", "Command name to embed, e.g. coop or coop.cmd", "coop").option("--rigour <level>", "Prompt rigour: strict | balanced | light", "balanced").option("--strict", "Shortcut for --rigour strict").option("--balanced", "Shortcut for --rigour balanced").option("--light", "Shortcut for --rigour light").action((options) => {
     const format = options.format ?? "text";
     if (format !== "text" && format !== "json" && format !== "markdown") {
       throw new Error(`Unsupported help-ai format '${format}'. Expected text|json|markdown.`);
     }
-    console.log(renderAiHelp(format).trimEnd());
+    const rigour = options.strict ? "strict" : options.light ? "light" : options.balanced ? "balanced" : options.rigour ?? "balanced";
+    if (rigour !== "strict" && rigour !== "balanced" && rigour !== "light") {
+      throw new Error(`Unsupported help-ai rigour '${rigour}'. Expected strict|balanced|light.`);
+    }
+    const topic = resolveHelpTopic(options);
+    let artifactsDir = "docs";
+    const repoRoot = options.repo ? resolveRepoRoot(options.repo) : resolveRepoRoot();
+    try {
+      ensureCoopInitialized(repoRoot);
+      artifactsDir = readCoopConfig(repoRoot).artifactsDir;
+    } catch {
+      artifactsDir = "docs";
+    }
+    const output3 = options.initialPrompt ? renderAiInitialPrompt({
+      repoPath: options.repo,
+      delivery: options.delivery,
+      track: options.track,
+      commandName: options.command,
+      rigour,
+      artifactsDir
+    }) : topic ? renderAiHelpTopic(format, topic) : renderAiHelp(format);
+    console.log(output3.trimEnd());
   });
 }
+function resolveHelpTopic(options) {
+  const requestedTopics = [];
+  if (options.topic) {
+    requestedTopics.push(options.topic);
+  }
+  if (options.stateTransitions) {
+    requestedTopics.push("state-transitions");
+  }
+  if (options.artifacts) {
+    requestedTopics.push("artifacts");
+  }
+  if (options.postExecution) {
+    requestedTopics.push("post-execution");
+  }
+  if (options.selection) {
+    requestedTopics.push("selection");
+  }
+  if (options.naming) {
+    requestedTopics.push("naming");
+  }
+  const unique2 = [...new Set(requestedTopics)];
+  if (unique2.length > 1) {
+    throw new Error(`Specify only one focused help-ai topic at a time. Received: ${unique2.join(", ")}.`);
+  }
+  const topic = unique2[0];
+  if (topic !== void 0 && topic !== "state-transitions" && topic !== "artifacts" && topic !== "post-execution" && topic !== "selection" && topic !== "naming") {
+    throw new Error(`Unsupported help-ai topic '${topic}'. Expected state-transitions|artifacts|post-execution|selection|naming.`);
+  }
+  return topic;
+}
 
 // src/commands/index.ts
-import path7 from "path";
+import path8 from "path";
 import { IndexManager as IndexManager2 } from "@kitsy/coop-core";
 function runStatus(options) {
   const root = resolveRepoRoot();
@@ -2951,7 +3394,7 @@ function runStatus(options) {
   const freshness = status.stale ? "stale" : "fresh";
   const existsText = status.exists ? "present" : "missing";
   console.log(`[COOP] index ${existsText}, ${freshness}`);
-  console.log(`[COOP] graph: ${path7.relative(root, status.graph_path)}`);
+  console.log(`[COOP] graph: ${path8.relative(root, status.graph_path)}`);
   if (status.generated_at) {
     console.log(`[COOP] generated_at: ${status.generated_at}`);
   }
@@ -2974,7 +3417,7 @@ function runRebuild() {
   const graph = manager.build_full_index();
   const elapsed = Date.now() - start;
   console.log(`[COOP] index rebuilt: ${graph.nodes.size} tasks (${elapsed} ms)`);
-  console.log(`[COOP] graph: ${path7.relative(root, manager.graphPath)}`);
+  console.log(`[COOP] graph: ${path8.relative(root, manager.graphPath)}`);
 }
 function registerIndexCommand(program) {
   const index = program.command("index").description("Index management commands");
@@ -2991,7 +3434,7 @@ function registerIndexCommand(program) {
 
 // src/commands/init.ts
 import fs8 from "fs";
-import path10 from "path";
+import path11 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 import { createInterface } from "readline/promises";
 import { stdin as input, stdout as output } from "process";
@@ -2999,7 +3442,7 @@ import { CURRENT_SCHEMA_VERSION, write_schema_version } from "@kitsy/coop-core";
 
 // src/hooks/pre-commit.ts
 import fs6 from "fs";
-import path8 from "path";
+import path9 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 import { detect_cycle, parseTaskContent, parseTaskFile as parseTaskFile7, validateStructural as validateStructural5 } from "@kitsy/coop-core";
 var HOOK_BLOCK_START = "# COOP_PRE_COMMIT_START";
@@ -3030,15 +3473,15 @@ function projectRootFromRelativePath(repoRoot, relativePath) {
   const normalized = toPosixPath2(relativePath);
   const projectMatch = /^\.coop\/projects\/([^/]+)\/tasks\/.+\.md$/i.exec(normalized);
   if (projectMatch?.[1]) {
-    return path8.join(repoRoot, ".coop", "projects", projectMatch[1]);
+    return path9.join(repoRoot, ".coop", "projects", projectMatch[1]);
   }
   if (normalized.startsWith(".coop/tasks/")) {
-    return path8.join(repoRoot, ".coop");
+    return path9.join(repoRoot, ".coop");
   }
   throw new Error(`Unsupported staged COOP task path '${relativePath}'.`);
 }
 function listTaskFilesForProject(projectRoot) {
-  const tasksDir = path8.join(projectRoot, "tasks");
+  const tasksDir = path9.join(projectRoot, "tasks");
   if (!fs6.existsSync(tasksDir)) return [];
   const out = [];
   const stack = [tasksDir];
@@ -3046,12 +3489,12 @@ function listTaskFilesForProject(projectRoot) {
     const current = stack.pop();
     const entries = fs6.readdirSync(current, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path8.join(current, entry.name);
+      const fullPath = path9.join(current, entry.name);
       if (entry.isDirectory()) {
         stack.push(fullPath);
         continue;
       }
-      if (entry.isFile() && path8.extname(entry.name).toLowerCase() === ".md") {
+      if (entry.isFile() && path9.extname(entry.name).toLowerCase() === ".md") {
         out.push(fullPath);
       }
     }
@@ -3070,7 +3513,7 @@ function parseStagedTasks(repoRoot, relativePaths) {
   const errors = [];
   const staged = [];
   for (const relativePath of relativePaths) {
-    const absolutePath = path8.join(repoRoot, ...relativePath.split("/"));
+    const absolutePath = path9.join(repoRoot, ...relativePath.split("/"));
     const projectRoot = projectRootFromRelativePath(repoRoot, relativePath);
     const stagedBlob = readGitBlob(repoRoot, `:${relativePath}`);
     if (!stagedBlob) {
@@ -3134,7 +3577,7 @@ function collectTasksForCycleCheck(projectRoot, stagedTasks) {
   }
   const tasks = [];
   for (const filePath of listTaskFilesForProject(projectRoot)) {
-    const normalized = toPosixPath2(path8.resolve(filePath));
+    const normalized = toPosixPath2(path9.resolve(filePath));
     const stagedTask = stagedByPath.get(normalized);
     if (stagedTask) {
       tasks.push(stagedTask);
@@ -3164,7 +3607,7 @@ function runPreCommitChecks(repoRoot) {
         const graph = buildGraphForCycleCheck(tasks);
         const cycle = detect_cycle(graph);
         if (cycle) {
-          const projectLabel = toPosixPath2(path8.relative(repoRoot, projectRoot));
+          const projectLabel = toPosixPath2(path9.relative(repoRoot, projectRoot));
           errors.push(`[COOP] Dependency cycle detected in ${projectLabel}: ${cycle.join(" -> ")}.`);
         }
       } catch (error) {
@@ -3196,8 +3639,8 @@ function hookScriptBlock() {
   ].join("\n");
 }
 function installPreCommitHook(repoRoot) {
-  const hookPath = path8.join(repoRoot, ".git", "hooks", "pre-commit");
-  const hookDir = path8.dirname(hookPath);
+  const hookPath = path9.join(repoRoot, ".git", "hooks", "pre-commit");
+  const hookDir = path9.dirname(hookPath);
   if (!fs6.existsSync(hookDir)) {
     return {
       installed: false,
@@ -3229,13 +3672,13 @@ function installPreCommitHook(repoRoot) {
 
 // src/hooks/post-merge-validate.ts
 import fs7 from "fs";
-import path9 from "path";
+import path10 from "path";
 import { list_projects } from "@kitsy/coop-core";
 import { load_graph as load_graph4, validate_graph as validate_graph2 } from "@kitsy/coop-core";
 var HOOK_BLOCK_START2 = "# COOP_POST_MERGE_START";
 var HOOK_BLOCK_END2 = "# COOP_POST_MERGE_END";
 function runPostMergeValidate(repoRoot) {
-  const workspaceDir = path9.join(repoRoot, ".coop");
+  const workspaceDir = path10.join(repoRoot, ".coop");
   if (!fs7.existsSync(workspaceDir)) {
     return {
       ok: true,
@@ -3288,8 +3731,8 @@ function postMergeHookBlock() {
   ].join("\n");
 }
 function installPostMergeHook(repoRoot) {
-  const hookPath = path9.join(repoRoot, ".git", "hooks", "post-merge");
-  const hookDir = path9.dirname(hookPath);
+  const hookPath = path10.join(repoRoot, ".git", "hooks", "post-merge");
+  const hookDir = path10.dirname(hookPath);
   if (!fs7.existsSync(hookDir)) {
     return {
       installed: false,
@@ -3339,7 +3782,7 @@ function aliasesYaml(aliases) {
   return `
 ${aliases.map((alias) => `    - "${alias}"`).join("\n")}`;
 }
-function buildProjectConfig(projectId, projectName, projectAliases) {
+function buildProjectConfig(projectId, projectName, projectAliases, namingTemplate) {
   return `version: 2
 project:
   name: ${JSON.stringify(projectName)}
@@ -3353,7 +3796,7 @@ id_prefixes:
   run: "RUN"
 
 id:
-  naming: "<TYPE>-<USER>-<YYMMDD>-<RAND>"
+  naming: ${JSON.stringify(namingTemplate)}
   seq_padding: 0
 
 defaults:
@@ -3482,7 +3925,7 @@ function writeIfMissing(filePath, content) {
   }
 }
 function ensureGitignoreEntry(root, entry) {
-  const gitignorePath = path10.join(root, ".gitignore");
+  const gitignorePath = path11.join(root, ".gitignore");
   if (!fs8.existsSync(gitignorePath)) {
     fs8.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
@@ -3497,7 +3940,7 @@ function ensureGitignoreEntry(root, entry) {
   }
 }
 function ensureGitattributesEntry(root, entry) {
-  const attrsPath = path10.join(root, ".gitattributes");
+  const attrsPath = path11.join(root, ".gitattributes");
   if (!fs8.existsSync(attrsPath)) {
     fs8.writeFileSync(attrsPath, `${entry}
 `, "utf8");
@@ -3559,10 +4002,12 @@ async function promptInitIdentity(root, options) {
       throw new Error("Invalid project id. Use letters, numbers, and hyphens.");
     }
     const aliasesInput = options.aliases !== void 0 ? options.aliases : await ask2("Aliases (csv, optional)", "");
+    const namingTemplate = options.naming?.trim() || await ask2("ID naming template", DEFAULT_ID_NAMING_TEMPLATE);
     return {
       projectName,
       projectId,
-      projectAliases: parseAliases2(aliasesInput)
+      projectAliases: parseAliases2(aliasesInput),
+      namingTemplate
     };
   } finally {
     rl.close();
@@ -3573,6 +4018,7 @@ async function resolveInitIdentity(root, options) {
   const fallbackName = options.name?.trim() || defaultName;
   const fallbackId = normalizeProjectId(options.id?.trim() || fallbackName) || repoIdentityId(root);
   const fallbackAliases = parseAliases2(options.aliases);
+  const fallbackNaming = options.naming?.trim() || DEFAULT_ID_NAMING_TEMPLATE;
   const interactive = Boolean(options.interactive || !options.yes && input.isTTY && output.isTTY);
   if (interactive) {
     return promptInitIdentity(root, options);
@@ -3580,16 +4026,17 @@ async function resolveInitIdentity(root, options) {
   return {
     projectName: fallbackName,
     projectId: fallbackId,
-    projectAliases: fallbackAliases
+    projectAliases: fallbackAliases,
+    namingTemplate: fallbackNaming
   };
 }
 function registerInitCommand(program) {
-  program.command("init").description("Initialize .coop/ structure in the current repository").option("--name <name>", "Project display name").option("--id <id>", "Project id").option("--aliases <csv>", "Comma-separated project aliases").option("-y, --yes", "Use defaults without prompting").option("--interactive", "Prompt for missing project identity values").action(async (options) => {
+  program.command("init").description("Initialize .coop/ structure in the current repository").option("--name <name>", "Project display name").option("--id <id>", "Project id").option("--aliases <csv>", "Comma-separated project aliases").option("--naming <template>", "ID naming template (default: <TYPE>-<TITLE16>-<SEQ>)").option("-y, --yes", "Use defaults without prompting").option("--interactive", "Prompt for missing project identity values").action(async (options) => {
     const root = resolveRepoRoot();
     const workspaceDir = coopWorkspaceDir(root);
     const identity = await resolveInitIdentity(root, options);
     const projectId = identity.projectId;
-    const projectRoot = path10.join(workspaceDir, "projects", projectId);
+    const projectRoot = path11.join(workspaceDir, "projects", projectId);
     const dirs = [
       "ideas",
       "tasks",
@@ -3605,23 +4052,23 @@ function registerInitCommand(program) {
       "history/deliveries",
       ".index"
     ];
-    ensureDir(path10.join(workspaceDir, "projects"));
+    ensureDir(path11.join(workspaceDir, "projects"));
     for (const dir of dirs) {
-      ensureDir(path10.join(projectRoot, dir));
+      ensureDir(path11.join(projectRoot, dir));
     }
     writeIfMissing(
-      path10.join(projectRoot, "config.yml"),
-      buildProjectConfig(projectId, identity.projectName, identity.projectAliases)
+      path11.join(projectRoot, "config.yml"),
+      buildProjectConfig(projectId, identity.projectName, identity.projectAliases, identity.namingTemplate)
     );
-    if (!fs8.existsSync(path10.join(projectRoot, "schema-version"))) {
+    if (!fs8.existsSync(path11.join(projectRoot, "schema-version"))) {
       write_schema_version(projectRoot, CURRENT_SCHEMA_VERSION);
     }
-    writeIfMissing(path10.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
-    writeIfMissing(path10.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE);
-    writeIfMissing(path10.join(projectRoot, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
-    writeIfMissing(path10.join(projectRoot, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
-    writeIfMissing(path10.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE);
-    writeIfMissing(path10.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE);
+    writeIfMissing(path11.join(projectRoot, "templates/task.md"), TASK_TEMPLATE);
+    writeIfMissing(path11.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE);
+    writeIfMissing(path11.join(projectRoot, "plugins/console-log.yml"), PLUGIN_CONSOLE_TEMPLATE);
+    writeIfMissing(path11.join(projectRoot, "plugins/github-pr.yml"), PLUGIN_GITHUB_TEMPLATE);
+    writeIfMissing(path11.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE);
+    writeIfMissing(path11.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE);
     writeWorkspaceConfig(root, { version: 2, current_project: projectId });
     ensureGitignoreEntry(root, ".coop/logs/");
     ensureGitignoreEntry(root, ".coop/tmp/");
@@ -3631,17 +4078,18 @@ function registerInitCommand(program) {
     const project = resolveProject(root, projectId);
     console.log("Initialized COOP workspace.");
     console.log(`- Root: ${root}`);
-    console.log(`- Workspace: ${path10.relative(root, workspaceDir)}`);
-    console.log(`- Project: ${project.id} (${path10.relative(root, project.root)})`);
+    console.log(`- Workspace: ${path11.relative(root, workspaceDir)}`);
+    console.log(`- Project: ${project.id} (${path11.relative(root, project.root)})`);
     console.log(`- Name: ${identity.projectName}`);
     console.log(`- Aliases: ${identity.projectAliases.length > 0 ? identity.projectAliases.join(", ") : "(none)"}`);
+    console.log(`- ID naming: ${identity.namingTemplate}`);
     console.log(`- ${preCommitHook.message}`);
     if (preCommitHook.installed) {
-      console.log(`- Hook: ${path10.relative(root, preCommitHook.hookPath)}`);
+      console.log(`- Hook: ${path11.relative(root, preCommitHook.hookPath)}`);
     }
     console.log(`- ${postMergeHook.message}`);
     if (postMergeHook.installed) {
-      console.log(`- Hook: ${path10.relative(root, postMergeHook.hookPath)}`);
+      console.log(`- Hook: ${path11.relative(root, postMergeHook.hookPath)}`);
     }
     console.log(`- ${mergeDrivers}`);
     console.log("- Next steps:");
@@ -3651,9 +4099,70 @@ function registerInitCommand(program) {
   });
 }
 
+// src/commands/lifecycle.ts
+import path12 from "path";
+import { parseTaskFile as parseTaskFile8 } from "@kitsy/coop-core";
+var lifecycleVerbs = [
+  {
+    name: "review",
+    description: "Move a task into review",
+    targetStatus: "in_review"
+  },
+  {
+    name: "complete",
+    description: "Complete a task",
+    targetStatus: "done"
+  },
+  {
+    name: "block",
+    description: "Mark a task as blocked",
+    targetStatus: "blocked"
+  },
+  {
+    name: "unblock",
+    description: "Move a blocked task back to todo",
+    targetStatus: "todo"
+  },
+  {
+    name: "reopen",
+    description: "Move a task back to todo",
+    targetStatus: "todo"
+  },
+  {
+    name: "cancel",
+    description: "Cancel a task",
+    targetStatus: "canceled"
+  }
+];
+function currentTaskSelection(root, id) {
+  const reference = resolveReference(root, id, "task");
+  const filePath = path12.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile8(filePath);
+  return formatSelectedTask(
+    {
+      task: parsed.task,
+      score: 0,
+      readiness: parsed.task.status === "blocked" ? "blocked" : parsed.task.status === "in_review" ? "waiting_review" : parsed.task.status === "done" || parsed.task.status === "canceled" ? "done" : parsed.task.status === "in_progress" ? "in_progress" : "ready",
+      fits_capacity: true,
+      fits_wip: true
+    },
+    {}
+  );
+}
+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 root = resolveRepoRoot();
+      console.log(currentTaskSelection(root, id));
+      const result = await transitionTaskByReference(root, id, verb.targetStatus, options);
+      console.log(`Updated ${result.task.id}: ${result.from} -> ${result.to}`);
+    });
+  }
+}
+
 // src/commands/list.ts
-import path11 from "path";
-import { parseIdeaFile as parseIdeaFile3, parseTaskFile as parseTaskFile8 } from "@kitsy/coop-core";
+import path13 from "path";
+import { parseIdeaFile as parseIdeaFile3, parseTaskFile as parseTaskFile9 } from "@kitsy/coop-core";
 import chalk2 from "chalk";
 
 // src/utils/not-implemented.ts
@@ -3683,7 +4192,7 @@ function sortByIdAsc(items) {
 }
 function loadTasks(root) {
   return listTaskFiles(root).map((filePath) => ({
-    task: parseTaskFile8(filePath).task,
+    task: parseTaskFile9(filePath).task,
     filePath
   }));
 }
@@ -3723,7 +4232,7 @@ function listTasks(options) {
         statusColor(entry.status),
         entry.priority,
         entry.track,
-        path11.relative(root, entry.filePath)
+        path13.relative(root, entry.filePath)
       ])
     )
   );
@@ -3758,7 +4267,7 @@ function listIdeas(options) {
         statusColor(entry.status),
         entry.priority,
         entry.track,
-        path11.relative(root, entry.filePath)
+        path13.relative(root, entry.filePath)
       ])
     )
   );
@@ -3783,24 +4292,24 @@ function registerListCommand(program) {
 
 // src/utils/logger.ts
 import fs9 from "fs";
-import path12 from "path";
+import path14 from "path";
 function resolveRepoSafe(start = process.cwd()) {
   try {
     return resolveRepoRoot(start);
   } catch {
-    return path12.resolve(start);
+    return path14.resolve(start);
   }
 }
 function resolveCliLogFile(start = process.cwd()) {
   const root = resolveRepoSafe(start);
   const workspace = coopWorkspaceDir(root);
   if (fs9.existsSync(workspace)) {
-    return path12.join(workspace, "logs", "cli.log");
+    return path14.join(workspace, "logs", "cli.log");
   }
-  return path12.join(resolveCoopHome(), "logs", "cli.log");
+  return path14.join(resolveCoopHome(), "logs", "cli.log");
 }
 function appendLogEntry(entry, logFile) {
-  fs9.mkdirSync(path12.dirname(logFile), { recursive: true });
+  fs9.mkdirSync(path14.dirname(logFile), { recursive: true });
   fs9.appendFileSync(logFile, `${JSON.stringify(entry)}
 `, "utf8");
 }
@@ -3877,7 +4386,7 @@ function registerLogCommand(program) {
 
 // src/commands/migrate.ts
 import fs10 from "fs";
-import path13 from "path";
+import path15 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import { stdin as input2, stdout as output2 } from "process";
 import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION2, IndexManager as IndexManager3, migrate_repository, parseYamlFile as parseYamlFile2, writeYamlFile as writeYamlFile4 } from "@kitsy/coop-core";
@@ -3901,7 +4410,7 @@ function writeIfMissing2(filePath, content) {
   }
 }
 function ensureGitignoreEntry2(root, entry) {
-  const gitignorePath = path13.join(root, ".gitignore");
+  const gitignorePath = path15.join(root, ".gitignore");
   if (!fs10.existsSync(gitignorePath)) {
     fs10.writeFileSync(gitignorePath, `${entry}
 `, "utf8");
@@ -3936,7 +4445,7 @@ function legacyWorkspaceProjectEntries(root) {
     "backlog",
     "plans",
     "releases"
-  ].filter((entry) => fs10.existsSync(path13.join(workspaceDir, entry)));
+  ].filter((entry) => fs10.existsSync(path15.join(workspaceDir, entry)));
 }
 function normalizeProjectId2(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
@@ -3981,7 +4490,7 @@ async function promptProjectIdentity(defaults, options) {
 async function resolveMigrationIdentity(root, options) {
   const existing = readCoopConfig(root);
   const defaults = {
-    projectName: existing.projectName || path13.basename(root),
+    projectName: existing.projectName || path15.basename(root),
     projectId: normalizeProjectId2(existing.projectId || repoIdentityId(root)) || repoIdentityId(root),
     projectAliases: options.aliases !== void 0 ? parseAliases3(options.aliases) : existing.projectAliases
   };
@@ -4004,7 +4513,7 @@ async function migrateWorkspaceLayout(root, options) {
   if (!fs10.existsSync(workspaceDir)) {
     throw new Error("Missing .coop directory. Run 'coop init' first.");
   }
-  const projectsDir = path13.join(workspaceDir, "projects");
+  const projectsDir = path15.join(workspaceDir, "projects");
   const legacyEntries = legacyWorkspaceProjectEntries(root);
   if (legacyEntries.length === 0 && fs10.existsSync(projectsDir)) {
     console.log("[COOP] workspace layout already uses v2.");
@@ -4012,11 +4521,11 @@ async function migrateWorkspaceLayout(root, options) {
   }
   const identity = await resolveMigrationIdentity(root, options);
   const projectId = identity.projectId;
-  const projectRoot = path13.join(projectsDir, projectId);
+  const projectRoot = path15.join(projectsDir, projectId);
   if (fs10.existsSync(projectRoot) && !options.force) {
-    throw new Error(`Project destination '${path13.relative(root, projectRoot)}' already exists. Re-run with --force.`);
+    throw new Error(`Project destination '${path15.relative(root, projectRoot)}' already exists. Re-run with --force.`);
   }
-  const changed = legacyEntries.map((entry) => `${path13.join(".coop", entry)} -> ${path13.join(".coop", "projects", projectId, entry)}`);
+  const changed = legacyEntries.map((entry) => `${path15.join(".coop", entry)} -> ${path15.join(".coop", "projects", projectId, entry)}`);
   changed.push(`.coop/config.yml -> workspace current_project=${projectId}`);
   console.log(`Workspace layout migration (${options.dryRun ? "DRY RUN" : "APPLY"})`);
   console.log(`- from: v1 flat layout`);
@@ -4035,17 +4544,17 @@ async function migrateWorkspaceLayout(root, options) {
   fs10.mkdirSync(projectsDir, { recursive: true });
   fs10.mkdirSync(projectRoot, { recursive: true });
   for (const entry of legacyEntries) {
-    const source = path13.join(workspaceDir, entry);
-    const destination = path13.join(projectRoot, entry);
+    const source = path15.join(workspaceDir, entry);
+    const destination = path15.join(projectRoot, entry);
     if (fs10.existsSync(destination)) {
       if (!options.force) {
-        throw new Error(`Destination '${path13.relative(root, destination)}' already exists.`);
+        throw new Error(`Destination '${path15.relative(root, destination)}' already exists.`);
       }
       fs10.rmSync(destination, { recursive: true, force: true });
     }
     fs10.renameSync(source, destination);
   }
-  const movedConfigPath = path13.join(projectRoot, "config.yml");
+  const movedConfigPath = path15.join(projectRoot, "config.yml");
   if (fs10.existsSync(movedConfigPath)) {
     const movedConfig = parseYamlFile2(movedConfigPath);
     const nextProject = typeof movedConfig.project === "object" && movedConfig.project !== null ? { ...movedConfig.project } : {};
@@ -4063,13 +4572,13 @@ async function migrateWorkspaceLayout(root, options) {
   }
   const workspace = readWorkspaceConfig(root);
   writeWorkspaceConfig(root, { ...workspace, version: 2, current_project: projectId });
-  writeIfMissing2(path13.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE2);
-  writeIfMissing2(path13.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE2);
+  writeIfMissing2(path15.join(workspaceDir, ".ignore"), COOP_IGNORE_TEMPLATE2);
+  writeIfMissing2(path15.join(workspaceDir, ".gitignore"), COOP_IGNORE_TEMPLATE2);
   ensureGitignoreEntry2(root, ".coop/logs/");
   ensureGitignoreEntry2(root, ".coop/tmp/");
   const manager = new IndexManager3(projectRoot);
   manager.build_full_index();
-  console.log(`[COOP] migrated workspace to v2 at ${path13.relative(root, projectRoot)}`);
+  console.log(`[COOP] migrated workspace to v2 at ${path15.relative(root, projectRoot)}`);
 }
 function registerMigrateCommand(program) {
   const migrate = program.command("migrate").description("Migrate COOP data and workspace layouts").option("--dry-run", "Preview migration without writing files").option("--to <version>", "Target schema version", String(CURRENT_SCHEMA_VERSION2)).action((options) => {
@@ -4088,7 +4597,7 @@ function registerMigrateCommand(program) {
     if (report.changed_files.length > 0) {
       console.log("- changed files:");
       for (const filePath of report.changed_files) {
-        console.log(`  - ${path13.relative(root, filePath)}`);
+        console.log(`  - ${path15.relative(root, filePath)}`);
       }
     }
     if (report.dry_run) {
@@ -4108,6 +4617,75 @@ function registerMigrateCommand(program) {
   });
 }
 
+// src/commands/naming.ts
+function printNamingOverview() {
+  const root = resolveRepoRoot();
+  const config = readCoopConfig(root);
+  const sampleTitle = "Natural-language COOP command recommender";
+  const sampleTaskTitle = "Implement billing payment contract review";
+  console.log("COOP Naming");
+  console.log(`Current template: ${config.idNamingTemplate}`);
+  console.log(`Default template: ${DEFAULT_ID_NAMING_TEMPLATE}`);
+  console.log("Tokens:");
+  console.log("  <TYPE>     entity type such as IDEA, TASK, DELIVERY");
+  console.log("  <TITLE>    semantic title token (defaults to TITLE16)");
+  console.log("  <TITLE16>  semantic title token capped to 16 chars");
+  console.log("  <TITLE24>  semantic title token capped to 24 chars");
+  console.log("  <TRACK>    task track");
+  console.log("  <SEQ>      sequential number within the rendered pattern");
+  console.log("  <USER>     actor/user namespace");
+  console.log("  <YYMMDD>   short date token");
+  console.log("  <RAND>     random uniqueness token");
+  console.log("  <PREFIX>   entity prefix override");
+  console.log("Examples:");
+  const tokenExamples = namingTokenExamples(sampleTitle);
+  for (const [token, value] of Object.entries(tokenExamples)) {
+    console.log(`  ${token.padEnd(10)} ${value}`);
+  }
+  console.log(`Preview (${DEFAULT_ID_NAMING_TEMPLATE}): ${previewNamingTemplate(DEFAULT_ID_NAMING_TEMPLATE, {
+    entityType: "idea",
+    title: sampleTitle
+  }, root)}`);
+  console.log(`Preview (${config.idNamingTemplate}): ${previewNamingTemplate(config.idNamingTemplate, {
+    entityType: "task",
+    title: sampleTaskTitle,
+    track: "mvp",
+    status: "todo",
+    taskType: "spike"
+  }, root)}`);
+  console.log("Try:");
+  console.log(`  coop naming preview "${sampleTitle}"`);
+  console.log('  coop config id.naming "<TYPE>-<TITLE24>"');
+  console.log('  coop config id.naming "<TRACK>-<SEQ>"');
+}
+function registerNamingCommand(program) {
+  const naming = program.command("naming").description("Explain COOP ID naming templates and preview examples");
+  naming.action(() => {
+    printNamingOverview();
+  });
+  naming.command("preview").description("Preview the current or supplied naming template for a sample title").argument("<title>", "Sample title to render").option("--template <template>", "Override naming template").option("--entity <entity>", "Entity type: idea|task|track|delivery|run", "task").option("--track <track>", "Track token value").option("--status <status>", "Status token value").option("--task-type <taskType>", "Task type token value").action(
+    (title, options) => {
+      const root = resolveRepoRoot();
+      const config = readCoopConfig(root);
+      const entity = options.entity?.trim().toLowerCase() || "task";
+      const template = options.template?.trim() || config.idNamingTemplate;
+      console.log(
+        previewNamingTemplate(
+          template,
+          {
+            entityType: entity,
+            title,
+            track: options.track,
+            status: options.status,
+            taskType: options.taskType
+          },
+          root
+        )
+      );
+    }
+  );
+}
+
 // src/commands/plan.ts
 import chalk3 from "chalk";
 import {
@@ -4343,7 +4921,7 @@ function registerPlanCommand(program) {
 
 // src/commands/project.ts
 import fs11 from "fs";
-import path14 from "path";
+import path16 from "path";
 import { CURRENT_SCHEMA_VERSION as CURRENT_SCHEMA_VERSION3, write_schema_version as write_schema_version2 } from "@kitsy/coop-core";
 var TASK_TEMPLATE2 = `---
 id: TASK-001
@@ -4376,7 +4954,7 @@ linked_tasks: []
 ## Problem
 What problem are you solving?
 `;
-var PROJECT_CONFIG_TEMPLATE = (projectId, projectName) => `version: 2
+var PROJECT_CONFIG_TEMPLATE = (projectId, projectName, namingTemplate) => `version: 2
 project:
   name: "${projectName}"
   id: "${projectId}"
@@ -4389,7 +4967,7 @@ id_prefixes:
   run: "RUN"
 
 id:
-  naming: "<TYPE>-<USER>-<YYMMDD>-<RAND>"
+  naming: ${JSON.stringify(namingTemplate)}
   seq_padding: 0
 
 defaults:
@@ -4462,19 +5040,19 @@ function writeIfMissing3(filePath, content) {
 function normalizeProjectId3(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
 }
-function createProject(root, projectId, projectName) {
+function createProject(root, projectId, projectName, namingTemplate = DEFAULT_ID_NAMING_TEMPLATE) {
   const workspaceDir = coopWorkspaceDir(root);
-  const projectRoot = path14.join(workspaceDir, "projects", projectId);
-  ensureDir2(path14.join(workspaceDir, "projects"));
+  const projectRoot = path16.join(workspaceDir, "projects", projectId);
+  ensureDir2(path16.join(workspaceDir, "projects"));
   for (const dir of PROJECT_DIRS) {
-    ensureDir2(path14.join(projectRoot, dir));
+    ensureDir2(path16.join(projectRoot, dir));
   }
-  writeIfMissing3(path14.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName));
-  if (!fs11.existsSync(path14.join(projectRoot, "schema-version"))) {
+  writeIfMissing3(path16.join(projectRoot, "config.yml"), PROJECT_CONFIG_TEMPLATE(projectId, projectName, namingTemplate));
+  if (!fs11.existsSync(path16.join(projectRoot, "schema-version"))) {
     write_schema_version2(projectRoot, CURRENT_SCHEMA_VERSION3);
   }
-  writeIfMissing3(path14.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
-  writeIfMissing3(path14.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE2);
+  writeIfMissing3(path16.join(projectRoot, "templates/task.md"), TASK_TEMPLATE2);
+  writeIfMissing3(path16.join(projectRoot, "templates/idea.md"), IDEA_TEMPLATE2);
   return projectRoot;
 }
 function registerProjectCommand(program) {
@@ -4502,7 +5080,7 @@ function registerProjectCommand(program) {
     }
     console.log(`id=${active.id}`);
     console.log(`name=${active.name}`);
-    console.log(`path=${path14.relative(root, active.root)}`);
+    console.log(`path=${path16.relative(root, active.root)}`);
     console.log(`layout=${active.layout}`);
   });
   project.command("use").description("Set the active COOP project").argument("<id>", "Project id").action((id) => {
@@ -4516,7 +5094,7 @@ function registerProjectCommand(program) {
     writeWorkspaceConfig(root, { ...workspace, version: 2, current_project: match.id });
     console.log(`current_project=${match.id}`);
   });
-  project.command("create").description("Create a new COOP project in the current workspace").argument("<id>", "Project id").option("--name <name>", "Project display name").action((id, options) => {
+  project.command("create").description("Create a new COOP project in the current workspace").argument("<id>", "Project id").option("--name <name>", "Project display name").option("--naming <template>", "ID naming template (default: <TYPE>-<TITLE16>-<SEQ>)").action((id, options) => {
     const root = resolveRepoRoot();
     const projectId = normalizeProjectId3(id);
     if (!projectId) {
@@ -4527,33 +5105,33 @@ function registerProjectCommand(program) {
       throw new Error(`Project '${projectId}' already exists.`);
     }
     const projectName = options.name?.trim() || repoDisplayName(root);
-    const projectRoot = createProject(root, projectId, projectName);
+    const projectRoot = createProject(root, projectId, projectName, options.naming?.trim() || DEFAULT_ID_NAMING_TEMPLATE);
     const workspace = readWorkspaceConfig(root);
     writeWorkspaceConfig(root, {
       ...workspace,
       version: 2,
       current_project: workspace.current_project || projectId
     });
-    console.log(`Created project '${projectId}' at ${path14.relative(root, projectRoot)}`);
+    console.log(`Created project '${projectId}' at ${path16.relative(root, projectRoot)}`);
   });
 }
 
 // src/commands/refine.ts
 import fs12 from "fs";
-import path15 from "path";
-import { parseIdeaFile as parseIdeaFile4, parseTaskFile as parseTaskFile9 } from "@kitsy/coop-core";
+import path17 from "path";
+import { parseIdeaFile as parseIdeaFile4, parseTaskFile as parseTaskFile10 } from "@kitsy/coop-core";
 import { create_provider_refinement_client, refine_idea_to_draft, refine_task_to_draft } from "@kitsy/coop-ai";
 function resolveTaskFile(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
-  return path15.join(root, ...target.file.split("/"));
+  return path17.join(root, ...target.file.split("/"));
 }
 function resolveIdeaFile2(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "idea");
-  return path15.join(root, ...target.file.split("/"));
+  return path17.join(root, ...target.file.split("/"));
 }
 async function readSupplementalInput(root, options) {
   if (options.inputFile?.trim()) {
-    return fs12.readFileSync(path15.resolve(root, options.inputFile.trim()), "utf8");
+    return fs12.readFileSync(path17.resolve(root, options.inputFile.trim()), "utf8");
   }
   if (options.stdin) {
     return readStdinText();
@@ -4571,7 +5149,7 @@ function loadAuthorityContext(root, refs) {
   for (const ref of refs ?? []) {
     const filePart = extractRefFile(ref);
     if (!filePart) continue;
-    const fullPath = path15.resolve(root, filePart);
+    const fullPath = path17.resolve(root, filePart);
     if (!fs12.existsSync(fullPath) || !fs12.statSync(fullPath).isFile()) continue;
     out.push({
       ref,
@@ -4610,7 +5188,7 @@ function registerRefineCommand(program) {
     const root = resolveRepoRoot();
     const projectDir = ensureCoopInitialized(root);
     const taskFile = resolveTaskFile(root, id);
-    const parsed = parseTaskFile9(taskFile);
+    const parsed = parseTaskFile10(taskFile);
     const supplemental = await readSupplementalInput(root, options);
     const client = create_provider_refinement_client(readCoopConfig(root).raw);
     const draft = await refine_task_to_draft(
@@ -4638,15 +5216,15 @@ function registerRefineCommand(program) {
     const written = applyRefinementDraft(root, projectDir, draft);
     console.log(`[COOP] applied draft from ${draftInput.source}: ${written.length} task file(s) updated`);
     for (const filePath of written) {
-      console.log(`- ${path15.relative(root, filePath)}`);
+      console.log(`- ${path17.relative(root, filePath)}`);
     }
   });
 }
 
 // src/commands/run.ts
 import fs13 from "fs";
-import path16 from "path";
-import { load_graph as load_graph6, parseTaskFile as parseTaskFile10 } from "@kitsy/coop-core";
+import path18 from "path";
+import { load_graph as load_graph6, parseTaskFile as parseTaskFile11 } from "@kitsy/coop-core";
 import {
   build_contract,
   create_provider_agent_client,
@@ -4655,11 +5233,11 @@ import {
 } from "@kitsy/coop-ai";
 function loadTask(root, idOrAlias) {
   const target = resolveReference(root, idOrAlias, "task");
-  const taskFile = path16.join(root, ...target.file.split("/"));
+  const taskFile = path18.join(root, ...target.file.split("/"));
   if (!fs13.existsSync(taskFile)) {
     throw new Error(`Task file not found: ${target.file}`);
   }
-  return parseTaskFile10(taskFile).task;
+  return parseTaskFile11(taskFile).task;
 }
 function printContract(contract) {
   console.log(JSON.stringify(contract, null, 2));
@@ -4695,26 +5273,26 @@ function registerRunCommand(program) {
       on_progress: (message) => console.log(`[COOP] ${message}`)
     });
     if (result.status === "failed") {
-      throw new Error(`Run failed: ${result.run.id}. Log: ${path16.relative(root, result.log_path)}`);
+      throw new Error(`Run failed: ${result.run.id}. Log: ${path18.relative(root, result.log_path)}`);
     }
     if (result.status === "paused") {
       console.log(`[COOP] run paused: ${result.run.id}`);
-      console.log(`[COOP] log: ${path16.relative(root, result.log_path)}`);
+      console.log(`[COOP] log: ${path18.relative(root, result.log_path)}`);
       return;
     }
     console.log(`[COOP] run completed: ${result.run.id}`);
-    console.log(`[COOP] log: ${path16.relative(root, result.log_path)}`);
+    console.log(`[COOP] log: ${path18.relative(root, result.log_path)}`);
   });
 }
 
 // src/server/api.ts
 import fs14 from "fs";
 import http2 from "http";
-import path17 from "path";
+import path19 from "path";
 import {
   analyze_feasibility as analyze_feasibility2,
   load_graph as load_graph7,
-  parseTaskFile as parseTaskFile11,
+  parseTaskFile as parseTaskFile12,
   resolve_external_dependencies
 } from "@kitsy/coop-core";
 function json(res, statusCode, payload) {
@@ -4756,12 +5334,12 @@ function taskSummary(graph, task, external = []) {
   };
 }
 function taskFileById(root, id) {
-  const tasksDir = path17.join(resolveProject(root).root, "tasks");
+  const tasksDir = path19.join(resolveProject(root).root, "tasks");
   if (!fs14.existsSync(tasksDir)) return null;
   const entries = fs14.readdirSync(tasksDir, { withFileTypes: true });
   const target = `${id}.md`.toLowerCase();
   const match = entries.find((entry) => entry.isFile() && entry.name.toLowerCase() === target);
-  return match ? path17.join(tasksDir, match.name) : null;
+  return match ? path19.join(tasksDir, match.name) : null;
 }
 function loadRemoteConfig(root) {
   const raw = readCoopConfig(root).raw;
@@ -4842,7 +5420,7 @@ function createApiServer(root, options = {}) {
           notFound(res, `Task '${taskId}' not found.`);
           return;
         }
-        const parsed = parseTaskFile11(filePath);
+        const parsed = parseTaskFile12(filePath);
         const task = graph.nodes.get(parsed.task.id) ?? parsed.task;
         json(res, 200, {
           ...workspaceMeta(repoRoot),
@@ -4851,7 +5429,7 @@ function createApiServer(root, options = {}) {
             created: task.created,
             updated: task.updated,
             body: parsed.body,
-            file_path: path17.relative(repoRoot, filePath).replace(/\\/g, "/")
+            file_path: path19.relative(repoRoot, filePath).replace(/\\/g, "/")
           }
         });
         return;
@@ -4940,8 +5518,8 @@ function registerServeCommand(program) {
 
 // src/commands/show.ts
 import fs15 from "fs";
-import path18 from "path";
-import { parseIdeaFile as parseIdeaFile5, parseTaskFile as parseTaskFile12 } from "@kitsy/coop-core";
+import path20 from "path";
+import { parseIdeaFile as parseIdeaFile5, parseTaskFile as parseTaskFile13 } from "@kitsy/coop-core";
 function stringify(value) {
   if (value === null || value === void 0) return "-";
   if (Array.isArray(value)) return value.length > 0 ? value.join(", ") : "-";
@@ -4959,7 +5537,7 @@ function pushListSection(lines, title, values) {
   }
 }
 function loadComputedFromIndex(root, taskId) {
-  const indexPath = path18.join(ensureCoopInitialized(root), ".index", "tasks.json");
+  const indexPath = path20.join(ensureCoopInitialized(root), ".index", "tasks.json");
   if (!fs15.existsSync(indexPath)) {
     return null;
   }
@@ -5004,8 +5582,8 @@ function showTask(taskId) {
   const root = resolveRepoRoot();
   const coop = ensureCoopInitialized(root);
   const target = resolveReference(root, taskId, "task");
-  const taskFile = path18.join(root, ...target.file.split("/"));
-  const parsed = parseTaskFile12(taskFile);
+  const taskFile = path20.join(root, ...target.file.split("/"));
+  const parsed = parseTaskFile13(taskFile);
   const task = parsed.task;
   const body = parsed.body.trim();
   const computed = loadComputedFromIndex(root, task.id);
@@ -5023,7 +5601,7 @@ function showTask(taskId) {
     `Tags: ${stringify(task.tags)}`,
     `Created: ${task.created}`,
     `Updated: ${task.updated}`,
-    `File: ${path18.relative(root, taskFile)}`,
+    `File: ${path20.relative(root, taskFile)}`,
     ""
   ];
   pushListSection(lines, "Acceptance", task.acceptance);
@@ -5048,7 +5626,7 @@ function showTask(taskId) {
     "Computed:"
   );
   if (!computed) {
-    lines.push(`index not built (${path18.relative(root, path18.join(coop, ".index", "tasks.json"))} missing)`);
+    lines.push(`index not built (${path20.relative(root, path20.join(coop, ".index", "tasks.json"))} missing)`);
   } else {
     for (const [key, value] of Object.entries(computed)) {
       lines.push(`- ${key}: ${stringify(value)}`);
@@ -5060,7 +5638,7 @@ function showIdea(ideaId) {
   const root = resolveRepoRoot();
   ensureCoopInitialized(root);
   const target = resolveReference(root, ideaId, "idea");
-  const ideaFile = path18.join(root, ...target.file.split("/"));
+  const ideaFile = path20.join(root, ...target.file.split("/"));
   const parsed = parseIdeaFile5(ideaFile);
   const idea = parsed.idea;
   const body = parsed.body.trim();
@@ -5074,7 +5652,7 @@ function showIdea(ideaId) {
     `Tags: ${stringify(idea.tags)}`,
     `Linked Tasks: ${stringify(idea.linked_tasks)}`,
     `Created: ${idea.created}`,
-    `File: ${path18.relative(root, ideaFile)}`,
+    `File: ${path20.relative(root, ideaFile)}`,
     "",
     "Body:",
     body || "-"
@@ -5191,8 +5769,8 @@ function registerTransitionCommand(program) {
 }
 
 // src/commands/taskflow.ts
-import path19 from "path";
-import { parseTaskFile as parseTaskFile13 } from "@kitsy/coop-core";
+import path21 from "path";
+import { parseTaskFile as parseTaskFile14 } from "@kitsy/coop-core";
 function normalizeExecutor(value) {
   if (!value?.trim()) return void 0;
   const normalized = value.trim().toLowerCase();
@@ -5229,8 +5807,8 @@ async function claimAndStart(root, taskId, options) {
     }
   }
   const reference = resolveReference(root, taskId, "task");
-  const filePath = path19.join(root, ...reference.file.split("/"));
-  const parsed = parseTaskFile13(filePath);
+  const filePath = path21.join(root, ...reference.file.split("/"));
+  const parsed = parseTaskFile14(filePath);
   if (parsed.task.status === "in_progress") {
     console.log(`Task ${parsed.task.id} is already in_progress.`);
     return;
@@ -5276,8 +5854,8 @@ function registerTaskFlowCommands(program) {
       today: options.today
     }).entry.task.id;
     const reference = resolveReference(root, taskId, "task");
-    const filePath = path19.join(root, ...reference.file.split("/"));
-    const parsed = parseTaskFile13(filePath);
+    const filePath = path21.join(root, ...reference.file.split("/"));
+    const parsed = parseTaskFile14(filePath);
     console.log(
       formatSelectedTask(
         {
@@ -5301,18 +5879,18 @@ function registerTaskFlowCommands(program) {
 
 // src/commands/ui.ts
 import fs16 from "fs";
-import path20 from "path";
+import path22 from "path";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { IndexManager as IndexManager4 } from "@kitsy/coop-core";
 function findPackageRoot(entryPath) {
-  let current = path20.dirname(entryPath);
+  let current = path22.dirname(entryPath);
   while (true) {
-    if (fs16.existsSync(path20.join(current, "package.json"))) {
+    if (fs16.existsSync(path22.join(current, "package.json"))) {
       return current;
     }
-    const parent = path20.dirname(current);
+    const parent = path22.dirname(current);
     if (parent === current) {
       throw new Error(`Unable to locate package root for ${entryPath}.`);
     }
@@ -5361,9 +5939,9 @@ async function startUiServer(repoRoot, host, port, shouldOpen) {
   const project = resolveProject(repoRoot);
   ensureIndex(repoRoot);
   const uiRoot = resolveUiPackageRoot();
-  const requireFromUi = createRequire(path20.join(uiRoot, "package.json"));
+  const requireFromUi = createRequire(path22.join(uiRoot, "package.json"));
   const vitePackageJson = requireFromUi.resolve("vite/package.json");
-  const viteBin = path20.join(path20.dirname(vitePackageJson), "bin", "vite.js");
+  const viteBin = path22.join(path22.dirname(vitePackageJson), "bin", "vite.js");
   const url = `http://${host}:${port}`;
   console.log(`COOP UI: ${url}`);
   const child = spawn(process.execPath, [viteBin, "--host", host, "--port", String(port)], {
@@ -5722,7 +6300,7 @@ function registerWebhookCommand(program) {
 // src/merge-driver/merge-driver.ts
 import fs17 from "fs";
 import os2 from "os";
-import path21 from "path";
+import path23 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
 import { stringifyFrontmatter as stringifyFrontmatter4, parseFrontmatterContent as parseFrontmatterContent3, parseYamlContent as parseYamlContent3, stringifyYamlContent as stringifyYamlContent2 } from "@kitsy/coop-core";
 var STATUS_RANK = {
@@ -5812,11 +6390,11 @@ function mergeTaskFile(ancestorPath, oursPath, theirsPath) {
   const ours = parseTaskDocument(oursRaw, oursPath);
   const theirs = parseTaskDocument(theirsRaw, theirsPath);
   const mergedFrontmatter = mergeTaskFrontmatter(ancestor.frontmatter, ours.frontmatter, theirs.frontmatter);
-  const tempDir = fs17.mkdtempSync(path21.join(os2.tmpdir(), "coop-merge-body-"));
+  const tempDir = fs17.mkdtempSync(path23.join(os2.tmpdir(), "coop-merge-body-"));
   try {
-    const ancestorBody = path21.join(tempDir, "ancestor.md");
-    const oursBody = path21.join(tempDir, "ours.md");
-    const theirsBody = path21.join(tempDir, "theirs.md");
+    const ancestorBody = path23.join(tempDir, "ancestor.md");
+    const oursBody = path23.join(tempDir, "ours.md");
+    const theirsBody = path23.join(tempDir, "theirs.md");
     fs17.writeFileSync(ancestorBody, ancestor.body, "utf8");
     fs17.writeFileSync(oursBody, ours.body, "utf8");
     fs17.writeFileSync(theirsBody, theirs.body, "utf8");
@@ -5854,7 +6432,7 @@ function runMergeDriver(kind, ancestorPath, oursPath, theirsPath) {
 // src/index.ts
 function readVersion() {
   const currentFile = fileURLToPath2(import.meta.url);
-  const packageJsonPath = path22.resolve(path22.dirname(currentFile), "..", "package.json");
+  const packageJsonPath = path24.resolve(path24.dirname(currentFile), "..", "package.json");
   try {
     const parsed = JSON.parse(fs18.readFileSync(packageJsonPath, "utf8"));
     return parsed.version ?? "0.0.0";
@@ -5887,7 +6465,9 @@ function createProgram() {
   registerHelpAiCommand(program);
   registerIndexCommand(program);
   registerLogCommand(program);
+  registerLifecycleCommands(program);
   registerMigrateCommand(program);
+  registerNamingCommand(program);
   registerPlanCommand(program);
   registerProjectCommand(program);
   registerRefineCommand(program);
@@ -5954,7 +6534,7 @@ async function runCli(argv = process.argv) {
 function isMainModule() {
   const entry = process.argv[1];
   if (!entry) return false;
-  return path22.resolve(entry) === fileURLToPath2(import.meta.url);
+  return path24.resolve(entry) === fileURLToPath2(import.meta.url);
 }
 if (isMainModule()) {
   await runCli(process.argv);