exponential-cli 1.13.0 → 1.16.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import { Command as Command23 } from "commander";
+// src/program.ts
+import { Command as Command25 } from "commander";
 
 // src/commands/auth.ts
 import { Command } from "commander";
@@ -125,7 +125,7 @@ function handleError(error, json = false) {
 // src/commands/auth.ts
 function createAuthCommand() {
   const auth = new Command("auth").description("Authentication commands");
-  auth.command("login").description("Configure CLI with your API token").requiredOption("--token <token>", "JWT token from /tokens page").requiredOption("--api-url <url>", "API URL (e.g., https://app.exponential.so)").action(async (options) => {
+  auth.command("login").description("Configure CLI with your API token").requiredOption("--token <token>", "JWT token from /settings/api-keys").requiredOption("--api-url <url>", "API URL (e.g., https://www.exponential.im)").action(async (options) => {
     try {
       let apiUrl = options.apiUrl.replace(/\/+$/, "");
       if (!apiUrl.startsWith("http://localhost") && !apiUrl.startsWith("https://")) {
@@ -209,6 +209,33 @@ function createAuthCommand() {
 // src/commands/actions.ts
 import { Command as Command2 } from "commander";
 
+// src/utils/resolve.ts
+async function resolveWorkspaceId(client, slugOrId) {
+  return (await resolveWorkspace(client, slugOrId)).id;
+}
+async function resolveWorkspace(client, slugOrId) {
+  const config = getConfig();
+  const candidate = slugOrId ?? config.defaultWorkspaceSlug ?? config.defaultWorkspaceId;
+  if (!candidate) {
+    throw new Error(
+      "No workspace specified and no default workspace set. Pass --workspace <slug> or run `exponential workspaces set-default <slug>`."
+    );
+  }
+  const workspaces = await client.workspaces.list();
+  const byId = workspaces.find((w) => w.id === candidate);
+  if (byId) return byId;
+  const bySlug = workspaces.find((w) => w.slug === candidate);
+  if (bySlug) return bySlug;
+  const known = workspaces.map((w) => w.slug).join(", ");
+  throw new Error(
+    `Workspace "${candidate}" not found. Available: ${known || "(none)"}`
+  );
+}
+async function resolveProductId(client, workspaceId, slugOrId) {
+  const product = await client.products.resolve(workspaceId, slugOrId);
+  return product.id;
+}
+
 // src/utils/output.ts
 import chalk3 from "chalk";
 function shouldUseJson(forceJson, forcePretty) {
@@ -236,10 +263,12 @@ function transformAction(action) {
       slug: action.workspace.slug,
       name: action.workspace.name
     } : null,
+    // `action.upsertBySource` returns assignees as bare `{ userId }` rows;
+    // every other procedure nests the user. Accept both.
     assignees: action.assignees?.map((a) => ({
-      id: a.user.id,
-      name: a.user.name,
-      email: a.user.email
+      id: a.user?.id ?? a.userId ?? "",
+      name: a.user?.name ?? null,
+      email: a.user?.email ?? null
     })) ?? [],
     createdAt: action.createdAt?.toISOString() ?? (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: action.completedAt?.toISOString() ?? null
@@ -271,12 +300,15 @@ function outputActionJson(action) {
   const output = transformAction(action);
   console.log(JSON.stringify(output, null, 2));
 }
+function outputActionUpsertJson(result) {
+  console.log(JSON.stringify({ outcome: result.outcome, action: transformAction(result.action) }, null, 2));
+}
 function outputActionPretty(action) {
   const statusColor = getKanbanStatusColor(action.kanbanStatus);
-  const statusBadge = action.kanbanStatus ? chalk3[statusColor](`[${action.kanbanStatus}]`) : chalk3.gray("[NO STATUS]");
+  const statusBadge2 = action.kanbanStatus ? chalk3[statusColor](`[${action.kanbanStatus}]`) : chalk3.gray("[NO STATUS]");
   console.log(chalk3.gray("\u2500".repeat(50)));
   console.log(`
-${statusBadge} ${chalk3.bold(action.name)}`);
+${statusBadge2} ${chalk3.bold(action.name)}`);
   console.log(chalk3.gray(`  ID: ${action.id}`));
   if (action.project) {
     console.log(`  ${chalk3.cyan("Project:")} ${action.project.name}`);
@@ -309,9 +341,9 @@ Actions (${actions.length} total)`));
   console.log(chalk3.gray("\u2500".repeat(50)));
   for (const action of actions) {
     const statusColor = getKanbanStatusColor(action.kanbanStatus);
-    const statusBadge = action.kanbanStatus ? chalk3[statusColor](`[${action.kanbanStatus}]`) : chalk3.gray("[NO STATUS]");
+    const statusBadge2 = action.kanbanStatus ? chalk3[statusColor](`[${action.kanbanStatus}]`) : chalk3.gray("[NO STATUS]");
     console.log(`
-${statusBadge} ${chalk3.bold(action.name)}`);
+${statusBadge2} ${chalk3.bold(action.name)}`);
     console.log(chalk3.gray(`  ID: ${action.id}`));
     if (action.project) {
       console.log(`  ${chalk3.cyan("Project:")} ${action.project.name}`);
@@ -930,9 +962,9 @@ function outputFeaturesPretty(features) {
 Features (${features.length} total)`));
   console.log(chalk3.gray("\u2500".repeat(50)));
   for (const f of features) {
-    const statusBadge = chalk3[getFeatureStatusColor(f.status)](`[${f.status}]`);
+    const statusBadge2 = chalk3[getFeatureStatusColor(f.status)](`[${f.status}]`);
     const ticketCount = f._count?.tickets != null ? chalk3.gray(` \u2014 ${f._count.tickets} tickets`) : "";
-    console.log(`  ${statusBadge} ${chalk3.bold(f.name)}${ticketCount}`);
+    console.log(`  ${statusBadge2} ${chalk3.bold(f.name)}${ticketCount}`);
     console.log(chalk3.gray(`    ID: ${f.id}`));
     if (f.keyResultLinks?.length) {
       const titles = f.keyResultLinks.map((l) => l.keyResult.title).join("; ");
@@ -1147,10 +1179,10 @@ Tickets (${tickets.length} total)`));
   console.log(chalk3.gray("\u2500".repeat(50)));
   for (const t of tickets) {
     const id = t.shortId ?? (t.number != null ? `#${t.number}` : "?");
-    const statusBadge = chalk3[getTicketStatusColor(t.status)](`[${t.status}]`);
+    const statusBadge2 = chalk3[getTicketStatusColor(t.status)](`[${t.status}]`);
     const typeBadge = chalk3.gray(`[${t.type}]`);
     const blocked = t.isBlocked ? chalk3.red(" BLOCKED") : "";
-    console.log(`  ${statusBadge} ${typeBadge} ${chalk3.bold(id)} ${t.title}${blocked}`);
+    console.log(`  ${statusBadge2} ${typeBadge} ${chalk3.bold(id)} ${t.title}${blocked}`);
     console.log(chalk3.gray(`    ID: ${t.id}`));
   }
   console.log();
@@ -1270,11 +1302,11 @@ function outputEpicsPretty(epics) {
 Epics (${epics.length} total)`));
   console.log(chalk3.gray("\u2500".repeat(50)));
   for (const e of epics) {
-    const statusBadge = chalk3[getEpicStatusColor(e.status)](`[${e.status}]`);
+    const statusBadge2 = chalk3[getEpicStatusColor(e.status)](`[${e.status}]`);
     const counts = e._count ? chalk3.gray(
       ` \u2014 ${e._count.tickets ?? 0} tickets, ${e._count.actions ?? 0} actions`
     ) : "";
-    console.log(`  ${statusBadge} ${chalk3.bold(e.name)}${counts}`);
+    console.log(`  ${statusBadge2} ${chalk3.bold(e.name)}${counts}`);
     console.log(chalk3.gray(`    ID: ${e.id}`));
   }
   console.log();
@@ -1509,6 +1541,242 @@ Meetings (${meetings.length} total)`));
   }
   console.log();
 }
+function getDecisionStatusColor(status) {
+  switch (status) {
+    case "OPEN":
+      return "yellow";
+    case "PROPOSED":
+      return "blue";
+    case "ACCEPTED":
+      return "green";
+    case "DEPRECATED":
+      return "red";
+    default:
+      return "gray";
+  }
+}
+function transformDecision(d) {
+  return {
+    id: d.id,
+    workspaceId: d.workspaceId,
+    number: d.number,
+    label: d.label,
+    statement: d.statement,
+    body: d.body,
+    status: d.status,
+    isOpenQuestion: d.status === "OPEN",
+    reviewState: d.reviewState,
+    source: d.source,
+    decidedAt: d.decidedAt,
+    ownerId: d.ownerId,
+    createdById: d.createdById,
+    confirmedById: d.confirmedById,
+    confirmedAt: d.confirmedAt,
+    transcriptionSessionId: d.transcriptionSessionId,
+    occurrenceId: d.occurrenceId,
+    productId: d.productId,
+    projectId: d.projectId,
+    goalId: d.goalId,
+    keyResultId: d.keyResultId,
+    supersededById: d.supersededById,
+    adrDocumentId: d.adrDocumentId,
+    evidence: d.evidence ?? [],
+    createdAt: d.createdAt,
+    updatedAt: d.updatedAt,
+    owner: d.owner ?? null,
+    deciders: d.deciders ?? [],
+    meeting: d.transcriptionSession ?? null,
+    product: d.product ?? null,
+    project: d.project ?? null,
+    goal: d.goal ?? null,
+    keyResult: d.keyResult ?? null,
+    supersededBy: d.supersededBy ?? null,
+    supersedes: d.supersedes ?? [],
+    links: d.links ?? [],
+    canEdit: d.canEdit ?? null
+  };
+}
+function transformDecisionListRow(d) {
+  return {
+    id: d.id,
+    workspaceId: d.workspaceId,
+    number: d.number,
+    label: d.label,
+    statement: d.statement,
+    status: d.status,
+    isOpenQuestion: d.status === "OPEN",
+    reviewState: d.reviewState ?? null,
+    source: d.source,
+    decidedAt: d.decidedAt,
+    updatedAt: d.updatedAt,
+    transcriptionSessionId: d.transcriptionSessionId,
+    occurrenceId: d.occurrenceId,
+    productId: d.productId,
+    projectId: d.projectId,
+    supersededById: d.supersededById,
+    evidenceCount: d.evidenceCount,
+    linkCount: d._count?.links ?? 0,
+    deciderCount: d._count?.deciders ?? 0,
+    product: d.product ?? null,
+    project: d.project ?? null,
+    meeting: d.transcriptionSession ?? null,
+    supersededBy: d.supersededBy ?? null
+  };
+}
+function outputDecisionJson(decision) {
+  console.log(JSON.stringify(transformDecision(decision), null, 2));
+}
+function outputDecisionPretty(decision) {
+  const color = getDecisionStatusColor(decision.status);
+  const kind = decision.status === "OPEN" ? chalk3.yellow(" [open question]") : "";
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  console.log(
+    `
+${chalk3.gray(decision.label)} ${chalk3.bold(decision.statement)}${kind}`
+  );
+  console.log(chalk3.gray(`  ID: ${decision.id}`));
+  console.log(`  ${chalk3.gray("Status:")} ${chalk3[color](decision.status)}`);
+  console.log(`  ${chalk3.gray("Source:")} ${decision.source}`);
+  if (decision.reviewState && decision.reviewState !== "CONFIRMED") {
+    console.log(`  ${chalk3.yellow(decision.reviewState)}`);
+  }
+  if (decision.decidedAt) {
+    console.log(
+      `  ${chalk3.gray("Decided:")} ${new Date(decision.decidedAt).toLocaleString()}`
+    );
+  }
+  if (decision.transcriptionSession) {
+    console.log(
+      `  ${chalk3.gray("Meeting:")} ${decision.transcriptionSession.title ?? "Untitled"} (${decision.transcriptionSession.id})`
+    );
+  }
+  if (decision.product) {
+    console.log(`  ${chalk3.gray("Product:")} ${decision.product.name}`);
+  }
+  if (decision.project) {
+    console.log(`  ${chalk3.gray("Project:")} ${decision.project.name}`);
+  }
+  if (decision.owner) {
+    console.log(`  ${chalk3.gray("Owner:")} ${decision.owner.name ?? decision.owner.id}`);
+  }
+  if (decision.deciders && decision.deciders.length > 0) {
+    const people = decision.deciders.map((d) => d.email ? `${d.name} <${d.email}>` : d.name).join(", ");
+    console.log(`  ${chalk3.gray("Deciders:")} ${people}`);
+  }
+  if (decision.supersededBy) {
+    console.log(
+      `  ${chalk3.gray("Superseded by:")} D-${decision.supersededBy.number} ${decision.supersededBy.statement}`
+    );
+  }
+  if (decision.supersedes && decision.supersedes.length > 0) {
+    for (const prior of decision.supersedes) {
+      console.log(
+        `  ${chalk3.gray("Supersedes:")} D-${prior.number} ${prior.statement}`
+      );
+    }
+  }
+  if (decision.links && decision.links.length > 0) {
+    console.log(`  ${chalk3.gray("Implemented by:")}`);
+    for (const link of decision.links) {
+      const target = link.ticket ? `${link.ticket.shortId ?? `#${link.ticket.number}`} ${link.ticket.title}` : link.feature ? `feature: ${link.feature.name}` : "(unknown)";
+      console.log(chalk3.gray(`    ${target}  [link ${link.id}]`));
+    }
+  }
+  if (decision.evidence && decision.evidence.length > 0) {
+    console.log(`
+${chalk3.bold("Evidence")}`);
+    for (const turn of decision.evidence) {
+      const who = turn.speaker ? `${turn.speaker}: ` : "";
+      console.log(chalk3.gray(`  [${turn.turnIndex}] ${who}${turn.text}`));
+    }
+  }
+  if (decision.body) {
+    console.log(`
+${decision.body}`);
+  }
+  console.log();
+}
+function outputDecisionsJson(decisions, extra = {}) {
+  console.log(
+    JSON.stringify(
+      {
+        decisions: decisions.map(transformDecisionListRow),
+        total: decisions.length,
+        ...extra
+      },
+      null,
+      2
+    )
+  );
+}
+function outputDecisionsPretty(decisions) {
+  if (decisions.length === 0) {
+    console.log(chalk3.gray("No decisions found."));
+    return;
+  }
+  const openCount = decisions.filter((d) => d.status === "OPEN").length;
+  console.log(
+    chalk3.bold(
+      `
+Decisions (${decisions.length} total, ${openCount} open question${openCount === 1 ? "" : "s"})`
+    )
+  );
+  console.log(chalk3.gray("\u2500".repeat(50)));
+  for (const d of decisions) {
+    const color = getDecisionStatusColor(d.status);
+    const draft = d.reviewState && d.reviewState !== "CONFIRMED" ? chalk3.yellow(` [${d.reviewState.toLowerCase()}]`) : "";
+    console.log(
+      `  ${chalk3.gray(d.label)} ${chalk3.bold(d.statement)}${draft} ${chalk3[color](`[${d.status}]`)}`
+    );
+    console.log(chalk3.gray(`    ID: ${d.id}`));
+    const context = [
+      d.product ? `Product: ${d.product.name}` : null,
+      d.transcriptionSession ? `Meeting: ${d.transcriptionSession.title ?? d.transcriptionSession.id}` : null,
+      d.decidedAt ? `Decided ${new Date(d.decidedAt).toLocaleDateString()}` : null,
+      d.evidenceCount > 0 ? `${d.evidenceCount} evidence` : null,
+      d._count?.links ? `${d._count.links} linked` : null
+    ].filter(Boolean);
+    if (context.length > 0) {
+      console.log(chalk3.gray(`    ${context.join(" \xB7 ")}`));
+    }
+  }
+  console.log();
+}
+function outputDecisionBatchJson(results) {
+  console.log(
+    JSON.stringify(
+      {
+        results: results.map((r) => ({
+          index: r.index,
+          success: r.success,
+          statement: r.statement ?? r.decision?.statement ?? null,
+          decision: r.decision ? transformDecision(r.decision) : null,
+          error: r.error ?? null
+        })),
+        total: results.length,
+        succeeded: results.filter((r) => r.success).length,
+        failed: results.filter((r) => !r.success).length
+      },
+      null,
+      2
+    )
+  );
+}
+function outputDecisionBatchPretty(results) {
+  for (const r of results) {
+    const statement = r.statement ?? r.decision?.statement ?? "";
+    if (r.success) {
+      console.log(
+        `  ${chalk3.green("\u2713")} #${r.index}: ${chalk3.gray(r.decision?.label ?? "")} ${statement}`
+      );
+    } else {
+      console.log(`  ${chalk3.red("\u2717")} #${r.index}: ${statement} \u2014 ${r.error ?? "failed"}`);
+    }
+  }
+  const ok = results.filter((r) => r.success).length;
+  console.log(chalk3.bold(`
+${ok}/${results.length} decisions logged`));
+}
 function outputRequirementJson(requirement) {
   console.log(JSON.stringify(requirement, null, 2));
 }
@@ -1990,6 +2258,134 @@ ${chalk3.bold(project.name)}`);
   }
   console.log();
 }
+function formatMinutes(totalMins) {
+  if (totalMins <= 0) return "0m";
+  const h = Math.floor(totalMins / 60);
+  const m = totalMins % 60;
+  if (h === 0) return `${m}m`;
+  if (m === 0) return `${h}h`;
+  return `${h}h ${m}m`;
+}
+function entryMinutes(entry) {
+  const end = entry.endedAt ? new Date(entry.endedAt) : /* @__PURE__ */ new Date();
+  const ms = end.getTime() - new Date(entry.startedAt).getTime();
+  return ms <= 0 ? 0 : Math.round(ms / 6e4);
+}
+function clock(date) {
+  const d = new Date(date);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+function transformTimeEntry(entry) {
+  return {
+    id: entry.id,
+    userId: entry.userId,
+    actionId: entry.actionId,
+    actionName: entry.action?.name ?? null,
+    projectId: entry.action?.projectId ?? null,
+    workspaceId: entry.workspaceId,
+    startedAt: entry.startedAt,
+    endedAt: entry.endedAt,
+    minutes: entryMinutes(entry),
+    status: entry.status,
+    source: entry.source,
+    sourceRef: entry.sourceRef,
+    note: entry.note,
+    createdByAgentId: entry.createdByAgentId
+  };
+}
+function statusBadge(status) {
+  return status === "PROPOSED" ? chalk3.yellow("[PROPOSED]") : chalk3.green("[CONFIRMED]");
+}
+function outputTimeLogJson(result) {
+  console.log(
+    JSON.stringify({ outcome: result.outcome, entry: transformTimeEntry(result.entry) }, null, 2)
+  );
+}
+function outputTimeLogPretty(result) {
+  const e = result.entry;
+  const verb = { created: "Logged", updated: "Updated", left: "Left untouched (already confirmed)" }[result.outcome];
+  console.log(
+    `${chalk3.green("\u2713")} ${verb}: ${clock(e.startedAt)}\u2013${e.endedAt ? clock(e.endedAt) : "now"} ${chalk3.bold(formatMinutes(entryMinutes(e)))} ${statusBadge(e.status)} ${e.action?.name ?? e.actionId}`
+  );
+  if (e.note) console.log(chalk3.gray(`  ${e.note}`));
+  console.log(chalk3.gray(`  ID: ${e.id}${e.sourceRef ? `  ref: ${e.sourceRef}` : ""}  owner: ${e.userId}`));
+}
+function outputTimeEntriesJson(entries, date) {
+  const rows = entries.map(transformTimeEntry);
+  console.log(
+    JSON.stringify(
+      {
+        date,
+        entries: rows,
+        total: rows.length,
+        totalMinutes: rows.reduce((acc, r) => acc + r.minutes, 0),
+        proposed: rows.filter((r) => r.status === "PROPOSED").length
+      },
+      null,
+      2
+    )
+  );
+}
+function outputTimeEntriesPretty(entries, date) {
+  if (entries.length === 0) {
+    console.log(chalk3.gray(`No time entries on ${date}.`));
+    return;
+  }
+  console.log(chalk3.bold(`
+Time on ${date}
+`));
+  let total = 0;
+  for (const e of entries) {
+    const mins = entryMinutes(e);
+    total += mins;
+    const range = `${clock(e.startedAt)}\u2013${e.endedAt ? clock(e.endedAt) : "now"}`;
+    console.log(
+      `  ${range}  ${chalk3.bold(formatMinutes(mins).padStart(6))}  ${statusBadge(e.status)} ${e.action?.name ?? e.actionId}${e.note ? chalk3.gray(` \xB7 ${e.note}`) : ""}`
+    );
+    console.log(chalk3.gray(`    ${e.id}  ${e.source}${e.sourceRef ? `  ${e.sourceRef}` : ""}`));
+  }
+  const proposed = entries.filter((e) => e.status === "PROPOSED").length;
+  console.log(
+    chalk3.bold(`
+${formatMinutes(total)} across ${entries.length} entries`) + (proposed > 0 ? chalk3.yellow(`, ${proposed} proposed`) : "")
+  );
+}
+function outputTimeBatchJson(results) {
+  console.log(
+    JSON.stringify(
+      {
+        results: results.map((r) => ({
+          index: r.index,
+          success: r.success,
+          outcome: r.outcome ?? null,
+          sourceRef: r.sourceRef ?? r.entry?.sourceRef ?? null,
+          entry: r.entry ? transformTimeEntry(r.entry) : null,
+          error: r.error ?? null
+        })),
+        total: results.length,
+        succeeded: results.filter((r) => r.success).length,
+        failed: results.filter((r) => !r.success).length
+      },
+      null,
+      2
+    )
+  );
+}
+function outputTimeBatchPretty(results) {
+  for (const r of results) {
+    const ref = r.sourceRef ?? r.entry?.sourceRef ?? "";
+    if (r.success && r.entry) {
+      console.log(
+        `  ${chalk3.green("\u2713")} #${r.index}: ${chalk3.gray(r.outcome ?? "")} ${clock(r.entry.startedAt)}\u2013${r.entry.endedAt ? clock(r.entry.endedAt) : "now"} ${r.entry.action?.name ?? r.entry.actionId}${ref ? chalk3.gray(` ${ref}`) : ""}`
+      );
+    } else {
+      console.log(`  ${chalk3.red("\u2717")} #${r.index}: ${ref} \u2014 ${r.error ?? "failed"}`);
+    }
+  }
+  const ok = results.filter((r) => r.success).length;
+  console.log(chalk3.bold(`
+${ok}/${results.length} entries logged`));
+}
 
 // src/commands/actions.ts
 var VALID_PRIORITIES = [
@@ -2242,6 +2638,35 @@ function createActionsCommand() {
       handleError(error, useJson);
     }
   });
+  actions.command("upsert").description(
+    "One Action per external source: find by (--workspace, --source-type, --source-id), refresh its title and links, else create it. The Daily worklog uses --source-type claude-session --source-id <conversation id>."
+  ).requiredOption("--source-type <type>", "e.g. claude-session").requiredOption("--source-id <id>", "The source's own id; the same pair always maps to the same Action").requiredOption("-t, --title <title>", "Action title (refreshed on every call)").option("-w, --workspace <slug|id>", "Workspace (defaults to your default workspace)").option("-d, --description <text>", "Description").option("--project <id>", "Link to a project CUID in the same workspace").option("--ticket <id>", "Link to a ticket CUID whose product is in the same workspace").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const result = await client.actions.upsertBySource({
+          sourceType: options.sourceType,
+          sourceId: options.sourceId,
+          name: options.title,
+          workspaceId,
+          description: options.description,
+          projectId: options.project,
+          ticketId: options.ticket
+        });
+        if (useJson) {
+          outputActionUpsertJson(result);
+        } else {
+          console.log(result.outcome === "created" ? "Created action:" : "Updated action:");
+          outputActionPretty(result.action);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
   const comment = new Command2("comment").description("Manage comments on an action");
   comment.command("list").description("List comments on an action").requiredOption("--id <id>", "Action ID").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -2432,79 +2857,715 @@ function createContactsCommand() {
       handleError(error, useJson);
     }
   });
-  contacts.command("delete").description("Delete a contact").argument("<id>", "Contact ID").action(async (id, _options, cmd) => {
+  contacts.command("delete").description("Delete a contact").argument("<id>", "Contact ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      await client.contacts.delete(id);
+      if (useJson) {
+        console.log(JSON.stringify({ deleted: true, id }, null, 2));
+      } else {
+        console.log(`
+\u2713 Contact ${id} deleted`);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("add-interaction").description("Add an interaction to a contact").requiredOption("--contact <id>", "Contact ID").requiredOption("--type <type>", `Interaction type (${VALID_INTERACTION_TYPES.join(", ")})`).requiredOption("--direction <dir>", `Direction (${VALID_INTERACTION_DIRECTIONS.join(", ")})`).option("--subject <text>", "Subject line").option("--notes <text>", "Notes").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      if (!VALID_INTERACTION_TYPES.includes(options.type)) {
+        throw new Error(`Invalid interaction type "${options.type}". Valid: ${VALID_INTERACTION_TYPES.join(", ")}`);
+      }
+      if (!VALID_INTERACTION_DIRECTIONS.includes(options.direction)) {
+        throw new Error(`Invalid direction "${options.direction}". Valid: ${VALID_INTERACTION_DIRECTIONS.join(", ")}`);
+      }
+      const client = getClient();
+      const interaction = await client.contacts.addInteraction({
+        contactId: options.contact,
+        type: options.type,
+        direction: options.direction,
+        subject: options.subject,
+        notes: options.notes
+      });
+      if (useJson) {
+        outputInteractionJson(interaction);
+      } else {
+        console.log("\n\u2713 Interaction added");
+        outputInteractionPretty(interaction);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  contacts.command("enrich").description("Queue a web-search enrichment job for an existing contact (runs regardless of the workspace auto-enrich setting)").argument("<id>", "Contact ID").action(async (id, _options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const result = await client.contacts.enrich(id);
+      if (useJson) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.enqueued) {
+        console.log(`
+\u2713 Enrichment queued for contact ${id} (job ${result.enrichmentId})`);
+      } else if (result.reason === "already-in-flight") {
+        console.log(`
+\u2022 Enrichment already in progress for contact ${id} (job ${result.enrichmentId})`);
+      } else {
+        console.log(`
+\u2022 Not queued for contact ${id}${result.reason ? ` (${result.reason})` : ""}`);
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  return contacts;
+}
+
+// src/commands/decisions.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+
+// src/utils/input.ts
+import { readFileSync } from "fs";
+var stdinConsumed = false;
+function readText(inline, file) {
+  if (inline !== void 0) return inline;
+  if (file === void 0) return void 0;
+  if (file === "-") {
+    if (stdinConsumed) {
+      throw new Error('stdin ("-") can only back one option per invocation.');
+    }
+    stdinConsumed = true;
+    return readFileSync(0, "utf-8");
+  }
+  return readFileSync(file, "utf-8");
+}
+function parseDate(value) {
+  if (value === void 0 || value === "") return void 0;
+  const date = /^\d{4}-\d{2}-\d{2}$/.test(value) ? /* @__PURE__ */ new Date(`${value}T00:00:00`) : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(
+      `Invalid date: "${value}". Use ISO format, e.g. 2026-08-25 or 2026-08-25T14:00.`
+    );
+  }
+  return date;
+}
+
+// src/commands/decisions.ts
+var STATUSES = [
+  "OPEN",
+  "PROPOSED",
+  "ACCEPTED",
+  "SUPERSEDED",
+  "DEPRECATED"
+];
+var SOURCES = ["MEETING", "MANUAL", "AGENT"];
+var OPEN_QUESTION_NOTE = `An OPEN QUESTION is a decision with --status OPEN \u2014 there is no separate model, and that is exactly what a meeting's "Open questions" panel shows.`;
+function parseStatus(value) {
+  const upper = value.toUpperCase();
+  if (!STATUSES.includes(upper)) {
+    throw new Error(
+      `Invalid status "${value}". Use one of: ${STATUSES.join(", ")}. ${OPEN_QUESTION_NOTE}`
+    );
+  }
+  return upper;
+}
+function parseSource(value) {
+  const upper = value.toUpperCase();
+  if (!SOURCES.includes(upper)) {
+    throw new Error(
+      `Invalid source "${value}". Use one of: ${SOURCES.join(", ")}.`
+    );
+  }
+  return upper;
+}
+function parseDecider(spec) {
+  const angled = /^\s*(.*?)\s*<\s*([^>]+?)\s*>\s*$/.exec(spec);
+  if (angled) {
+    const name = angled[1]?.trim() ?? "";
+    const email = angled[2].trim();
+    return { name: name === "" ? email : name, email };
+  }
+  const bare = spec.trim();
+  if (bare === "") {
+    throw new Error('Empty --decider. Use "Name <email>", a name, or an email.');
+  }
+  if (bare.includes("@") && !bare.includes(" ")) {
+    return { name: bare, email: bare };
+  }
+  return { name: bare };
+}
+function parseEvidence(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `Evidence must be JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error(
+      "Evidence must be a JSON array of {turnIndex, speaker?, startTime?, text} objects."
+    );
+  }
+  return parsed.map((turn, i) => {
+    if (typeof turn !== "object" || turn === null) {
+      throw new Error(`Evidence[${i}] is not an object.`);
+    }
+    const t = turn;
+    if (typeof t.turnIndex !== "number" || typeof t.text !== "string") {
+      throw new Error(
+        `Evidence[${i}] needs a numeric "turnIndex" and a string "text".`
+      );
+    }
+    return {
+      turnIndex: t.turnIndex,
+      speaker: typeof t.speaker === "string" ? t.speaker : null,
+      startTime: typeof t.startTime === "number" ? t.startTime : null,
+      text: t.text
+    };
+  });
+}
+async function resolveProductFilter(client, workspaceId, value) {
+  if (value === void 0) return void 0;
+  if (value === "workspace") return "workspace";
+  return await resolveProductId(client, workspaceId, value);
+}
+function parsePositiveInt(v, flag) {
+  if (v === void 0) return void 0;
+  const n = Number.parseInt(v, 10);
+  if (Number.isNaN(n) || n < 1) {
+    throw new Error(`${flag} must be a positive integer, got "${v}".`);
+  }
+  return n;
+}
+function parseNullableString(v) {
+  if (v === void 0) return void 0;
+  return v === "null" ? null : v;
+}
+function parseNullableInt(v) {
+  if (v === void 0) return void 0;
+  if (v === "null") return null;
+  const n = Number.parseInt(v, 10);
+  if (Number.isNaN(n)) throw new Error(`Expected a number, got "${v}".`);
+  return n;
+}
+var BATCH_ITEM_KEYS = /* @__PURE__ */ new Set([
+  "statement",
+  "body",
+  "status",
+  "source",
+  "meeting",
+  "transcriptionSessionId",
+  "productId",
+  "projectId",
+  "goalId",
+  "keyResultId",
+  "occurrenceId",
+  "decidedAt",
+  "ownerId",
+  "deciders",
+  "evidence"
+]);
+function parseBatchFile(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `--from-file must be JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const items = Array.isArray(parsed) ? parsed : typeof parsed === "object" && parsed !== null && Array.isArray(parsed.decisions) ? parsed.decisions : null;
+  if (!items) {
+    throw new Error(
+      '--from-file must contain a JSON array of decisions, or {"decisions": [...]}.'
+    );
+  }
+  if (items.length === 0) {
+    throw new Error("--from-file contained no decisions.");
+  }
+  return items.map((item, i) => {
+    if (typeof item !== "object" || item === null) {
+      throw new Error(`Decision[${i}] is not an object.`);
+    }
+    const entry = item;
+    if (typeof entry.statement !== "string" || entry.statement.trim() === "") {
+      throw new Error(`Decision[${i}] needs a non-empty "statement".`);
+    }
+    const unknown = Object.keys(entry).filter(
+      (key) => !BATCH_ITEM_KEYS.has(key)
+    );
+    if (unknown.length > 0) {
+      throw new Error(
+        `Decision[${i}] has unknown field(s): ${unknown.join(", ")}. Accepted: ${[...BATCH_ITEM_KEYS].join(", ")}.`
+      );
+    }
+    if (entry.goalId !== void 0 && typeof entry.goalId !== "number") {
+      throw new Error(`Decision[${i}].goalId must be a number, not a string.`);
+    }
+    return entry;
+  });
+}
+function batchDeciders(value, index) {
+  if (value === void 0 || value === null) return void 0;
+  if (!Array.isArray(value)) {
+    throw new Error(`Decision[${index}].deciders must be an array.`);
+  }
+  return value.map((d) => {
+    if (typeof d === "string") return parseDecider(d);
+    if (typeof d === "object" && d !== null && typeof d.name === "string") {
+      const obj = d;
+      return {
+        name: obj.name,
+        email: typeof obj.email === "string" ? obj.email : null,
+        userId: typeof obj.userId === "string" ? obj.userId : null
+      };
+    }
+    throw new Error(
+      `Decision[${index}].deciders entries must be "Name <email>" strings or {name, email?} objects.`
+    );
+  });
+}
+function createDecisionsCommand() {
+  const decisions = new Command4("decisions").description(
+    [
+      "Log and manage decisions and open questions (the workspace Decision Log).",
+      "",
+      OPEN_QUESTION_NOTE,
+      "",
+      "Statuses: OPEN (an open question) \xB7 PROPOSED \xB7 ACCEPTED \xB7 SUPERSEDED \xB7 DEPRECATED.",
+      'SUPERSEDED and DEPRECATED are reached with "decisions status", never at creation.'
+    ].join("\n")
+  );
+  decisions.command("list").description(
+    `List decisions, newest decided first. Pass --status OPEN for open questions only. ${OPEN_QUESTION_NOTE}`
+  ).option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").option(
+    "--meeting <id>",
+    "One meeting's decisions and open questions (includes drafts if you can edit it)"
+  ).option(
+    "--status <status>",
+    "Filter by status (repeatable): OPEN, PROPOSED, ACCEPTED, SUPERSEDED, DEPRECATED",
+    (value, previous) => [...previous, parseStatus(value)],
+    []
+  ).option(
+    "--source <source>",
+    "Filter by source (repeatable): MEETING, MANUAL, AGENT",
+    (value, previous) => [...previous, parseSource(value)],
+    []
+  ).option("--product <slug|id>", 'Filter by product, or "workspace" for decisions with no product').option("--include-workspace-wide", "With --product: also include decisions that have no product").option("--project <id>", "Filter by project CUID").option("--search <text>", "Free-text over statement and body").option("--number <n>", "One decision by its workspace sequence number (D-0003 is 3)").option("--limit <n>", "Cap the rows returned (1-500)").option("--adr <id>", "Decisions formalised as this ADR document").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const client = getClient();
+        if (options.meeting) {
+          const result = await client.decisions.listForMeeting(options.meeting);
+          let rows2 = result.decisions;
+          if (options.status.length > 0) {
+            rows2 = rows2.filter((d) => options.status.includes(d.status));
+          }
+          if (options.source.length > 0) {
+            rows2 = rows2.filter((d) => options.source.includes(d.source));
+          }
+          if (useJson) {
+            outputDecisionsJson(rows2, {
+              meetingId: options.meeting,
+              workspaceId: result.workspaceId,
+              canLogDecision: result.canLogDecision
+            });
+          } else {
+            outputDecisionsPretty(rows2);
+            if (!result.canLogDecision) {
+              console.log(
+                chalk4.yellow(
+                  "You cannot log decisions on this meeting (no edit access, or it has no workspace)."
+                )
+              );
+            }
+          }
+          return;
+        }
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const rows = options.adr ? await client.decisions.listForAdr(workspaceId, options.adr) : await client.decisions.list({
+          workspaceId,
+          statuses: options.status.length > 0 ? options.status : void 0,
+          sources: options.source.length > 0 ? options.source : void 0,
+          productId: await resolveProductFilter(client, workspaceId, options.product),
+          includeWorkspaceWide: options.includeWorkspaceWide,
+          projectId: options.project,
+          search: options.search,
+          number: parsePositiveInt(options.number, "--number"),
+          limit: parsePositiveInt(options.limit, "--limit")
+        });
+        if (useJson) outputDecisionsJson(rows, { workspaceId });
+        else outputDecisionsPretty(rows);
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  decisions.command("get <id>").description("Show one decision in full: body, evidence, deciders, chain and links").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(async (id, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const decision = await client.decisions.get(workspaceId, id);
+      if (useJson) outputDecisionJson(decision);
+      else outputDecisionPretty(decision);
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  decisions.command("create").description(
+    [
+      "Log a decision, or an open question with --status OPEN.",
+      OPEN_QUESTION_NOTE,
+      "Bodies are Markdown: use --body-file <path> (or - for stdin) rather than a shell argument.",
+      "Bulk: --from-file <path|-> takes a JSON array of decisions; the other flags become its defaults."
+    ].join(" ")
+  ).option("-s, --statement <text>", "The decision, or the open question (max 500 chars)").option("-b, --body <markdown>", "Markdown detail: context, alternatives, consequences").option("--body-file <path>", 'Read the body from a file ("-" = stdin)').option("--status <status>", "OPEN (open question), PROPOSED (default) or ACCEPTED").option("--source <source>", "MEETING, MANUAL or AGENT").option("--meeting <id>", "Meeting (transcriptionSessionId) this came out of \u2014 needs edit access to it").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").option("--product <slug|id>", "Link to a product").option("--project <id>", "Link to a project CUID").option("--goal <id>", "Link to a goal (integer id)").option("--key-result <id>", "Link to a key result CUID").option("--occurrence <id>", "Link to a ceremony occurrence CUID").option("--decided-at <iso>", "When it was decided (e.g. 2026-09-10T14:00)").option("--owner <userId>", "Owner user ID").option(
+    '--decider <"Name <email>">',
+    "Someone who made the decision (repeatable); external people need no account",
+    (value, previous) => [...previous, parseDecider(value)],
+    []
+  ).option(
+    "--evidence-file <path>",
+    'JSON array of {turnIndex, text} transcript quotes ("-" = stdin). Needs --meeting: the server checks every quote against that transcript and silently drops the ones that do not match.'
+  ).option("--from-file <path>", 'Bulk create from a JSON array of decisions ("-" = stdin)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        if (!options.statement && !options.fromFile) {
+          throw new Error(
+            "Pass --statement <text>, or --from-file <path|-> for a bulk create."
+          );
+        }
+        if (options.statement && options.fromFile) {
+          throw new Error(
+            "--statement and --from-file are alternatives: the file carries the statements."
+          );
+        }
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = options.product ? await resolveProductId(client, workspaceId, options.product) : void 0;
+        const status = options.status ? parseStatus(options.status) : void 0;
+        const source = options.source ? parseSource(options.source) : void 0;
+        const decidedAt = parseDate(options.decidedAt);
+        const goalId = options.goal ? Number.parseInt(options.goal, 10) : void 0;
+        if (goalId !== void 0 && Number.isNaN(goalId)) {
+          throw new Error(`--goal must be an integer id, got "${options.goal}".`);
+        }
+        const defaults = {
+          workspaceId,
+          status,
+          source,
+          transcriptionSessionId: options.meeting,
+          productId,
+          projectId: options.project,
+          goalId,
+          keyResultId: options.keyResult,
+          occurrenceId: options.occurrence,
+          decidedAt,
+          ownerId: options.owner,
+          deciders: options.decider.length > 0 ? options.decider : void 0
+        };
+        if (options.fromFile) {
+          const perEntryOnly = [
+            options.body !== void 0 ? "--body" : null,
+            options.bodyFile !== void 0 ? "--body-file" : null,
+            options.evidenceFile !== void 0 ? "--evidence-file" : null
+          ].filter((flag) => flag !== null);
+          if (perEntryOnly.length > 0) {
+            throw new Error(
+              `${perEntryOnly.join(", ")} ${perEntryOnly.length === 1 ? "is" : "are"} per-decision content \u2014 put "body" and "evidence" on each entry in --from-file instead.`
+            );
+          }
+          const items = parseBatchFile(readText(void 0, options.fromFile));
+          const results = [];
+          for (const [index, item] of items.entries()) {
+            const statement = String(item.statement);
+            try {
+              const input = {
+                ...defaults,
+                statement,
+                body: typeof item.body === "string" ? item.body : void 0,
+                status: item.status !== void 0 ? parseStatus(String(item.status)) : defaults.status,
+                source: item.source !== void 0 ? parseSource(String(item.source)) : defaults.source,
+                transcriptionSessionId: typeof item.transcriptionSessionId === "string" ? item.transcriptionSessionId : typeof item.meeting === "string" ? item.meeting : defaults.transcriptionSessionId,
+                productId: typeof item.productId === "string" ? item.productId : defaults.productId,
+                projectId: typeof item.projectId === "string" ? item.projectId : defaults.projectId,
+                goalId: typeof item.goalId === "number" ? item.goalId : defaults.goalId,
+                keyResultId: typeof item.keyResultId === "string" ? item.keyResultId : defaults.keyResultId,
+                occurrenceId: typeof item.occurrenceId === "string" ? item.occurrenceId : defaults.occurrenceId,
+                decidedAt: typeof item.decidedAt === "string" ? parseDate(item.decidedAt) : defaults.decidedAt,
+                ownerId: typeof item.ownerId === "string" ? item.ownerId : defaults.ownerId,
+                deciders: batchDeciders(item.deciders, index) ?? defaults.deciders,
+                evidence: item.evidence === void 0 ? void 0 : parseEvidence(JSON.stringify(item.evidence))
+              };
+              if (input.evidence && !input.transcriptionSessionId) {
+                throw new Error(
+                  'Evidence is quotes from a meeting transcript, so this entry needs a "meeting" (or the --meeting flag).'
+                );
+              }
+              const decision2 = await client.decisions.create(input);
+              results.push({ index, success: true, decision: decision2, statement });
+            } catch (error) {
+              results.push({
+                index,
+                success: false,
+                statement,
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+          if (results.some((r) => !r.success)) process.exitCode = 1;
+          if (useJson) outputDecisionBatchJson(results);
+          else outputDecisionBatchPretty(results);
+          return;
+        }
+        const evidenceRaw = readText(void 0, options.evidenceFile);
+        if (evidenceRaw !== void 0 && !options.meeting) {
+          throw new Error(
+            "Evidence is quotes from a meeting transcript, so --evidence-file needs --meeting <id>."
+          );
+        }
+        const decision = await client.decisions.create({
+          ...defaults,
+          statement: options.statement,
+          body: readText(options.body, options.bodyFile),
+          deciders: options.decider.length > 0 ? options.decider : void 0,
+          evidence: evidenceRaw === void 0 ? void 0 : parseEvidence(evidenceRaw)
+        });
+        if (useJson) outputDecisionJson(decision);
+        else {
+          console.log(
+            `
+\u2713 ${decision.status === "OPEN" ? "Open question" : "Decision"} logged`
+          );
+          outputDecisionPretty(decision);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  decisions.command("update").description(
+    `Update a decision's content and scope; only the fields you pass are written. Status changes go through "decisions status".`
+  ).requiredOption("--id <id>", "Decision CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").option("-s, --statement <text>", "New statement").option("-b, --body <markdown>", 'New Markdown body (or "null" to clear)').option("--body-file <path>", 'Read the new body from a file ("-" = stdin)').option("--decided-at <iso>", 'When it was decided (or "null" to clear)').option("--owner <userId>", 'Owner user ID (or "null" to clear)').option("--product <slug|id>", 'Product (or "null" to detach)').option("--project <id>", 'Project CUID (or "null" to detach)').option("--goal <id>", 'Goal integer id (or "null" to detach)').option("--key-result <id>", 'Key result CUID (or "null" to detach)').option("--adr <id>", 'ADR document CUID (or "null" to detach)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const body = options.body === "null" ? null : readText(options.body, options.bodyFile);
+        const patch = {
+          statement: options.statement,
+          body,
+          decidedAt: options.decidedAt === "null" ? null : parseDate(options.decidedAt),
+          ownerId: parseNullableString(options.owner),
+          projectId: parseNullableString(options.project),
+          goalId: parseNullableInt(options.goal),
+          keyResultId: parseNullableString(options.keyResult),
+          adrDocumentId: parseNullableString(options.adr)
+        };
+        if (options.product === void 0 && Object.values(patch).every((v) => v === void 0)) {
+          throw new Error(
+            "Nothing to update. Pass at least one of --statement, --body, --body-file, --decided-at, --owner, --product, --project, --goal, --key-result, --adr."
+          );
+        }
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const productId = options.product === void 0 ? void 0 : options.product === "null" ? null : await resolveProductId(client, workspaceId, options.product);
+        const decision = await client.decisions.update({
+          workspaceId,
+          decisionId: options.id,
+          ...patch,
+          productId
+        });
+        if (useJson) outputDecisionJson(decision);
+        else {
+          console.log("\n\u2713 Decision updated");
+          outputDecisionPretty(decision);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  decisions.command("status").description(
+    "Move a decision through its lifecycle \u2014 including answering an open question by moving it from OPEN to ACCEPTED."
+  ).requiredOption("--id <id>", "Decision CUID").requiredOption(
+    "--status <status>",
+    "OPEN, PROPOSED, ACCEPTED, SUPERSEDED or DEPRECATED"
+  ).option("--superseded-by <id>", "The decision that replaced this one (with --status SUPERSEDED)").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const status = parseStatus(options.status);
+        if (status === "SUPERSEDED" && !options.supersededBy) {
+          throw new Error(
+            "--status SUPERSEDED needs --superseded-by <id>: the decision that replaced this one."
+          );
+        }
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const decision = await client.decisions.setStatus({
+          workspaceId,
+          decisionId: options.id,
+          status,
+          supersededById: options.supersededBy
+        });
+        if (useJson) outputDecisionJson(decision);
+        else {
+          console.log(`
+\u2713 Decision is now ${decision.status}`);
+          outputDecisionPretty(decision);
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  decisions.command("link").description("Record what implements a decision: a ticket or a feature. Idempotent.").requiredOption("--id <id>", "Decision CUID").option("--ticket <id>", "Ticket CUID").option("--feature <id>", "Feature CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        if (!options.ticket && !options.feature) {
+          throw new Error("Pass --ticket <id> or --feature <id>.");
+        }
+        if (options.ticket && options.feature) {
+          throw new Error("Pass one of --ticket or --feature, not both.");
+        }
+        const client = getClient();
+        const workspaceId = await resolveWorkspaceId(client, options.workspace);
+        const link = options.ticket ? await client.decisions.linkTicket(workspaceId, options.id, options.ticket) : await client.decisions.linkFeature(workspaceId, options.id, options.feature);
+        if (useJson) console.log(JSON.stringify(link, null, 2));
+        else {
+          console.log(`\u2713 Linked ${chalk4.gray(`(link id ${link.id})`)}`);
+          console.log(
+            chalk4.gray("  Remove it with: exponential decisions unlink --link " + link.id)
+          );
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  decisions.command("unlink").description(
+    'Remove one "implemented by" link. Takes the LINK id (shown by "decisions get"), not the ticket or feature id.'
+  ).requiredOption("--link <id>", "DecisionLink CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      await client.decisions.unlink(workspaceId, options.link);
+      if (useJson) console.log(JSON.stringify({ deleted: true, linkId: options.link }, null, 2));
+      else console.log("\u2713 Link removed");
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  const drafts = new Command4("draft").description(
+    "Review decisions an agent proposed but nobody has confirmed yet (visible only on their source meeting)"
+  );
+  drafts.command("extract").description(
+    "Propose draft decisions from a meeting's notes and transcript, for someone to confirm. Idempotent: existing drafts are returned rather than regenerated, and a meeting that already has confirmed decisions is left alone."
+  ).requiredOption("--meeting <id>", "Meeting CUID (transcriptionSessionId)").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      const client = getClient();
+      const result = await client.decisions.extractDrafts(options.meeting);
+      if (useJson) console.log(JSON.stringify(result, null, 2));
+      else {
+        if (result.alreadyPublished) {
+          console.log(
+            chalk4.gray("This meeting already has confirmed decisions \u2014 nothing was extracted.")
+          );
+        } else if (result.alreadyDrafted) {
+          console.log(chalk4.gray("Returning the drafts this meeting already had."));
+        }
+        console.log(
+          `\u2713 ${result.draftCount} draft${result.draftCount === 1 ? "" : "s"} awaiting review (${result.draftsCreated} new)`
+        );
+        if (result.discardedWithoutEvidence > 0) {
+          console.log(
+            chalk4.gray(
+              `  ${result.discardedWithoutEvidence} candidate(s) dropped \u2014 no transcript turn supported them.`
+            )
+          );
+        }
+        for (const message of result.errors) console.log(chalk4.yellow(`  ${message}`));
+      }
+    } catch (error) {
+      handleError(error, useJson);
+    }
+  });
+  drafts.command("confirm").description("Publish a draft decision into the log").requiredOption("--id <id>", "Decision CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
     try {
       const client = getClient();
-      await client.contacts.delete(id);
-      if (useJson) {
-        console.log(JSON.stringify({ deleted: true, id }, null, 2));
-      } else {
-        console.log(`
-\u2713 Contact ${id} deleted`);
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const decision = await client.decisions.confirmDraft(workspaceId, options.id);
+      if (useJson) outputDecisionJson(decision);
+      else {
+        console.log("\n\u2713 Draft confirmed");
+        outputDecisionPretty(decision);
       }
     } catch (error) {
       handleError(error, useJson);
     }
   });
-  contacts.command("add-interaction").description("Add an interaction to a contact").requiredOption("--contact <id>", "Contact ID").requiredOption("--type <type>", `Interaction type (${VALID_INTERACTION_TYPES.join(", ")})`).requiredOption("--direction <dir>", `Direction (${VALID_INTERACTION_DIRECTIONS.join(", ")})`).option("--subject <text>", "Subject line").option("--notes <text>", "Notes").action(async (options, cmd) => {
+  drafts.command("reject").description(
+    'Reject a draft. A confirmed decision is never rejected \u2014 deprecate or supersede it with "decisions status".'
+  ).requiredOption("--id <id>", "Decision CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
     try {
-      if (!VALID_INTERACTION_TYPES.includes(options.type)) {
-        throw new Error(`Invalid interaction type "${options.type}". Valid: ${VALID_INTERACTION_TYPES.join(", ")}`);
-      }
-      if (!VALID_INTERACTION_DIRECTIONS.includes(options.direction)) {
-        throw new Error(`Invalid direction "${options.direction}". Valid: ${VALID_INTERACTION_DIRECTIONS.join(", ")}`);
-      }
       const client = getClient();
-      const interaction = await client.contacts.addInteraction({
-        contactId: options.contact,
-        type: options.type,
-        direction: options.direction,
-        subject: options.subject,
-        notes: options.notes
-      });
-      if (useJson) {
-        outputInteractionJson(interaction);
-      } else {
-        console.log("\n\u2713 Interaction added");
-        outputInteractionPretty(interaction);
-      }
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const result = await client.decisions.rejectDraft(workspaceId, options.id);
+      if (useJson) console.log(JSON.stringify(result, null, 2));
+      else console.log("\u2713 Draft rejected");
     } catch (error) {
       handleError(error, useJson);
     }
   });
-  contacts.command("enrich").description("Queue a web-search enrichment job for an existing contact (runs regardless of the workspace auto-enrich setting)").argument("<id>", "Contact ID").action(async (id, _options, cmd) => {
+  drafts.command("delete").description(
+    "Permanently delete a draft or rejected decision. Confirmed decisions are never deleted."
+  ).requiredOption("--id <id>", "Decision CUID").option("--workspace <slug|id>", "Workspace (defaults to your default workspace)").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
     try {
       const client = getClient();
-      const result = await client.contacts.enrich(id);
-      if (useJson) {
-        console.log(JSON.stringify(result, null, 2));
-      } else if (result.enqueued) {
-        console.log(`
-\u2713 Enrichment queued for contact ${id} (job ${result.enrichmentId})`);
-      } else if (result.reason === "already-in-flight") {
-        console.log(`
-\u2022 Enrichment already in progress for contact ${id} (job ${result.enrichmentId})`);
-      } else {
-        console.log(`
-\u2022 Not queued for contact ${id}${result.reason ? ` (${result.reason})` : ""}`);
-      }
+      const workspaceId = await resolveWorkspaceId(client, options.workspace);
+      const result = await client.decisions.deleteDraft(workspaceId, options.id);
+      if (useJson) console.log(JSON.stringify({ deleted: true, ...result }, null, 2));
+      else console.log("\u2713 Draft deleted");
     } catch (error) {
       handleError(error, useJson);
     }
   });
-  return contacts;
+  decisions.addCommand(drafts);
+  return decisions;
 }
 
 // src/commands/deals.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 function createDealsCommand() {
-  const deals = new Command4("deals").description("Manage pipeline deals");
+  const deals = new Command5("deals").description("Manage pipeline deals");
   deals.command("pipeline").description("Get pipeline overview with stages").requiredOption("--workspace <id>", "Workspace ID").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -2689,36 +3750,7 @@ function createDealsCommand() {
 }
 
 // src/commands/epics.ts
-import { Command as Command5 } from "commander";
-
-// src/utils/resolve.ts
-async function resolveWorkspaceId(client, slugOrId) {
-  return (await resolveWorkspace(client, slugOrId)).id;
-}
-async function resolveWorkspace(client, slugOrId) {
-  const config = getConfig();
-  const candidate = slugOrId ?? config.defaultWorkspaceSlug ?? config.defaultWorkspaceId;
-  if (!candidate) {
-    throw new Error(
-      "No workspace specified and no default workspace set. Pass --workspace <slug> or run `exponential workspaces set-default <slug>`."
-    );
-  }
-  const workspaces = await client.workspaces.list();
-  const byId = workspaces.find((w) => w.id === candidate);
-  if (byId) return byId;
-  const bySlug = workspaces.find((w) => w.slug === candidate);
-  if (bySlug) return bySlug;
-  const known = workspaces.map((w) => w.slug).join(", ");
-  throw new Error(
-    `Workspace "${candidate}" not found. Available: ${known || "(none)"}`
-  );
-}
-async function resolveProductId(client, workspaceId, slugOrId) {
-  const product = await client.products.resolve(workspaceId, slugOrId);
-  return product.id;
-}
-
-// src/commands/epics.ts
+import { Command as Command6 } from "commander";
 var EPIC_STATUSES = ["OPEN", "IN_PROGRESS", "DONE", "CANCELLED"];
 var EPIC_PRIORITIES = ["HIGH", "MEDIUM", "LOW", "NONE"];
 function validateEpicStatus(value) {
@@ -2737,7 +3769,7 @@ function validateEpicPriority(value) {
   }
   return value;
 }
-function parseDate(value) {
+function parseDate2(value) {
   if (!value) return void 0;
   const d = new Date(value);
   if (isNaN(d.getTime())) {
@@ -2746,7 +3778,7 @@ function parseDate(value) {
   return d;
 }
 function createEpicsCommand() {
-  const epics = new Command5("epics").description(
+  const epics = new Command6("epics").description(
     "Manage epics. Epics are workspace-scoped and group actions and tickets across products."
   );
   epics.command("list").description("List epics in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID").option("--status <status>", `Filter by status: ${EPIC_STATUSES.join(", ")}`).action(
@@ -2783,8 +3815,8 @@ function createEpicsCommand() {
       const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
       try {
         const priority = validateEpicPriority(options.priority);
-        const startDate = parseDate(options.start);
-        const targetDate = parseDate(options.target);
+        const startDate = parseDate2(options.start);
+        const targetDate = parseDate2(options.target);
         const client = getClient();
         const workspaceId = await resolveWorkspaceId(client, options.workspace);
         const epic = await client.epics.create({
@@ -2846,10 +3878,10 @@ function createEpicsCommand() {
 }
 
 // src/commands/features.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/stories.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) {
@@ -2858,7 +3890,7 @@ async function readStdin() {
   return Buffer.concat(chunks).toString("utf-8");
 }
 function createStoriesCommand() {
-  const stories = new Command6("stories").description(
+  const stories = new Command7("stories").description(
     "Manage a feature's native, structured user stories (As a / I want / So that)."
   );
   stories.command("add").description(
@@ -2956,7 +3988,7 @@ function createStoriesCommand() {
 }
 
 // src/commands/scopes.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 var SCOPE_STATUSES = [
   "PLANNED",
   "IN_PROGRESS",
@@ -2973,7 +4005,7 @@ function validateScopeStatus(value) {
   return value;
 }
 function createScopesCommand() {
-  const scopes = new Command7("scopes").description(
+  const scopes = new Command8("scopes").description(
     `Manage a feature's scopes: shippable increments ("V1", "V2"), each with its own lifecycle.`
   );
   scopes.command("list").description("List a feature's scopes").requiredOption("--feature <id>", "Feature CUID").action(
@@ -3052,7 +4084,7 @@ function createScopesCommand() {
 }
 
 // src/commands/requirements.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 var REQUIREMENT_KINDS = [
   "FUNCTIONAL",
   "NON_FUNCTIONAL",
@@ -3075,7 +4107,7 @@ async function readStdin2() {
   return Buffer.concat(chunks).toString("utf-8");
 }
 function createRequirementsCommand() {
-  const requirements = new Command8("requirements").description(
+  const requirements = new Command9("requirements").description(
     `Manage a feature's requirements: atomic, testable EARS-style "shall" statements, checkable met/unmet.`
   );
   requirements.command("add").description(
@@ -3206,25 +4238,25 @@ function createRequirementsCommand() {
 }
 
 // src/commands/areas.ts
-import { Command as Command9 } from "commander";
-import chalk4 from "chalk";
+import { Command as Command10 } from "commander";
+import chalk5 from "chalk";
 function outputAreasPretty(areas) {
   if (areas.length === 0) {
-    console.log(chalk4.gray("No areas found."));
+    console.log(chalk5.gray("No areas found."));
     return;
   }
-  console.log(chalk4.bold(`
+  console.log(chalk5.bold(`
 Areas (${areas.length} total)`));
-  console.log(chalk4.gray("\u2500".repeat(50)));
+  console.log(chalk5.gray("\u2500".repeat(50)));
   for (const a of areas) {
-    const count = a._count?.features != null ? chalk4.gray(` (${a._count.features} features)`) : "";
-    console.log(`  ${chalk4.bold(a.name)}${count}`);
-    console.log(chalk4.gray(`    ID: ${a.id}`));
+    const count = a._count?.features != null ? chalk5.gray(` (${a._count.features} features)`) : "";
+    console.log(`  ${chalk5.bold(a.name)}${count}`);
+    console.log(chalk5.gray(`    ID: ${a.id}`));
   }
   console.log();
 }
 function createAreasCommand() {
-  const areas = new Command9("areas").description(
+  const areas = new Command10("areas").description(
     "Manage a product's areas: the buckets features are filed under (a feature has exactly one or none)."
   );
   areas.command("list").description("List a product's areas").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").action(
@@ -3268,7 +4300,7 @@ function createAreasCommand() {
 }
 
 // src/commands/featureComments.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/utils/mentions.ts
 function candidateLabels(member) {
@@ -3341,7 +4373,7 @@ function collectMention(value, previous) {
 
 // src/commands/featureComments.ts
 function createFeatureCommentsCommand() {
-  const comment = new Command10("comment").description(
+  const comment = new Command11("comment").description(
     "Read and post comments on a feature. Mention teammates with --mention."
   );
   comment.command("list").description("List comments on a feature").requiredOption("--feature <id>", "Feature ID").action(async (options, cmd) => {
@@ -3542,7 +4574,7 @@ function validateFeatureStatus(value) {
   return value;
 }
 function createFeaturesCommand() {
-  const features = new Command11("features").description(
+  const features = new Command12("features").description(
     "Manage features. A feature lives under a product and groups user stories, scopes, and tickets."
   );
   features.command("list").description("List features in a product").requiredOption("--product <slug|id>", "Product slug or CUID").option("--workspace <slug|id>", "Workspace (required when --product is a slug)").option("--status <status>", `Filter by status: ${FEATURE_STATUSES.join(", ")}`).action(
@@ -3799,8 +4831,8 @@ Aborted: ${reason}. Feature "${feature.name}" was NOT deleted.`);
 }
 
 // src/commands/labels.ts
-import { Command as Command12 } from "commander";
-import chalk5 from "chalk";
+import { Command as Command13 } from "commander";
+import chalk6 from "chalk";
 var TRIAGE_LABELS = [
   { slug: "needs-triage", name: "needs-triage", color: "avatar-orange" },
   { slug: "needs-info", name: "needs-info", color: "avatar-yellow" },
@@ -3814,22 +4846,22 @@ function looksLikeCuid(value) {
 }
 function outputTagsPretty(tags) {
   if (tags.length === 0) {
-    console.log(chalk5.dim("No labels found."));
+    console.log(chalk6.dim("No labels found."));
     return;
   }
   console.log();
   for (const tag of tags) {
-    const scope = tag.workspaceId === null ? chalk5.cyan("global") : chalk5.magenta("workspace");
-    const category = tag.category === null ? chalk5.dim("(label)") : chalk5.dim(`(${tag.category})`);
+    const scope = tag.workspaceId === null ? chalk6.cyan("global") : chalk6.magenta("workspace");
+    const category = tag.category === null ? chalk6.dim("(label)") : chalk6.dim(`(${tag.category})`);
     console.log(
-      `  ${chalk5.bold(tag.slug)}  ${tag.name}  ${chalk5.gray(tag.color)}  ${scope}  ${category}`
+      `  ${chalk6.bold(tag.slug)}  ${tag.name}  ${chalk6.gray(tag.color)}  ${scope}  ${category}`
     );
   }
   console.log();
 }
 function outputTagPretty(tag, prefix) {
   if (prefix) console.log(prefix);
-  console.log(`  ${chalk5.bold(tag.slug)}  ${tag.name}  ${chalk5.gray(tag.color)}`);
+  console.log(`  ${chalk6.bold(tag.slug)}  ${tag.name}  ${chalk6.gray(tag.color)}`);
 }
 async function resolveLabelIds(client, workspaceId, values) {
   if (values.length === 0) return [];
@@ -3853,7 +4885,7 @@ async function resolveLabelIds(client, workspaceId, values) {
   return [...byId, ...resolvedFromSlugs];
 }
 function createLabelsCommand() {
-  const labels = new Command12("labels").description(
+  const labels = new Command13("labels").description(
     "Manage labels (orthogonal tags applied to actions, tickets, features, and epics)."
   );
   labels.command("list").description("List labels visible in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID").option(
@@ -3901,7 +4933,7 @@ function createLabelsCommand() {
         if (useJson) {
           console.log(JSON.stringify(tag, null, 2));
         } else {
-          outputTagPretty(tag, chalk5.green("\n\u2713 Label created"));
+          outputTagPretty(tag, chalk6.green("\n\u2713 Label created"));
         }
       } catch (error) {
         handleError(error, useJson);
@@ -3939,10 +4971,10 @@ function createLabelsCommand() {
           console.log(JSON.stringify(results, null, 2));
         } else {
           console.log();
-          console.log(chalk5.bold("Triage labels:"));
+          console.log(chalk6.bold("Triage labels:"));
           for (const r of results) {
-            const tag = chalk5.bold(r.slug);
-            const status = r.status === "created" ? chalk5.green("created") : chalk5.dim("existed");
+            const tag = chalk6.bold(r.slug);
+            const status = r.status === "created" ? chalk6.green("created") : chalk6.dim("existed");
             console.log(`  ${tag}  ${status}`);
           }
           console.log();
@@ -3956,38 +4988,10 @@ function createLabelsCommand() {
 }
 
 // src/commands/meetings.ts
-import { Command as Command13 } from "commander";
-import chalk6 from "chalk";
-
-// src/utils/input.ts
-import { readFileSync } from "fs";
-var stdinConsumed = false;
-function readText(inline, file) {
-  if (inline !== void 0) return inline;
-  if (file === void 0) return void 0;
-  if (file === "-") {
-    if (stdinConsumed) {
-      throw new Error('stdin ("-") can only back one option per invocation.');
-    }
-    stdinConsumed = true;
-    return readFileSync(0, "utf-8");
-  }
-  return readFileSync(file, "utf-8");
-}
-function parseDate2(value) {
-  if (value === void 0 || value === "") return void 0;
-  const date = /^\d{4}-\d{2}-\d{2}$/.test(value) ? /* @__PURE__ */ new Date(`${value}T00:00:00`) : new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(
-      `Invalid date: "${value}". Use ISO format, e.g. 2026-08-25 or 2026-08-25T14:00.`
-    );
-  }
-  return date;
-}
-
-// src/commands/meetings.ts
+import { Command as Command14 } from "commander";
+import chalk7 from "chalk";
 function createMeetingsCommand() {
-  const meetings = new Command13("meetings").description(
+  const meetings = new Command14("meetings").description(
     "Manage meetings and their notes (recorded, imported, or manually created)"
   );
   meetings.command("list").description(
@@ -4048,7 +5052,7 @@ function createMeetingsCommand() {
           transcription,
           notes: readText(options.notes, options.notesFile),
           description: options.description,
-          meetingDate: parseDate2(options.date),
+          meetingDate: parseDate(options.date),
           projectId: options.project,
           workspaceId
         });
@@ -4082,7 +5086,7 @@ function createMeetingsCommand() {
           notes: notes2,
           summary: options.summary,
           description: options.description,
-          meetingDate: parseDate2(options.date)
+          meetingDate: parseDate(options.date)
         });
         if (useJson) outputMeetingJson(meeting);
         else {
@@ -4094,7 +5098,72 @@ function createMeetingsCommand() {
       }
     }
   );
-  const notes = new Command13("notes").description(
+  meetings.command("delete [ids...]").description(
+    'Permanently delete meetings you own. Pass one or more ids, and/or --ids-file with whitespace-separated ids ("-" = stdin). Deleting more than one id requires --force. Exit 0 only when everything requested was deleted.'
+  ).option("--ids-file <path>", 'Read whitespace-separated meeting ids from a file ("-" = stdin)').option("--force", "Confirm deleting more than one meeting in a single call").action(
+    async (idArgs, options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const fromFile = readText(void 0, options.idsFile);
+        const ids = [
+          ...new Set([
+            ...idArgs,
+            ...fromFile ? fromFile.split(/\s+/) : []
+          ].filter((id) => id !== ""))
+        ];
+        if (ids.length === 0) {
+          throw new Error(
+            "Nothing to delete. Pass one or more meeting ids, or --ids-file <path|->."
+          );
+        }
+        const malformed = ids.filter((id) => !/^[a-z][a-z0-9]{15,}$/i.test(id));
+        if (malformed.length > 0) {
+          throw new Error(
+            `These don't look like meeting ids: ${malformed.slice(0, 5).join(", ")}${malformed.length > 5 ? ` (+${malformed.length - 5} more)` : ""}. Nothing was deleted.`
+          );
+        }
+        if (ids.length > 1 && !options.force) {
+          throw new Error(
+            `Refusing to delete ${ids.length} meetings without --force. Deletion is permanent.`
+          );
+        }
+        const client = getClient();
+        let count;
+        if (ids.length === 1) {
+          await client.meetings.delete(ids[0]);
+          count = 1;
+        } else {
+          count = 0;
+          for (let i = 0; i < ids.length; i += 500) {
+            const chunk = ids.slice(i, i + 500);
+            count += (await client.meetings.deleteMany(chunk)).count;
+          }
+        }
+        const skipped = ids.length - count;
+        if (skipped > 0) {
+          process.exitCode = 1;
+        }
+        if (useJson) {
+          console.log(
+            JSON.stringify({ requested: ids.length, count, skipped }, null, 2)
+          );
+        } else {
+          console.log(`\u2713 Deleted ${count} of ${ids.length} meeting${ids.length === 1 ? "" : "s"}`);
+          if (skipped > 0) {
+            console.log(
+              chalk7.yellow(
+                `${skipped} id(s) were skipped \u2014 not found, or not owned by you.`
+              )
+            );
+          }
+        }
+      } catch (error) {
+        handleError(error, useJson);
+      }
+    }
+  );
+  const notes = new Command14("notes").description(
     "Read and write a meeting's notes"
   );
   notes.command("get <id>").description(
@@ -4110,7 +5179,7 @@ function createMeetingsCommand() {
         process.stdout.write(body.endsWith("\n") ? body : `${body}
 `);
       } else if (process.stdout.isTTY) {
-        console.log(chalk6.gray("No notes yet."));
+        console.log(chalk7.gray("No notes yet."));
       }
     } catch (error) {
       handleError(error, shouldUseJson(globalOpts.json, globalOpts.pretty));
@@ -4159,7 +5228,7 @@ function createMeetingsCommand() {
 }
 
 // src/commands/organizations.ts
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 var VALID_SIZES = [
   "1-10",
   "11-50",
@@ -4169,7 +5238,7 @@ var VALID_SIZES = [
   "1000+"
 ];
 function createOrganizationsCommand() {
-  const organizations = new Command14("organizations").alias("orgs").description("Manage CRM organizations");
+  const organizations = new Command15("organizations").alias("orgs").description("Manage CRM organizations");
   organizations.command("list").description("List organizations").requiredOption("--workspace <id>", "Workspace ID").option("--search <query>", "Search by name or description").option("--industry <industry>", "Filter by industry").option("--limit <n>", "Max results to return", parseInt).option("--cursor <cursor>", "Pagination cursor").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -4237,12 +5306,12 @@ function createOrganizationsCommand() {
 }
 
 // src/commands/pages.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/pageComments.ts
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 function createPageCommentsCommand() {
-  const comment = new Command15("comment").description(
+  const comment = new Command16("comment").description(
     "Read and post comments on a page. Mention teammates with --mention."
   );
   comment.command("list").description("List comments on a page").requiredOption("--page <id>", "Page ID").action(async (options, cmd) => {
@@ -4337,7 +5406,7 @@ function createPageCommentsCommand() {
 
 // src/commands/pages.ts
 function createPagesCommand() {
-  const pages = new Command16("pages").description(
+  const pages = new Command17("pages").description(
     'Manage Knowledge pages (PRDs, research, technical specs). Link one to a feature with "features link-page".'
   );
   pages.command("list").description("List pages in a workspace").option("--workspace <slug|id>", "Workspace (defaults to the configured default)").option("--search <text>", "Filter by title/content").action(
@@ -4420,9 +5489,9 @@ function createPagesCommand() {
 }
 
 // src/commands/products.ts
-import { Command as Command17 } from "commander";
+import { Command as Command18 } from "commander";
 function createProductsCommand() {
-  const products = new Command17("products").description(
+  const products = new Command18("products").description(
     "Manage products. A workspace contains products; a product holds features and tickets."
   );
   products.command("list").description("List products in a workspace").option("--workspace <slug|id>", "Workspace slug or CUID (defaults to configured workspace)").action(async (options, cmd) => {
@@ -4485,7 +5554,7 @@ function createProductsCommand() {
 }
 
 // src/commands/projects.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 var PROJECT_STATUSES = [
   "ACTIVE",
   "ON_HOLD",
@@ -4512,7 +5581,7 @@ function validateProjectPriority(value) {
   return value;
 }
 function createProjectsCommand() {
-  const projects = new Command18("projects").description("Manage projects");
+  const projects = new Command19("projects").description("Manage projects");
   projects.command("list").description("List all projects").option("--workspace <slug|id>", "Workspace slug or CUID").option("--include-actions", "Include actions in output").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -4631,8 +5700,8 @@ Re-run with --force to delete it anyway.`
 }
 
 // src/commands/search.ts
-import { Command as Command19 } from "commander";
-import chalk7 from "chalk";
+import { Command as Command20 } from "commander";
+import chalk8 from "chalk";
 var TYPE_LABELS = {
   workspace: "Workspaces",
   project: "Projects",
@@ -4650,7 +5719,7 @@ var TYPE_LABELS = {
   product: "Products"
 };
 function createSearchCommand() {
-  const search = new Command19("search").description(
+  const search = new Command20("search").description(
     "Global search across projects, actions, goals, workspaces and more \u2014 same coverage as the app's Cmd+K palette"
   ).argument("<query>", "Text to search for").option("-w, --workspace <slug>", "Restrict results to one workspace (slug or ID)").option("-l, --limit <n>", "Max results per entity type (1-25, default 10)").action(async (query, options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -4664,10 +5733,10 @@ function createSearchCommand() {
           (w) => w.slug === options.workspace || w.id === options.workspace
         );
         if (!match) {
-          console.error(chalk7.red(`Workspace "${options.workspace}" not found.`));
-          console.log(chalk7.gray("Available workspaces:"));
+          console.error(chalk8.red(`Workspace "${options.workspace}" not found.`));
+          console.log(chalk8.gray("Available workspaces:"));
           workspaces.forEach((w) => {
-            console.log(chalk7.gray(`  - ${w.slug} (${w.name})`));
+            console.log(chalk8.gray(`  - ${w.slug} (${w.name})`));
           });
           process.exit(1);
         }
@@ -4680,7 +5749,7 @@ function createSearchCommand() {
         return;
       }
       if (result.results.length === 0) {
-        console.log(chalk7.gray(`No matches for "${result.query}".`));
+        console.log(chalk8.gray(`No matches for "${result.query}".`));
         return;
       }
       const byType = /* @__PURE__ */ new Map();
@@ -4690,14 +5759,14 @@ function createSearchCommand() {
         byType.set(r.type, bucket);
       }
       for (const [type, rows] of byType) {
-        console.log(chalk7.bold(`
+        console.log(chalk8.bold(`
 ${TYPE_LABELS[type] ?? type}`));
         for (const row of rows) {
-          const parts = [chalk7.white(row.title)];
-          if (row.subtitle) parts.push(chalk7.gray(row.subtitle));
-          if (row.workspace) parts.push(chalk7.cyan(`@${row.workspace.slug}`));
-          console.log(`  ${parts.join(chalk7.gray(" \xB7 "))}`);
-          console.log(chalk7.gray(`    ${row.id}${row.url ? `  ${row.url}` : ""}`));
+          const parts = [chalk8.white(row.title)];
+          if (row.subtitle) parts.push(chalk8.gray(row.subtitle));
+          if (row.workspace) parts.push(chalk8.cyan(`@${row.workspace.slug}`));
+          console.log(`  ${parts.join(chalk8.gray(" \xB7 "))}`);
+          console.log(chalk8.gray(`    ${row.id}${row.url ? `  ${row.url}` : ""}`));
         }
       }
       console.log();
@@ -4709,7 +5778,7 @@ ${TYPE_LABELS[type] ?? type}`));
 }
 
 // src/commands/tickets.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 function collectRepeatable(value, previous) {
   return [...previous, value];
 }
@@ -4752,7 +5821,7 @@ function validateTicketType(value) {
   return value;
 }
 function createTicketsCommand() {
-  const tickets = new Command20("tickets").description(
+  const tickets = new Command21("tickets").description(
     "Manage product backlog tickets. Tickets live under a product, link to features/epics, depend on each other, and can be implemented via actions."
   );
   tickets.command("list").description(
@@ -4933,7 +6002,7 @@ function createTicketsCommand() {
       const globalOpts = cmd.optsWithGlobals();
       const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
       try {
-        const parseNullableInt = (v) => {
+        const parseNullableInt2 = (v) => {
           if (v === void 0) return void 0;
           if (v === "null") return null;
           const n = parseInt(v, 10);
@@ -4947,7 +6016,7 @@ function createTicketsCommand() {
           if (isNaN(n)) throw new Error(`Invalid number: ${v}`);
           return n;
         };
-        const parseNullableString = (v) => {
+        const parseNullableString2 = (v) => {
           if (v === void 0) return void 0;
           if (v === "null") return null;
           return v;
@@ -4961,14 +6030,14 @@ function createTicketsCommand() {
           body: options.body,
           type,
           status,
-          priority: parseNullableInt(options.priority),
+          priority: parseNullableInt2(options.priority),
           points: parseNullableFloat(options.points),
-          featureId: parseNullableString(options.feature),
-          epicId: parseNullableString(options.epic),
-          cycleId: parseNullableString(options.cycle),
-          assigneeId: parseNullableString(options.assignee),
-          branchName: parseNullableString(options.branch),
-          prUrl: parseNullableString(options.pr)
+          featureId: parseNullableString2(options.feature),
+          epicId: parseNullableString2(options.epic),
+          cycleId: parseNullableString2(options.cycle),
+          assigneeId: parseNullableString2(options.assignee),
+          branchName: parseNullableString2(options.branch),
+          prUrl: parseNullableString2(options.pr)
         });
         if (options.addLabel.length > 0 || options.removeLabel.length > 0) {
           const current = await client.labels.listForEntity({
@@ -5078,7 +6147,7 @@ function createTicketsCommand() {
       handleError(error, useJson);
     }
   });
-  const comment = new Command20("comment").description("Manage comments on a ticket");
+  const comment = new Command21("comment").description("Manage comments on a ticket");
   comment.command("list").description("List comments on a ticket").requiredOption("--id <id>", "Ticket CUID").action(async (options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -5169,11 +6238,187 @@ function createTicketsCommand() {
   return tickets;
 }
 
+// src/commands/time.ts
+import { Command as Command22 } from "commander";
+var SOURCES2 = ["manual", "claude-desktop", "agent-run"];
+var STATUSES2 = ["PROPOSED", "CONFIRMED"];
+var OWNERSHIP_NOTE = "Run with an external-agent key, the entry belongs to the agent's OWNER and is always PROPOSED; a personal token logs your own time, CONFIRMED by default.";
+function parseSource2(value) {
+  const lower = value.toLowerCase();
+  if (!SOURCES2.includes(lower)) {
+    throw new Error(`Invalid source "${value}". Use one of: ${SOURCES2.join(", ")}.`);
+  }
+  return lower;
+}
+function parseStatus2(value) {
+  const upper = value.toUpperCase();
+  if (!STATUSES2.includes(upper)) {
+    throw new Error(`Invalid status "${value}". Use one of: ${STATUSES2.join(", ")}.`);
+  }
+  return upper;
+}
+var BATCH_ITEM_KEYS2 = /* @__PURE__ */ new Set([
+  "actionId",
+  "action",
+  "startedAt",
+  "from",
+  "endedAt",
+  "to",
+  "source",
+  "status",
+  "sourceRef",
+  "ref",
+  "note"
+]);
+function parseBatchFile2(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(
+      `--from-file must be JSON: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const items = Array.isArray(parsed) ? parsed : typeof parsed === "object" && parsed !== null && Array.isArray(parsed.entries) ? parsed.entries : null;
+  if (!items) {
+    throw new Error('--from-file must contain a JSON array of entries, or {"entries": [...]}.');
+  }
+  if (items.length === 0) {
+    throw new Error("--from-file contained no entries.");
+  }
+  return items.map((item, i) => {
+    if (typeof item !== "object" || item === null) {
+      throw new Error(`Entry[${i}] is not an object.`);
+    }
+    const entry = item;
+    const unknown = Object.keys(entry).filter((key) => !BATCH_ITEM_KEYS2.has(key));
+    if (unknown.length > 0) {
+      throw new Error(
+        `Entry[${i}] has unknown field(s): ${unknown.join(", ")}. Accepted: ${[...BATCH_ITEM_KEYS2].join(", ")}.`
+      );
+    }
+    return entry;
+  });
+}
+function optionalString(value, label, index) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`Entry[${index}].${label} must be a string.`);
+  return value;
+}
+function batchItemToInput(item, index, defaults) {
+  const actionId = optionalString(item.actionId ?? item.action, "actionId", index) ?? defaults.actionId;
+  const from = optionalString(item.startedAt ?? item.from, "startedAt", index);
+  const to = optionalString(item.endedAt ?? item.to, "endedAt", index);
+  const startedAt = from !== void 0 ? parseDate(from) : defaults.startedAt;
+  const endedAt = to !== void 0 ? parseDate(to) : defaults.endedAt;
+  if (!actionId) throw new Error(`Entry[${index}] needs an "actionId" (or the --action flag).`);
+  if (!startedAt || !endedAt) {
+    throw new Error(`Entry[${index}] needs "startedAt" and "endedAt" (or --from and --to).`);
+  }
+  const source = optionalString(item.source, "source", index);
+  const status = optionalString(item.status, "status", index);
+  return {
+    actionId,
+    startedAt,
+    endedAt,
+    source: source !== void 0 ? parseSource2(source) : defaults.source,
+    status: status !== void 0 ? parseStatus2(status) : defaults.status,
+    sourceRef: optionalString(item.sourceRef ?? item.ref, "sourceRef", index) ?? defaults.sourceRef,
+    note: optionalString(item.note, "note", index) ?? defaults.note
+  };
+}
+function createTimeCommand() {
+  const time = new Command22("time").description(
+    `Time entries \u2014 log the day's work and list it. ${OWNERSHIP_NOTE}`
+  );
+  time.command("log").description(
+    [
+      "Log one completed entry with explicit bounds; the running Timer is never touched.",
+      "With --ref the write is idempotent per owner: a re-run updates a PROPOSED entry and leaves a CONFIRMED one alone.",
+      "Bulk: --from-file <path|-> takes a JSON array of entries; the other flags become its defaults.",
+      OWNERSHIP_NOTE
+    ].join(" ")
+  ).option("-a, --action <id>", "Action CUID the time was spent on").option("--from <iso>", "Start, e.g. 2026-09-11T09:22").option("--to <iso>", "End, e.g. 2026-09-11T10:30").option("--source <source>", `${SOURCES2.join(", ")} (default: manual)`).option("--status <status>", "PROPOSED or CONFIRMED (ignored under an agent key: always PROPOSED)").option("--ref <sourceRef>", "Idempotency key, e.g. claude-session:<sessionId>#<segment>").option("--note <text>", "One line shown in the day view and list row").option("--from-file <path>", 'Bulk log from a JSON array of entries ("-" = stdin)').action(
+    async (options, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+      try {
+        const defaults = {
+          actionId: options.action,
+          startedAt: parseDate(options.from),
+          endedAt: parseDate(options.to),
+          source: options.source ? parseSource2(options.source) : void 0,
+          status: options.status ? parseStatus2(options.status) : void 0,
+          sourceRef: options.ref,
+          note: options.note
+        };
+        const client = getClient();
+        if (options.fromFile) {
+          if (options.ref !== void 0) {
+            throw new Error(
+              '--ref is per-entry: a shared sourceRef would make every entry overwrite the last. Put "sourceRef" on each entry in --from-file instead.'
+            );
+          }
+          const items = parseBatchFile2(readText(void 0, options.fromFile));
+          const inputs = items.map((item, i) => {
+            try {
+              return batchItemToInput(item, i, defaults);
+            } catch (error) {
+              return error instanceof Error ? error : new Error(String(error));
+            }
+          });
+          const results = [];
+          for (const [index, input] of inputs.entries()) {
+            if (input instanceof Error) {
+              results.push({ index, success: false, error: input.message });
+              continue;
+            }
+            const [result2] = await client.time.logBatch([input]);
+            results.push({ ...result2, index });
+          }
+          if (results.some((r) => !r.success)) process.exitCode = 1;
+          if (useJson) outputTimeBatchJson(results);
+          else outputTimeBatchPretty(results);
+          return;
+        }
+        if (!defaults.actionId) throw new Error("Pass --action <id>, or --from-file <path|-> for a batch.");
+        if (!defaults.startedAt || !defaults.endedAt) throw new Error("Pass both --from <iso> and --to <iso>.");
+        if (defaults.endedAt.getTime() <= defaults.startedAt.getTime()) {
+          throw new Error("--to must be after --from.");
+        }
+        const result = await client.time.log(defaults);
+        if (useJson) outputTimeLogJson(result);
+        else outputTimeLogPretty(result);
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+  time.command("list").description("One day's entries for the signed-in user, oldest first, each with its PROPOSED/CONFIRMED status").requiredOption("-d, --date <YYYY-MM-DD>", "The day (local time)").option("-w, --workspace <slug|id>", "Only entries in this workspace (default: all)").option("--proposed", "Only PROPOSED entries").action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
+    try {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(options.date)) {
+        throw new Error(`--date must be YYYY-MM-DD, got "${options.date}".`);
+      }
+      const client = getClient();
+      const workspaceId = options.workspace ? await resolveWorkspaceId(client, options.workspace) : void 0;
+      let entries = await client.time.list(options.date, workspaceId);
+      if (options.proposed) entries = entries.filter((e) => e.status === "PROPOSED");
+      if (useJson) outputTimeEntriesJson(entries, options.date);
+      else outputTimeEntriesPretty(entries, options.date);
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  return time;
+}
+
 // src/commands/workspaces.ts
-import { Command as Command21 } from "commander";
-import chalk8 from "chalk";
+import { Command as Command23 } from "commander";
+import chalk9 from "chalk";
 function createWorkspacesCommand() {
-  const workspaces = new Command21("workspaces").description("Manage workspaces");
+  const workspaces = new Command23("workspaces").description("Manage workspaces");
   workspaces.command("list").description("List all workspaces").action(async (_options, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
     const useJson = shouldUseJson(globalOpts.json, globalOpts.pretty);
@@ -5186,7 +6431,7 @@ function createWorkspacesCommand() {
         const config = getConfig();
         outputWorkspacesPretty(workspaces2);
         if (config.defaultWorkspaceSlug) {
-          console.log(chalk8.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
+          console.log(chalk9.gray(`Default workspace: ${config.defaultWorkspaceSlug}`));
         }
       }
     } catch (error) {
@@ -5199,10 +6444,10 @@ function createWorkspacesCommand() {
       const workspaces2 = await client.workspaces.list();
       const workspace = workspaces2.find((w) => w.slug === slug);
       if (!workspace) {
-        console.error(chalk8.red(`Workspace with slug "${slug}" not found.`));
-        console.log(chalk8.gray("Available workspaces:"));
+        console.error(chalk9.red(`Workspace with slug "${slug}" not found.`));
+        console.log(chalk9.gray("Available workspaces:"));
         workspaces2.forEach((w) => {
-          console.log(chalk8.gray(`  - ${w.slug} (${w.name})`));
+          console.log(chalk9.gray(`  - ${w.slug} (${w.name})`));
         });
         process.exit(1);
       }
@@ -5210,7 +6455,7 @@ function createWorkspacesCommand() {
         defaultWorkspaceId: workspace.id,
         defaultWorkspaceSlug: workspace.slug
       });
-      console.log(chalk8.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
+      console.log(chalk9.green(`Default workspace set to: ${workspace.name} (${workspace.slug})`));
     } catch (error) {
       handleError(error);
     }
@@ -5238,20 +6483,20 @@ function createWorkspacesCommand() {
           return;
         }
         if (members.length === 0) {
-          console.log(chalk8.gray("No members found."));
+          console.log(chalk9.gray("No members found."));
           return;
         }
-        console.log(chalk8.bold(`
+        console.log(chalk9.bold(`
 Members (${members.length})
 `));
         for (const m of members) {
           const label = m.name ?? m.email ?? m.id;
-          const via = m.source === "team" ? chalk8.gray(
+          const via = m.source === "team" ? chalk9.gray(
             ` via team${m.teams.length ? `: ${m.teams.map((t) => t.name).join(", ")}` : ""}` + (m.teamRole ? ` [team ${m.teamRole}]` : "")
           ) : "";
-          console.log(`${chalk8.bold(label)} ${chalk8.gray(`(${m.role})`)}${via}`);
-          if (m.email) console.log(chalk8.gray(`  ${m.email}`));
-          console.log(chalk8.gray(`  mention: ${m.mentionSyntax}`));
+          console.log(`${chalk9.bold(label)} ${chalk9.gray(`(${m.role})`)}${via}`);
+          if (m.email) console.log(chalk9.gray(`  ${m.email}`));
+          console.log(chalk9.gray(`  mention: ${m.mentionSyntax}`));
           console.log();
         }
       } catch (error) {
@@ -5263,7 +6508,7 @@ Members (${members.length})
 }
 
 // src/commands/goals.ts
-import { Command as Command22 } from "commander";
+import { Command as Command24 } from "commander";
 var GOAL_STATUSES = [
   "planned",
   "active",
@@ -5375,7 +6620,7 @@ function validateKeyResultUnit(value) {
   return value;
 }
 function createKeyResultsCommand() {
-  const kr = new Command22("kr").description(
+  const kr = new Command24("kr").description(
     "Key results on an objective. Ids are CUIDs; --goal takes the objective's integer id."
   );
   kr.command("list").description("List key results").option("--goal <id>", "Objective ID (a number)").option("-w, --workspace <slug|id>", "Workspace (workspace-wide: every member's KRs)").option("--period <period>", "Period, e.g. Q3-2026").option("--status <status>", `Filter by status: ${KEY_RESULT_STATUSES.join(", ")}`).option("--mine", "Narrow a workspace list to key results you own").action(
@@ -5578,7 +6823,7 @@ function createKeyResultsCommand() {
   return kr;
 }
 function createGoalCommentsCommand() {
-  const comment = new Command22("comment").description(
+  const comment = new Command24("comment").description(
     "Read and post comments on a goal. Mention teammates with --mention."
   );
   comment.command("list").description("List comments on a goal").requiredOption("--goal <id>", "Goal ID (a number)").action(async (options, cmd) => {
@@ -5673,7 +6918,7 @@ function createGoalCommentsCommand() {
   return comment;
 }
 function createGoalsCommand() {
-  const goals = new Command22("goals").description(
+  const goals = new Command24("goals").description(
     "Manage goals (objectives) and their key results. Objectives have integer ids; key results are CUIDs."
   );
   goals.command("list").description(
@@ -5939,7 +7184,7 @@ Re-run with --with-key-results to go ahead, or move them with \`goals kr update
   return goals;
 }
 function createOkrsCommand() {
-  const okrs = new Command22("okrs").description(
+  const okrs = new Command24("okrs").description(
     "OKRs \u2014 objectives with their key results nested. Manage the parts with `goals` and `goals kr`."
   );
   okrs.command("list").description(
@@ -6016,39 +7261,54 @@ function createOkrsCommand() {
   return okrs;
 }
 
-// src/index.ts
+// src/program.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 var PKG_VERSION = JSON.parse(
   readFileSync2(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8")
 ).version;
-var program = new Command23();
-program.name("exponential").description(
-  [
-    "CLI to interact with Exponential productivity app.",
-    "",
-    "Work-tracking hierarchy:",
-    "  workspace -> product -> feature -> ticket -> action",
-    "  epics are workspace-scoped and can group tickets and actions across products."
-  ].join("\n")
-).version(PKG_VERSION).option("--json", "Output as JSON (default when piped)").option("--pretty", "Force pretty-printed output");
-program.addCommand(createAuthCommand());
-program.addCommand(createActionsCommand());
-program.addCommand(createContactsCommand());
-program.addCommand(createDealsCommand());
-program.addCommand(createEpicsCommand());
-program.addCommand(createFeaturesCommand());
-program.addCommand(createLabelsCommand());
-program.addCommand(createMeetingsCommand());
-program.addCommand(createOrganizationsCommand());
-program.addCommand(createPagesCommand());
-program.addCommand(createProductsCommand());
-program.addCommand(createProjectsCommand());
-program.addCommand(createSearchCommand());
-program.addCommand(createTicketsCommand());
-program.addCommand(createWorkspacesCommand());
-program.addCommand(createGoalsCommand());
-program.addCommand(createOkrsCommand());
-program.parse();
+var CLI_VERSION_FLAGS = "-V, --cli-version";
+function isBareVersionRequest(args) {
+  return args.includes("--version") && args.every((arg) => arg.startsWith("-"));
+}
+function buildProgram() {
+  const program = new Command25();
+  program.name("exponential").description(
+    [
+      "CLI to interact with Exponential productivity app.",
+      "",
+      "Work-tracking hierarchy:",
+      "  workspace -> product -> feature -> ticket -> action",
+      "  epics are workspace-scoped and can group tickets and actions across products."
+    ].join("\n")
+  ).version(PKG_VERSION, CLI_VERSION_FLAGS, "Output the CLI version").option("--json", "Output as JSON (default when piped)").option("--pretty", "Force pretty-printed output");
+  program.addCommand(createAuthCommand());
+  program.addCommand(createActionsCommand());
+  program.addCommand(createContactsCommand());
+  program.addCommand(createDecisionsCommand());
+  program.addCommand(createDealsCommand());
+  program.addCommand(createEpicsCommand());
+  program.addCommand(createFeaturesCommand());
+  program.addCommand(createLabelsCommand());
+  program.addCommand(createMeetingsCommand());
+  program.addCommand(createOrganizationsCommand());
+  program.addCommand(createPagesCommand());
+  program.addCommand(createProductsCommand());
+  program.addCommand(createProjectsCommand());
+  program.addCommand(createSearchCommand());
+  program.addCommand(createTicketsCommand());
+  program.addCommand(createTimeCommand());
+  program.addCommand(createWorkspacesCommand());
+  program.addCommand(createGoalsCommand());
+  program.addCommand(createOkrsCommand());
+  return program;
+}
+
+// src/index.ts
+if (isBareVersionRequest(process.argv.slice(2))) {
+  console.log(PKG_VERSION);
+} else {
+  buildProgram().parse();
+}
 //# sourceMappingURL=index.js.map