jiradc-cli 1.0.32 → 1.0.34

package/README.md

@@ -17,6 +17,11 @@ export JIRA_TOKEN="your-personal-access-token" # HTTP Access Token from Jira
 
 ## Breaking changes in this release
 
+- **`field options` is removed.** It called a Jira 9 endpoint and returned 404 for every field on Jira 8.x. Jira scopes a custom field's options to a context, so there is no context-free replacement — use `issue createmeta --project <key> --type <name>` (create screen), `issue editmeta <key>` (edit screen), or `issue transitions <key>` (transition screen).
+- **`issue transitions` no longer reports `required`** on screen fields. Jira reports field-configuration requiredness there, which cannot see the workflow validator that actually gates the transition, so it returned `false` for fields that then rejected the transition. Supply everything in a transition's `fields` block. (`required` from `createmeta`/`editmeta` reflects field configuration and is reliable.)
+- **`issue get` / `issue search` return issue-picker custom fields as a bare key string** (or an array of keys) instead of the whole nested issue. `fields.customfield_NNNNN.key` becomes `fields.customfield_NNNNN`.
+- **`issue create --custom-fields` is now `--fields`**, matching `issue update`. The old name still works as a deprecated alias.
+- **Argument mistakes now exit 2/3/6** (`usage`/`not_found`/`auth`) instead of 1.
 - `issue transitions` now returns a bare JSON array of transitions (previously wrapped in `{ transitions: [...] }`). Each transition is reduced to `{ id, name, to, fields? }` — verbose fields like `to.iconUrl`, `to.statusCategory`, `isGlobal`, `isInitial`, `isConditional`, `hasScreen` are stripped.
 - `component list` now requires `--project <key>` instead of a positional `<projectKey>` argument.
 - `issue link-epic` is now variadic on the issue argument: `link-epic <issueKey...> --epic <epicKey>`. Single-issue calls keep working.
@@ -27,88 +32,89 @@ All commands output JSON. Add `--pretty` to pretty-print.
 
 ### issue
 
-| Command | Description |
-|---------|-------------|
-| `jiradc issue get <key>` | Get issue details (`--fields` to select, `--expand` for changelog/transitions) |
-| `jiradc issue search <jql>` | Search issues with JQL |
-| `jiradc issue create` | Create an issue (`--project`, `--type`, `--summary`, `--description`, `--custom-fields`) |
-| `jiradc issue update <key>` | Update an issue (`--summary`, `--description`, `--priority`, `--assignee`, `--labels`, `--components`, `--fix-versions`, or `--fields` JSON) |
-| `jiradc issue delete <key>` | Delete an issue |
-| `jiradc issue assign <key> <user>` | Assign issue (user can be a username, `me`, or `none` to unassign) |
-| `jiradc issue transition <key>` | Transition issue to a new status (`--to` accepts ID or status name, `--comment` to add a note) |
-| `jiradc issue transitions <key>` | List available transitions |
-| `jiradc issue comment add <key>` | Add a comment (`--body`) |
-| `jiradc issue comment edit <key>` | Edit a comment (`--id`, `--body`) |
-| `jiradc issue comment delete <key>` | Delete a comment (`--id`) |
-| `jiradc issue link <key> <targetKey>` | Link two issues (`--type` link type name) |
-| `jiradc issue unlink <linkId>` | Remove a link |
-| `jiradc issue link-types` | List available link types |
-| `jiradc issue link-epic <keys...>` | Link one or more issues to an epic (`--epic <epicKey>`) |
-| `jiradc issue worklog add <key>` | Add a work log entry (`--time`, `--comment`, `--started`) |
-| `jiradc issue worklog list <key>` | Get work log entries |
-| `jiradc issue worklog edit <key>` | Update a work log entry (`--id`, `--time`, `--comment`, `--started`, `--adjust-estimate`, `--new-estimate`) |
-| `jiradc issue worklog delete <key>` | Delete a work log entry (`--id`, `--adjust-estimate`, `--new-estimate`, `--increase-by`) |
-| `jiradc issue changelog <key>` | Get issue changelog |
-| `jiradc issue batch-changelog` | Get changelog for multiple issues (`--keys`) |
-| `jiradc issue clone <key>` | Clone an issue with subtasks |
-| `jiradc issue batch-create` | Create multiple issues from JSON |
-| `jiradc issue dev-status <key>` | Get development status (branches, PRs, commits) |
+| Command                               | Description                                                                                                                                  |
+| ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `jiradc issue get <key>`              | Get issue details (`--fields` to select, `--expand` for changelog/transitions)                                                               |
+| `jiradc issue search <jql>`           | Search issues with JQL                                                                                                                       |
+| `jiradc issue create`                 | Create an issue (`--project`, `--type`, `--summary`, `--description`, `--custom-fields`)                                                     |
+| `jiradc issue update <key>`           | Update an issue (`--summary`, `--description`, `--priority`, `--assignee`, `--labels`, `--components`, `--fix-versions`, or `--fields` JSON) |
+| `jiradc issue delete <key>`           | Delete an issue                                                                                                                              |
+| `jiradc issue assign <key> <user>`    | Assign issue (user can be a username, `me`, or `none` to unassign)                                                                           |
+| `jiradc issue transition <key>`       | Transition issue to a new status (`--to` accepts ID or status name, `--comment` to add a note)                                               |
+| `jiradc issue transitions <key>`      | List available transitions (with any fields their screens require)                                                                           |
+| `jiradc issue createmeta`             | Fields a new issue accepts, with allowed values (`--project`, `--type`)                                                                      |
+| `jiradc issue editmeta <key>`         | Fields an existing issue's edit screen accepts, with allowed values                                                                          |
+| `jiradc issue comment add <key>`      | Add a comment (`--body`)                                                                                                                     |
+| `jiradc issue comment edit <key>`     | Edit a comment (`--id`, `--body`)                                                                                                            |
+| `jiradc issue comment delete <key>`   | Delete a comment (`--id`)                                                                                                                    |
+| `jiradc issue link <key> <targetKey>` | Link two issues (`--type` link type name)                                                                                                    |
+| `jiradc issue unlink <linkId>`        | Remove a link                                                                                                                                |
+| `jiradc issue link-types`             | List available link types                                                                                                                    |
+| `jiradc issue link-epic <keys...>`    | Link one or more issues to an epic (`--epic <epicKey>`)                                                                                      |
+| `jiradc issue worklog add <key>`      | Add a work log entry (`--time`, `--comment`, `--started`)                                                                                    |
+| `jiradc issue worklog list <key>`     | Get work log entries                                                                                                                         |
+| `jiradc issue worklog edit <key>`     | Update a work log entry (`--id`, `--time`, `--comment`, `--started`, `--adjust-estimate`, `--new-estimate`)                                  |
+| `jiradc issue worklog delete <key>`   | Delete a work log entry (`--id`, `--adjust-estimate`, `--new-estimate`, `--increase-by`)                                                     |
+| `jiradc issue changelog <key>`        | Get issue changelog                                                                                                                          |
+| `jiradc issue batch-changelog`        | Get changelog for multiple issues (`--keys`)                                                                                                 |
+| `jiradc issue clone <key>`            | Clone an issue with subtasks                                                                                                                 |
+| `jiradc issue batch-create`           | Create multiple issues from JSON                                                                                                             |
+| `jiradc issue dev-status <key>`       | Get development status (branches, PRs, commits)                                                                                              |
 
 #### issue attachment
 
-| Command | Description |
-|---------|-------------|
-| `jiradc issue attachment list <key>` | List attachments |
+| Command                                                 | Description                    |
+| ------------------------------------------------------- | ------------------------------ |
+| `jiradc issue attachment list <key>`                    | List attachments               |
 | `jiradc issue attachment download <key> <attachmentId>` | Download a specific attachment |
-| `jiradc issue attachment download-all <key>` | Download all attachments |
-| `jiradc issue attachment upload <key> <files...>` | Upload files |
-| `jiradc issue attachment delete <attachmentId>` | Delete an attachment |
+| `jiradc issue attachment download-all <key>`            | Download all attachments       |
+| `jiradc issue attachment upload <key> <files...>`       | Upload files                   |
+| `jiradc issue attachment delete <attachmentId>`         | Delete an attachment           |
 
 ### project
 
-| Command | Description |
-|---------|-------------|
-| `jiradc project list` | List projects |
+| Command                         | Description                 |
+| ------------------------------- | --------------------------- |
+| `jiradc project list`           | List projects               |
 | `jiradc project versions <key>` | List versions for a project |
 
 ### component
 
-| Command | Description |
-|---------|-------------|
-| `jiradc component list` | List components for a project (`--project <key>`) |
-| `jiradc component get <id>` | Get a component by ID |
-| `jiradc component create` | Create a component (`--project`, `--name`, `--description`, `--lead`) |
-| `jiradc component update <id>` | Update a component |
-| `jiradc component issue-count <id>` | Get the number of issues using a component |
+| Command                             | Description                                                           |
+| ----------------------------------- | --------------------------------------------------------------------- |
+| `jiradc component list`             | List components for a project (`--project <key>`)                     |
+| `jiradc component get <id>`         | Get a component by ID                                                 |
+| `jiradc component create`           | Create a component (`--project`, `--name`, `--description`, `--lead`) |
+| `jiradc component update <id>`      | Update a component                                                    |
+| `jiradc component issue-count <id>` | Get the number of issues using a component                            |
 
 ### board
 
-| Command | Description |
-|---------|-------------|
-| `jiradc board list` | List boards (`--project`, `--type`: scrum/kanban/simple, `--name`) |
-| `jiradc board issues <boardId>` | Get issues on a board |
+| Command                         | Description                                                        |
+| ------------------------------- | ------------------------------------------------------------------ |
+| `jiradc board list`             | List boards (`--project`, `--type`: scrum/kanban/simple, `--name`) |
+| `jiradc board issues <boardId>` | Get issues on a board                                              |
 
 ### sprint
 
-| Command | Description |
-|---------|-------------|
-| `jiradc sprint list <boardId>` | List sprints (`--state`: future/active/closed) |
-| `jiradc sprint issues <boardId> <sprintId>` | Get issues in a sprint |
-| `jiradc sprint create <boardId>` | Create a sprint |
-| `jiradc sprint update <sprintId>` | Update a sprint |
-| `jiradc sprint delete <sprintId>` | Delete a sprint (returns its issues to the backlog) |
+| Command                                     | Description                                         |
+| ------------------------------------------- | --------------------------------------------------- |
+| `jiradc sprint list <boardId>`              | List sprints (`--state`: future/active/closed)      |
+| `jiradc sprint issues <boardId> <sprintId>` | Get issues in a sprint                              |
+| `jiradc sprint create <boardId>`            | Create a sprint                                     |
+| `jiradc sprint update <sprintId>`           | Update a sprint                                     |
+| `jiradc sprint delete <sprintId>`           | Delete a sprint (returns its issues to the backlog) |
 
 ### field
 
-| Command | Description |
-|---------|-------------|
-| `jiradc field search` | Search for fields (`--query`, `--type`: custom/system) |
-| `jiradc field options <fieldKey>` | Get allowed values for a field (`--project`, `--issue-type`) |
+| Command                         | Description                                                                   |
+| ------------------------------- | ----------------------------------------------------------------------------- |
+| `jiradc field search <keyword>` | Search for fields by name or ID (returns name + type, **not** allowed values) |
 
 ### user
 
-| Command | Description |
-|---------|-------------|
+| Command          | Description           |
+| ---------------- | --------------------- |
 | `jiradc user me` | Get current user info |
 
 ## Pagination

package/dist/index.js

@@ -4,6 +4,45 @@
 import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+var DEFAULT_TTL = 36e5;
+function getCacheDir(name) {
+  return join(homedir(), ".cache", name);
+}
+function getCachePath(name, key) {
+  return join(getCacheDir(name), `${key}.json`);
+}
+function cacheGet(options, key) {
+  const ttl = options.ttl ?? DEFAULT_TTL;
+  const path = getCachePath(options.name, key);
+  try {
+    const stat = statSync(path);
+    if (Date.now() - stat.mtimeMs > ttl)
+      return null;
+    const raw = readFileSync(path, "utf-8");
+    const entry = JSON.parse(raw);
+    return entry.data;
+  } catch {
+    return null;
+  }
+}
+function cacheSet(options, key, data) {
+  const dir = getCacheDir(options.name);
+  const path = getCachePath(options.name, key);
+  const entry = { data, timestamp: Date.now() };
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path, JSON.stringify(entry));
+  } catch {
+  }
+}
+async function cacheGetOrFetch(options, key, fetcher) {
+  const cached = cacheGet(options, key);
+  if (cached !== null)
+    return cached;
+  const data = await fetcher();
+  cacheSet(options, key, data);
+  return data;
+}
 
 // ../../cli-utils/dist/bootstrap.js
 import { readFileSync as readFileSync2 } from "fs";
@@ -239,6 +278,7 @@ var CliAuthError = class extends Error {
 };
 var NOT_FOUND_RECOVERY = "Verify the id/key, then check your access.";
 var NOT_FOUND_MESSAGE = "Not found: it may not exist, or you may not have permission to see it";
+var USAGE_RECOVERY = "Check the command syntax and flags; run the command with --help.";
 var CliNotFoundError = class extends Error {
   recovery;
   constructor(message, recovery = NOT_FOUND_RECOVERY) {
@@ -247,6 +287,16 @@ var CliNotFoundError = class extends Error {
     this.recovery = recovery;
   }
 };
+var CliUsageError = class extends Error {
+  recovery;
+  detail;
+  constructor(message, recovery = USAGE_RECOVERY, detail) {
+    super(message);
+    this.name = "CliUsageError";
+    this.recovery = recovery;
+    this.detail = detail;
+  }
+};
 var SubcommandRequiredError = class extends Error {
   subcommands;
   constructor(commandPath3, subcommands) {
@@ -255,6 +305,16 @@ var SubcommandRequiredError = class extends Error {
     this.subcommands = subcommands;
   }
 };
+var UnknownSubcommandError = class extends Error {
+  subcommands;
+  suggestion;
+  constructor(commandPath3, token, subcommands, suggestion) {
+    super(`'${token}' is not a subcommand of '${commandPath3}'`);
+    this.name = "UnknownSubcommandError";
+    this.subcommands = subcommands;
+    this.suggestion = suggestion;
+  }
+};
 var TYPE_EXIT = {
   usage: EXIT.USAGE,
   not_found: EXIT.NOT_FOUND,
@@ -357,12 +417,31 @@ function normalize(err, opts) {
       detail: { subcommands: err.subcommands }
     };
   }
+  if (err instanceof UnknownSubcommandError) {
+    const didYouMean = err.suggestion === void 0 ? "" : `Did you mean '${err.suggestion}'? `;
+    return {
+      type: "usage",
+      message,
+      recovery: `${didYouMean}Valid subcommands: ${err.subcommands.join(", ")}.`,
+      retryable: false,
+      detail: { subcommands: err.subcommands }
+    };
+  }
   if (err instanceof CliAuthError) {
     return { type: "auth", message: message || "Missing credentials", recovery: opts.authRecovery, retryable: false };
   }
   if (err instanceof CliNotFoundError) {
     return { type: "not_found", message, recovery: err.recovery, retryable: false };
   }
+  if (err instanceof CliUsageError) {
+    return {
+      type: "usage",
+      message,
+      recovery: err.recovery,
+      retryable: false,
+      ...err.detail !== void 0 ? { detail: err.detail } : {}
+    };
+  }
   const status = httpStatus(err);
   const detail = responseDetail(err);
   if (status !== void 0) {
@@ -548,11 +627,39 @@ function attachSubcommandGuards(cmd) {
   const hasAction = Boolean(cmd._actionHandler);
   if (hasAction)
     return;
-  cmd.action(() => {
+  cmd.allowExcessArguments(true);
+  cmd.action((...params) => {
+    const invoked = params[params.length - 1];
     const names = cmd.commands.map((c) => c.name()).filter((name) => name !== "help");
-    throw new SubcommandRequiredError(commandPath2(cmd), names);
+    const [token] = invoked.args;
+    if (token === void 0)
+      throw new SubcommandRequiredError(commandPath2(cmd), names);
+    throw new UnknownSubcommandError(commandPath2(cmd), token, names, suggestSubcommand(token, names));
   });
 }
+function editDistance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      row[j] = Math.min(row[j - 1] + 1, prev[j] + 1, substitution);
+    }
+    prev = row;
+  }
+  return prev[b.length];
+}
+function suggestSubcommand(token, names) {
+  const MAX_EDITS = 2;
+  let best;
+  for (const name of names) {
+    const distance = editDistance(token.toLowerCase(), name.toLowerCase());
+    if (distance <= MAX_EDITS && distance < token.length && (!best || distance < best.distance)) {
+      best = { name, distance };
+    }
+  }
+  return best?.name;
+}
 async function runCli(program, opts) {
   routeErrors(program);
   attachSubcommandGuards(program);
@@ -568,7 +675,7 @@ async function runCli(program, opts) {
 
 // src/program.ts
 import { styleText } from "util";
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/commands/board/issues.ts
 import { Argument } from "commander";
@@ -623,9 +730,28 @@ function transformUser(user) {
 function transformField(field) {
   return field;
 }
-function transformCustomFieldOption(option) {
-  const { self: _self, ...rest } = option;
-  return rest;
+
+// src/utils/transformers/field-meta.ts
+function slimAllowedValue(raw) {
+  const out = {};
+  if (typeof raw.id === "string") out.id = raw.id;
+  if (typeof raw.name === "string") out.name = raw.name;
+  if (typeof raw.value === "string") out.value = raw.value;
+  if (Array.isArray(raw.children) && raw.children.length > 0) out.children = raw.children.map(slimAllowedValue);
+  return out;
+}
+function transformFieldMetaEntry(id, meta) {
+  const out = { id, required: meta.required === true };
+  if (typeof meta.name === "string") out.name = meta.name;
+  if (typeof meta.schema?.type === "string") out.type = meta.schema.type;
+  if (Array.isArray(meta.allowedValues) && meta.allowedValues.length > 0) {
+    out.allowedValues = meta.allowedValues.map(slimAllowedValue);
+  }
+  return out;
+}
+function transformFieldMeta(fields) {
+  const entries = Object.entries(fields).map(([id, meta]) => transformFieldMetaEntry(id, meta));
+  return [...entries.filter((f) => f.required), ...entries.filter((f) => !f.required)];
 }
 
 // src/utils/transformers/project.ts
@@ -766,12 +892,22 @@ function transformIssueLink(l) {
     ...outwardIssue ? { outwardIssue: transformIssueBasic(outwardIssue) } : {}
   };
 }
+function customFieldNames(names, fields) {
+  if (!names) return void 0;
+  const kept = Object.entries(names).filter(
+    ([id]) => id.startsWith("customfield_") && fields[id] !== void 0
+  );
+  return kept.length > 0 ? Object.fromEntries(kept) : void 0;
+}
 function transformIssue(issue) {
-  const { self: _self, expand: _expand, names: _names, schema: _schema, fields, ...rest } = issue;
+  const { self: _self, expand: _expand, names, schema: _schema, fields, ...rest } = issue;
+  const transformed = transformIssueFields(fields, issue.key);
+  const fieldNames = customFieldNames(names, transformed);
   return {
     ...rest,
     url: issueBrowseUrl(issue.key),
-    fields: transformIssueFields(fields)
+    fields: transformed,
+    ...fieldNames ? { names: fieldNames } : {}
   };
 }
 function isEmpty(v) {
@@ -807,7 +943,45 @@ function pruneSentinels(fields) {
   if (watches && watches.watchCount === 0) delete out.watches;
   return out;
 }
-function transformIssueFields(fields) {
+var DEV_STATUS_DUMP = /com\.atlassian\.jira\.plugin\.devstatus/;
+function collapseDevStatus(fields, key) {
+  const out = { ...fields };
+  for (const [field, value] of Object.entries(out)) {
+    if (typeof value === "string" && DEV_STATUS_DUMP.test(value)) {
+      out[field] = `(use: jiradc issue dev-status ${key})`;
+    }
+  }
+  return out;
+}
+function transformInlineComponent(c) {
+  const { self: _self, description: _description, ...rest } = c;
+  return rest;
+}
+var ISSUE_KEY_PATTERN = /^[A-Z][A-Z0-9_]*-\d+$/;
+function asIssueRefKey(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const o = value;
+  if (typeof o.key !== "string" || !ISSUE_KEY_PATTERN.test(o.key)) return void 0;
+  if (typeof o.self !== "string" || !o.self.includes("/issue/")) return void 0;
+  return o.key;
+}
+function collapseIssueRefs(fields) {
+  const out = { ...fields };
+  for (const [key, value] of Object.entries(out)) {
+    const single = asIssueRefKey(value);
+    if (single !== void 0) {
+      out[key] = single;
+      continue;
+    }
+    if (Array.isArray(value) && value.length > 0) {
+      const keys = value.map(asIssueRefKey);
+      if (keys.every((k) => k !== void 0)) out[key] = keys;
+    }
+  }
+  return out;
+}
+function transformIssueFields(fields, key) {
+  if (!fields) return {};
   const {
     // shaped sub-entities (recursed individually)
     issuetype,
@@ -833,9 +1007,11 @@ function transformIssueFields(fields) {
     // everything else: optional scalars, customfield_*, etc. — gets compacted
     ...rest
   } = fields;
-  const compacted = pruneSentinels(compactRecord(rest));
+  const compacted = collapseDevStatus(collapseIssueRefs(pruneSentinels(compactRecord(rest))), key);
+  const components = compacted.components;
   return {
     ...compacted,
+    ...Array.isArray(components) ? { components: components.map(transformInlineComponent) } : {},
     summary,
     project,
     created,
@@ -876,23 +1052,23 @@ function transformIssueFields(fields) {
 }
 
 // src/utils/transformers/transition.ts
-function slimAllowedValue(raw) {
+function slimAllowedValue2(raw) {
   if (!raw || typeof raw !== "object") return {};
   const av = raw;
   const slim = {};
   if (typeof av.id === "string") slim.id = av.id;
   if (typeof av.name === "string") slim.name = av.name;
   if (typeof av.value === "string") slim.value = av.value;
+  if (Array.isArray(av.children) && av.children.length > 0) slim.children = av.children.map(slimAllowedValue2);
   return slim;
 }
 function slimField(raw) {
   if (!raw || typeof raw !== "object") return {};
   const field = raw;
   const out = {};
-  if (typeof field.required === "boolean") out.required = field.required;
   if (typeof field.name === "string") out.name = field.name;
   if (Array.isArray(field.allowedValues)) {
-    out.allowedValues = field.allowedValues.map(slimAllowedValue);
+    out.allowedValues = field.allowedValues.map(slimAllowedValue2);
   }
   return out;
 }
@@ -1190,7 +1366,7 @@ function update(parent) {
     async (id, opts) => {
       const description = resolveTextOrFile(opts, "description", { required: false });
       if (opts.name === void 0 && description === void 0 && opts.lead === void 0 && opts.assigneeType === void 0) {
-        throw new Error("Provide at least one of --name, --description, --lead, --assignee-type");
+        throw new CliUsageError("Provide at least one of --name, --description, --lead, --assignee-type");
       }
       const client = getClient();
       const result = await client.components.update({
@@ -1224,22 +1400,6 @@ function registerComponentCommands(program) {
   issueCount(component);
 }
 
-// src/commands/field/options.ts
-function options(parent) {
-  const cmd = parent.command("options").description("Get available options for a custom field").argument("<id>", "Field ID", text).option("--query <text>", "Filter options by text", text).option("--limit <number>", "Max results to return (1-1000)", intInRange(1, 1e3), 25).option("--start <number>", "Page number (1-indexed)", positiveInt);
-  examples(cmd, ["10001", '10001 --query "High"', "10001 --limit 20 --start 2"]);
-  cmd.action(async (id, opts) => {
-    const client = getClient();
-    const result = await client.fields.getFieldOptions({
-      fieldId: id,
-      query: opts.query,
-      maxResults: opts.limit,
-      page: opts.start
-    });
-    output(transformPaged({ ...result, startAt: result.startAt ?? 0 }, transformCustomFieldOption));
-  });
-}
-
 // src/commands/field/search.ts
 function search(parent) {
   const cmd = parent.command("search").description("Search for fields by name or ID").argument("<keyword>", "Search keyword", text).option("--limit <number>", "Maximum number of results (1-1000)", intInRange(1, 1e3), 25);
@@ -1254,9 +1414,8 @@ function search(parent) {
 // src/commands/field/index.ts
 function registerFieldCommands(program) {
   const field = program.command("field").description("Field operations");
-  examples(field, ['search "epic"', 'search "priority"', "options 10120"]);
+  examples(field, ['search "epic"', 'search "priority"']);
   search(field);
-  options(field);
 }
 
 // src/utils/resolve-user.ts
@@ -1667,13 +1826,16 @@ function registerCommentCommands(parent) {
 }
 
 // src/commands/issue/create.ts
+import { Option as Option5 } from "commander";
 import { z as z2 } from "zod";
-var customFieldsSchema = z2.record(z2.unknown());
+var fieldsSchema = z2.record(z2.unknown());
 function create3(parent) {
   const cmd = parent.command("create").description("Create a new issue").requiredOption("--project <key>", "Project key or ID", text).requiredOption("--type <name>", "Issue type name (e.g., Task, Bug, Story)", text).requiredOption("--summary <text>", "Issue summary/title", text).option("--assignee <user>", 'Assignee. Username, "me", or "none" to leave unassigned.', text).option("--reporter <user>", 'Reporter. Username or "me".', text).option("--priority <name>", "Priority name (e.g., High, Medium, Low)", text).option("--labels <labels>", "Comma-separated labels", text).option("--components <names>", "Comma-separated component names", text).option("--fix-versions <versions>", "Comma-separated fix version names", text).option("--due-date <date>", "Due date in YYYY-MM-DD format", date).option("--parent <key>", "Parent issue key (for subtasks)", issueKey).option(
-    "--custom-fields <json>",
-    `Additional custom fields as JSON (e.g., '{"customfield_10100": "EPIC-1"}')`,
-    jsonShape(customFieldsSchema)
+    "--fields <json>",
+    `Additional fields as JSON (e.g., '{"customfield_10100": "EPIC-1"}')`,
+    jsonShape(fieldsSchema)
+  ).addOption(
+    new Option5("--custom-fields <json>", "Deprecated alias for --fields").argParser(jsonShape(fieldsSchema)).hideHelp()
   );
   textOrFileOption(cmd, "description", { description: "Issue description in wiki markup" });
   examples(cmd, [
@@ -1684,6 +1846,13 @@ function create3(parent) {
   cmd.action(
     async (opts) => {
       const description = resolveTextOrFile(opts, "description", { required: false });
+      if (opts.fields && opts.customFields) {
+        throw new CliUsageError(
+          "Pass either --fields or --custom-fields, not both",
+          "--custom-fields is a deprecated alias for --fields. Merge the two JSON objects into a single --fields value."
+        );
+      }
+      const fields = opts.fields ?? opts.customFields;
       const assignee = opts.assignee !== void 0 ? await resolveUserToken(opts.assignee) : void 0;
       const reporter = opts.reporter !== void 0 ? await resolveUserToken(opts.reporter) : void 0;
       const client = getClient();
@@ -1700,13 +1869,31 @@ function create3(parent) {
         fixVersions: opts.fixVersions?.split(",").map((v) => v.trim()),
         dueDate: opts.dueDate,
         parent: opts.parent,
-        customFields: opts.customFields
+        customFields: fields
       });
       output(transformCreatedIssue(result));
     }
   );
 }
 
+// src/commands/issue/createmeta.ts
+function createmeta(parent) {
+  const cmd = parent.command("createmeta").description("Show which fields a new issue of a given type accepts, and the values they allow").requiredOption("--project <key>", "Project key", text).requiredOption("--type <name>", "Issue type name (e.g., Task, Bug, Story)", text);
+  examples(cmd, ["--project PROJ --type Task", "--project PROJ --type Bug"]);
+  cmd.action(async (opts) => {
+    const client = getClient();
+    const meta = await client.issues.getCreateMeta({ projectKey: opts.project, issueTypeName: opts.type });
+    const issueType = meta.projects?.[0]?.issuetypes?.[0];
+    if (!issueType?.fields) {
+      throw new CliNotFoundError(
+        `No create metadata for issue type "${opts.type}" in project "${opts.project}"`,
+        "Verify the project key and issue type name, then check you may create that type there."
+      );
+    }
+    output(transformFieldMeta(issueType.fields));
+  });
+}
+
 // src/commands/issue/delete.ts
 function deleteIssue(parent) {
   const cmd = parent.command("delete").description("Delete an issue").argument("<key>", "Issue key", issueKey).option("--delete-subtasks", "Also delete subtasks (default: false)");
@@ -1796,10 +1983,20 @@ function devStatus(parent) {
   });
 }
 
+// src/commands/issue/editmeta.ts
+function editmeta(parent) {
+  const cmd = parent.command("editmeta").description("Show which fields this issue's edit screen accepts, and the values they allow").argument("<key>", "Issue key", issueKey);
+  examples(cmd, ["PROJ-123"]);
+  cmd.action(async (key) => {
+    const client = getClient();
+    const meta = await client.issues.getEditMeta({ issueKeyOrId: key });
+    output(transformFieldMeta(meta.fields ?? {}));
+  });
+}
+
 // src/utils/constants.ts
-var DEFAULT_FIELDS = [
+var SEARCH_DEFAULT_FIELDS = [
   "summary",
-  "description",
   "status",
   "assignee",
   "reporter",
@@ -1808,13 +2005,78 @@ var DEFAULT_FIELDS = [
   "created",
   "updated",
   "issuetype",
-  "components",
-  "comment"
+  "components"
 ];
+var DEFAULT_FIELDS = [...SEARCH_DEFAULT_FIELDS, "description", "comment"];
+
+// src/utils/field-selectors.ts
+var WILDCARD = "*";
+var NEGATION = "-";
+function buildFieldNameIndex(fields) {
+  const ids = /* @__PURE__ */ new Set();
+  const byName = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    ids.add(field.id);
+    byName.set(field.name.toLowerCase(), field.id);
+    for (const clause of field.clauseNames ?? []) byName.set(clause.toLowerCase(), field.id);
+  }
+  for (const field of fields) byName.set(field.id.toLowerCase(), field.id);
+  return { ids, byName };
+}
+function resolveOne(token, index) {
+  if (index.ids.has(token)) return token;
+  return index.byName.get(token.toLowerCase());
+}
+function resolveFieldSelectors(tokens, index) {
+  const resolved = [];
+  const unresolved = [];
+  for (const token of tokens) {
+    if (token.startsWith(WILDCARD)) {
+      resolved.push(token);
+      continue;
+    }
+    const negated = token.startsWith(NEGATION);
+    const bare = negated ? token.slice(1) : token;
+    const id = resolveOne(bare, index);
+    if (id === void 0) {
+      unresolved.push(token);
+      continue;
+    }
+    resolved.push(negated ? `${NEGATION}${id}` : id);
+  }
+  if (unresolved.length > 0) {
+    const plural = unresolved.length > 1 ? "s" : "";
+    throw new CliUsageError(
+      `Unknown field name${plural}: ${unresolved.join(", ")}`,
+      `Jira selects fields by id, and these matched no field id, name or JQL clause name on this instance. Run jiradc field search <keyword> to find the right name or id. Left unresolved these would be dropped silently, returning an answer missing the field${plural} you asked for.`,
+      { unresolved }
+    );
+  }
+  return [...new Set(resolved)];
+}
+function parseFieldSelectors(raw) {
+  return raw.split(",").map((token) => token.trim()).filter((token) => token.length > 0);
+}
+var FIELD_CACHE = { name: "jiradc", ttl: 36e5 };
+async function loadFieldNameIndex(client) {
+  const fields = await cacheGetOrFetch(
+    FIELD_CACHE,
+    "field-names",
+    async () => (await client.fields.getAll()).map(({ id, name, clauseNames }) => ({ id, name, clauseNames }))
+  );
+  return buildFieldNameIndex(fields);
+}
+async function selectFields(client, opts, defaults) {
+  if (opts.allFields === true) return void 0;
+  if (opts.fields === void 0) return defaults;
+  const tokens = parseFieldSelectors(opts.fields);
+  if (tokens.length === 0) return defaults;
+  return resolveFieldSelectors(tokens, await loadFieldNameIndex(client));
+}
 
 // src/commands/issue/get.ts
 function get2(parent) {
-  const cmd = parent.command("get").description("Get issue details").argument("<key>", "Issue key", issueKey).option("--fields <fields>", "Comma-separated fields to return (defaults to essential fields)", text).option("--all-fields", "Return all fields instead of defaults").option("--expand <expand>", 'Expand options (e.g., "transitions", "changelog")', text);
+  const cmd = parent.command("get").description("Get issue details").argument("<key>", "Issue key", issueKey).option("--fields <fields>", "Comma-separated fields to return, by name or id", text).option("--all-fields", "Return all fields instead of defaults").option("--expand <expand>", 'Expand options (e.g., "transitions", "changelog")', text);
   examples(cmd, [
     "PROJ-123",
     "PROJ-123 --fields summary,status,assignee",
@@ -1823,7 +2085,7 @@ function get2(parent) {
   ]);
   cmd.action(async (key, opts) => {
     const client = getClient();
-    const fields = opts.allFields ? void 0 : opts.fields?.split(",").map((f) => f.trim()) ?? DEFAULT_FIELDS;
+    const fields = await selectFields(client, opts, DEFAULT_FIELDS);
     const result = await client.issues.get({
       issueKeyOrId: key,
       fields,
@@ -1902,63 +2164,126 @@ function link(parent) {
   });
 }
 
+// src/utils/paging.ts
+var ALL_RESULTS_CAP = 1e3;
+function planSearch(opts, maxPageSize) {
+  const start = opts.start ?? 0;
+  if (opts.all !== true) return { all: false, pageSize: opts.limit, start };
+  if (opts.limitGiven) {
+    throw new CliUsageError(
+      "Pass either --all or --limit, not both",
+      "--all collects every match; --limit caps how many come back. Drop --limit to collect everything, or drop --all and page with --limit and --start."
+    );
+  }
+  return { all: true, pageSize: maxPageSize, start };
+}
+async function fetchEveryPage(fetchPage, opts) {
+  const first = await fetchPage(opts.start, opts.pageSize);
+  const outstanding = first.total - opts.start;
+  if (outstanding > ALL_RESULTS_CAP) {
+    throw new CliUsageError(
+      `--all would collect ${outstanding} issues, above the ${ALL_RESULTS_CAP} limit`,
+      `Narrow the query, or page it yourself with --start and --limit. Returning the first ${ALL_RESULTS_CAP} instead would look like a complete answer and would not be one.`,
+      { total: first.total, cap: ALL_RESULTS_CAP }
+    );
+  }
+  const offsets = [];
+  for (let at = opts.start + first.issues.length; at < first.total; at += opts.pageSize) offsets.push(at);
+  const rest = await Promise.all(offsets.map(async (at) => fetchPage(at, opts.pageSize)));
+  const issues3 = [first, ...rest].flatMap((page) => page.issues);
+  return { startAt: opts.start, maxResults: issues3.length, total: first.total, isLast: true, issues: issues3 };
+}
+
 // src/commands/issue/search.ts
+var MAX_PAGE_SIZE = 50;
 function search2(parent) {
-  const cmd = parent.command("search").description("Search issues using JQL").argument("<jql>", "JQL query string", text).option("--limit <number>", "Max results (1-50, Jira DC caps at 50)", intInRange(1, 50), 25).option("--start <number>", "Starting index for pagination", nonNegativeInt).option("--fields <fields>", "Comma-separated fields to return (defaults to essential fields)", text).option("--all-fields", "Return all fields instead of defaults");
+  const cmd = parent.command("search").description("Search issues using JQL").argument("<jql>", "JQL query string", text).option(
+    "--limit <number>",
+    `Max results (1-${MAX_PAGE_SIZE}, Jira DC caps at ${MAX_PAGE_SIZE})`,
+    intInRange(1, MAX_PAGE_SIZE),
+    25
+  ).option("--start <number>", "Starting index for pagination", nonNegativeInt).option(
+    "--fields <fields>",
+    "Comma-separated fields to return, by name or id (defaults to a lean set without description/comment)",
+    text
+  ).option("--all-fields", "Return all fields instead of defaults").option("--all", `Collect every match, not just one page (up to ${ALL_RESULTS_CAP}; fails above it)`);
   examples(cmd, [
     '"project = PROJ AND status = Open"',
     '"assignee = currentUser()" --limit 10 --fields summary,status',
+    '"project = PROJ AND status = Open" --all',
     '"project = PROJ" --start 50 --limit 50'
   ]);
-  cmd.action(async (jql, opts) => {
-    const client = getClient();
-    const fields = opts.allFields ? void 0 : opts.fields?.split(",").map((f) => f.trim()) ?? DEFAULT_FIELDS;
-    const result = await client.issues.search({
-      jql,
-      startAt: opts.start,
-      maxResults: opts.limit,
-      fields
-    });
-    output(transformPaged(result, transformIssue));
-  });
+  cmd.action(
+    async (jql, opts) => {
+      const client = getClient();
+      const fields = await selectFields(client, opts, SEARCH_DEFAULT_FIELDS);
+      const plan = planSearch({ ...opts, limitGiven: cmd.getOptionValueSource("limit") === "cli" }, MAX_PAGE_SIZE);
+      const page = async (startAt, maxResults) => client.issues.search({ jql, startAt, maxResults, fields });
+      if (!plan.all) {
+        output(transformPaged(await page(plan.start, plan.pageSize), transformIssue));
+        return;
+      }
+      const every = await fetchEveryPage(page, { pageSize: plan.pageSize, start: plan.start });
+      output({ ...every, issues: every.issues.map(transformIssue) });
+    }
+  );
 }
 
 // src/commands/issue/transition.ts
+import { z as z3 } from "zod";
+var fieldsSchema2 = z3.record(z3.unknown());
+function resolveTransitionId(to, transitions2) {
+  const target = to.toLowerCase();
+  const byName = transitions2.filter((t) => t.name.toLowerCase() === target);
+  const matches = byName.length > 0 ? byName : transitions2.filter((t) => t.to.toLowerCase() === target);
+  if (matches.length === 1) return matches[0].id;
+  const available = transitions2.map((t) => ({ id: t.id, name: t.name, to: t.to }));
+  if (matches.length === 0) {
+    throw new CliUsageError(
+      `Transition "${to}" not available from current status`,
+      "Re-run --to with one of the listed transitions (by name, id, or target status).",
+      { available }
+    );
+  }
+  const ids = matches.map((t) => t.id).join(", ");
+  throw new CliUsageError(
+    `"${to}" matches more than one available transition`,
+    `Re-run --to with one of these ids: ${ids}.`,
+    { available }
+  );
+}
 function transition(parent) {
-  const cmd = parent.command("transition").description("Transition issue to a new status").argument("<key>", "Issue key", issueKey).requiredOption("--to <idOrName>", "Transition ID, or status name (case-insensitive)", text);
+  const cmd = parent.command("transition").description("Transition issue to a new status").argument("<key>", "Issue key", issueKey).requiredOption("--to <idOrName>", "Transition ID, transition name, or target status name (case-insensitive)", text).option(
+    "--fields <json>",
+    `Fields required by the transition screen, as JSON (e.g. '{"customfield_10100": {"value": "Approved"}}')`,
+    jsonShape(fieldsSchema2)
+  );
   commentOption(cmd, { description: "Comment to add during transition" });
   examples(cmd, [
     "PROJ-123 --to 31",
+    'PROJ-123 --to "Start Review"',
     'PROJ-123 --to "In Review"',
-    'PROJ-123 --to Done --comment "Verified in staging"'
+    'PROJ-123 --to Done --comment "Verified in staging"',
+    `PROJ-123 --to Approve --fields '{"customfield_10100": {"value": "Approved"}}'`
   ]);
-  cmd.action(async (key, opts) => {
-    const comment = resolveTextOrFile(opts, "comment", { required: false });
-    const client = getClient();
-    let transitionId;
-    if (/^\d+$/.test(opts.to)) {
-      transitionId = opts.to;
-    } else {
-      const raw = await client.issues.getTransitions({
-        issueKeyOrId: key,
-        expand: "transitions.fields"
-      });
-      const transitions2 = transformTransitions(raw);
-      const target = opts.to.toLowerCase();
-      const matches = transitions2.filter((t) => t.name.toLowerCase() === target);
-      if (matches.length === 0) {
-        const names = transitions2.map((t) => `"${t.name}"`).join(", ");
-        throw new Error(`Transition "${opts.to}" not available from current status. Available: ${names || "(none)"}`);
-      }
-      if (matches.length > 1) {
-        const ids = matches.map((t) => t.id).join(", ");
-        throw new Error(`Multiple transitions named "${opts.to}". Use --to <id> with one of: ${ids}`);
+  cmd.action(
+    async (key, opts) => {
+      const comment = resolveTextOrFile(opts, "comment", { required: false });
+      const client = getClient();
+      let transitionId;
+      if (/^\d+$/.test(opts.to)) {
+        transitionId = opts.to;
+      } else {
+        const raw = await client.issues.getTransitions({
+          issueKeyOrId: key,
+          expand: "transitions.fields"
+        });
+        transitionId = resolveTransitionId(opts.to, transformTransitions(raw));
       }
-      transitionId = matches[0].id;
+      await client.issues.transition({ issueKeyOrId: key, transitionId, fields: opts.fields, comment });
+      output({ transitioned: true, issue: transformIssueRef(key) });
     }
-    await client.issues.transition({ issueKeyOrId: key, transitionId, comment });
-    output({ transitioned: true, issue: transformIssueRef(key) });
-  });
+  );
 }
 
 // src/commands/issue/transitions.ts
@@ -1987,7 +2312,7 @@ function unlink2(parent) {
 }
 
 // src/commands/issue/update.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/utils/multi-value.ts
 import { InvalidArgumentError as InvalidArgumentError5 } from "commander";
@@ -2016,7 +2341,7 @@ function parseMultiValue(flagName, raw) {
 }
 
 // src/commands/issue/update.ts
-var fieldsSchema = z3.record(z3.unknown());
+var fieldsSchema3 = z4.record(z4.unknown());
 function buildUpdateOps(parsed, wrap) {
   if (parsed.mode !== "mutate") return void 0;
   return [...parsed.adds.map((v) => ({ add: wrap(v) })), ...parsed.removes.map((v) => ({ remove: wrap(v) }))];
@@ -2029,7 +2354,7 @@ function update3(parent) {
   const cmd = parent.command("update").description("Update issue fields").argument("<key>", "Issue key", issueKey).option(
     "--fields <json>",
     "JSON string of fields to update (advanced; merges with shortcuts, wins on conflict)",
-    jsonShape(fieldsSchema)
+    jsonShape(fieldsSchema3)
   ).option("--no-notify-users", "Suppress notification emails (default: notify)").option("--attachments <paths>", "Comma-separated local file paths to attach", text).option("--summary <text>", "Set the issue summary", text).option("--priority <name>", "Set the priority by name (e.g. High)", text).option("--assignee <user>", 'Set the assignee. Username, "me", or "none" to unassign.', text).option("--labels <list>", 'Set labels ("a,b,c") or mutate ("+add,-remove")', text).option("--components <list>", 'Set components ("a,b") or mutate ("+add,-remove")', text).option("--fix-versions <list>", 'Set fix versions ("1.0,2.0") or mutate ("+1.0,-0.9")', text);
   textOrFileOption(cmd, "description", { description: "Set the issue description (wiki markup)" });
   examples(cmd, [
@@ -2044,7 +2369,7 @@ function update3(parent) {
     const description = resolveTextOrFile(opts, "description", { required: false });
     const hasShortcut = opts.summary !== void 0 || description !== void 0 || opts.priority !== void 0 || opts.assignee !== void 0 || opts.labels !== void 0 || opts.components !== void 0 || opts.fixVersions !== void 0;
     if (!opts.fields && !opts.attachments && !hasShortcut) {
-      throw new Error(
+      throw new CliUsageError(
         "Provide at least one of --fields, --attachments, or a shortcut flag (--summary, --priority, --labels, ...)"
       );
     }
@@ -2132,12 +2457,12 @@ function create4(parent) {
 }
 
 // src/commands/issue/worklog/delete.ts
-import { Option as Option5 } from "commander";
+import { Option as Option6 } from "commander";
 var ADJUST_ESTIMATE = ["new", "leave", "manual", "auto"];
 function deleteWorklog(parent) {
   const cmd = parent.command("delete").description("Delete a worklog entry").argument("<key>", "Issue key", issueKey);
   subEntityOption(cmd, "worklog", { mandatory: true });
-  cmd.addOption(new Option5("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text).option(
+  cmd.addOption(new Option6("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text).option(
     "--increase-by <amount>",
     'Amount to increase the estimate by; required when --adjust-estimate is "manual"',
     text
@@ -2178,12 +2503,12 @@ function list4(parent) {
 }
 
 // src/commands/issue/worklog/update.ts
-import { Option as Option6 } from "commander";
+import { Option as Option7 } from "commander";
 var ADJUST_ESTIMATE2 = ["new", "leave", "auto"];
 function update4(parent) {
   const cmd = parent.command("update").description("Update an existing worklog entry").argument("<key>", "Issue key", issueKey);
   subEntityOption(cmd, "worklog", { mandatory: true });
-  cmd.option("--time <timeSpent>", "Time spent (e.g., '2h', '30m', '1d 4h')", text).option("--started <datetime>", "Start time in ISO 8601 format", dateTime).addOption(new Option6("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE2)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text);
+  cmd.option("--time <timeSpent>", "Time spent (e.g., '2h', '30m', '1d 4h')", text).option("--started <datetime>", "Start time in ISO 8601 format", dateTime).addOption(new Option7("--adjust-estimate <mode>", "How to adjust the remaining estimate").choices(ADJUST_ESTIMATE2)).option("--new-estimate <estimate>", 'New remaining estimate; required when --adjust-estimate is "new"', text);
   commentOption(cmd, { description: "Worklog comment" });
   examples(cmd, [
     'PROJ-123 --worklog-id 12345 --time "1h 30m"',
@@ -2241,6 +2566,8 @@ function registerIssueCommands(program) {
   deleteIssue(issue);
   transition(issue);
   transitions(issue);
+  createmeta(issue);
+  editmeta(issue);
   assign(issue);
   registerCommentCommands(issue);
   registerWorklogCommands(issue);
@@ -2342,10 +2669,10 @@ function issues2(parent) {
 }
 
 // src/commands/sprint/list.ts
-import { Option as Option7 } from "commander";
+import { Option as Option8 } from "commander";
 var SPRINT_STATES = ["future", "active", "closed"];
 function list6(parent) {
-  const cmd = parent.command("list").description("List sprints for a board").requiredOption("--board <id>", "Board ID", positiveInt).addOption(new Option7("--state <state>", "Filter by sprint state").choices(SPRINT_STATES));
+  const cmd = parent.command("list").description("List sprints for a board").requiredOption("--board <id>", "Board ID", positiveInt).addOption(new Option8("--state <state>", "Filter by sprint state").choices(SPRINT_STATES));
   examples(cmd, ["--board 42", "--board 42 --state active"]);
   cmd.action(async (opts) => {
     const client = getClient();
@@ -2358,10 +2685,10 @@ function list6(parent) {
 }
 
 // src/commands/sprint/update.ts
-import { Argument as Argument4, Option as Option8 } from "commander";
+import { Argument as Argument4, Option as Option9 } from "commander";
 var SPRINT_STATES2 = ["future", "active", "closed"];
 function update5(parent) {
-  const cmd = parent.command("update").description("Update an existing sprint").addArgument(new Argument4("<id>", "Sprint ID").argParser(positiveInt)).option("--name <name>", "New sprint name", text).addOption(new Option8("--state <state>", "New sprint state").choices(SPRINT_STATES2)).option("--start-date <date>", "New start date in ISO 8601 format", text).option("--end-date <date>", "New end date in ISO 8601 format", text).option("--goal <goal>", "New sprint goal", text);
+  const cmd = parent.command("update").description("Update an existing sprint").addArgument(new Argument4("<id>", "Sprint ID").argParser(positiveInt)).option("--name <name>", "New sprint name", text).addOption(new Option9("--state <state>", "New sprint state").choices(SPRINT_STATES2)).option("--start-date <date>", "New start date in ISO 8601 format", text).option("--end-date <date>", "New end date in ISO 8601 format", text).option("--goal <goal>", "New sprint goal", text);
   examples(cmd, [
     '100 --name "Sprint 10 - Extended"',
     "100 --state active",
@@ -2401,10 +2728,10 @@ function registerSprintCommands(program) {
 
 // src/commands/token/client.ts
 import { JiraClient as JiraClient2 } from "jira-data-center-client";
-function getTokenClient(options2 = {}) {
+function getTokenClient(options = {}) {
   const baseUrl = process.env.JIRA_URL;
-  const username = options2.basicUsername ?? process.env.JIRA_BASIC_USERNAME;
-  const password = options2.basicPassword ?? process.env.JIRA_BASIC_PASSWORD;
+  const username = options.basicUsername ?? process.env.JIRA_BASIC_USERNAME;
+  const password = options.basicPassword ?? process.env.JIRA_BASIC_PASSWORD;
   if (!baseUrl || !username || !password) {
     const missing = [
       ...!baseUrl ? ["JIRA_URL"] : [],
@@ -2545,12 +2872,12 @@ function registerUserCommands(program) {
 function assertExactlyOne(opts, keys, label) {
   const present = keys.filter((k) => opts[k] !== void 0);
   if (present.length !== 1)
-    throw new Error(`Provide exactly one of ${keys.map((k) => `--${k}`).join(", ")} (${label}).`);
+    throw new CliUsageError(`Provide exactly one of ${keys.map((k) => `--${k}`).join(", ")} (${label}).`);
   return present[0];
 }
 function assertAtLeastOne(opts, keys) {
   if (!keys.some((k) => opts[k] !== void 0))
-    throw new Error(`Provide at least one of ${keys.map((k) => `--${k}`).join(", ")}.`);
+    throw new CliUsageError(`Provide at least one of ${keys.map((k) => `--${k}`).join(", ")}.`);
 }
 
 // src/commands/xray/execution/add.ts
@@ -2581,7 +2908,9 @@ function add(parent) {
     }
     const allKeys = [...keys];
     if (allKeys.length === 0) {
-      throw new Error("No tests to add \u2014 the given --set(s) contain no tests and no --test keys were provided.");
+      throw new CliUsageError(
+        "No tests to add \u2014 the given --set(s) contain no tests and no --test keys were provided."
+      );
     }
     const result = await client.testExecutions.addTests({ execKey, keys: allKeys });
     output(result ?? { added: allKeys });
@@ -2825,7 +3154,7 @@ function update7(parent) {
   ]);
   cmd.action(async (folderId, opts) => {
     if (opts.name === void 0 && opts.rank === void 0) {
-      throw new Error("Provide at least one of --name or --rank.");
+      throw new CliUsageError("Provide at least one of --name or --rank.");
     }
     const client = getClient();
     await client.testRepository.updateFolder({
@@ -2855,12 +3184,12 @@ function registerFolderCommands(xray) {
 // src/commands/xray/import/execution.ts
 import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename2 } from "path";
-import { Option as Option9 } from "commander";
+import { Option as Option10 } from "commander";
 var FORMATS = ["xray", "junit", "testng", "nunit", "xunit", "robot", "cucumber", "behave"];
 var NEEDS_SCOPE = /* @__PURE__ */ new Set(["junit", "testng", "nunit", "xunit", "robot"]);
 function execution(parent) {
   const cmd = parent.command("execution").description("Import test execution results into Xray").requiredOption("--file <path>", "Path to the result file", filePath).addOption(
-    new Option9(
+    new Option10(
       "--format <format>",
       "Result format. xray/cucumber/behave: JSON body, no --project/--execution required. junit/testng/nunit/xunit/robot: XML body, requires --project OR --execution."
     ).choices(FORMATS).makeOptionMandatory()
@@ -2881,7 +3210,7 @@ function execution(parent) {
   cmd.action(
     async (opts) => {
       if (NEEDS_SCOPE.has(opts.format) && !opts.project && !opts.execution) {
-        throw new Error(
+        throw new CliUsageError(
           `--project or --execution is required for ${opts.format} format. Provide --project <key> to create a new execution, or --execution <key> to import into an existing one.`
         );
       }
@@ -3058,7 +3387,7 @@ function add4(parent) {
 }
 
 // src/commands/xray/precondition/create.ts
-import { Option as Option10 } from "commander";
+import { Option as Option11 } from "commander";
 
 // src/utils/xray/fields.ts
 var CONCEPT_SUFFIX = {
@@ -3089,18 +3418,22 @@ function resolveTestTypeValue(allowedValues, type) {
   if (type === "manual") {
     const match2 = allowedValues.find((v) => /manual/i.test(v));
     if (!match2)
-      throw new Error(`No 'manual' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`);
+      throw new CliNotFoundError(
+        `No 'manual' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`
+      );
     return match2;
   }
   if (type === "generic") {
     const match2 = allowedValues.find((v) => /generic/i.test(v));
     if (!match2)
-      throw new Error(`No 'generic' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`);
+      throw new CliNotFoundError(
+        `No 'generic' Test Type value found on this instance. Available: ${allowedValues.join(", ")}`
+      );
     return match2;
   }
   const match = allowedValues.find((v) => !/manual/i.test(v) && !/generic/i.test(v));
   if (!match)
-    throw new Error(
+    throw new CliNotFoundError(
       `No 'cucumber' (gherkin/automation) Test Type value found on this instance. Available: ${allowedValues.join(", ")}`
     );
   return match;
@@ -3121,7 +3454,7 @@ async function resolveTypeValue(client, params) {
 }
 function requireField(map, concept, label) {
   const id = map[concept];
-  if (!id) throw new Error(`Xray field for '${label}' not found on this instance.`);
+  if (!id) throw new CliNotFoundError(`Xray field for '${label}' not found on this instance.`);
   return id;
 }
 function buildTestCustomFields(map, opts) {
@@ -3159,7 +3492,7 @@ function create10(parent) {
   const cmd = parent.command("create").description(
     "Create a new Xray Pre-Condition issue. Note: the Pre-Condition issue type is only available in projects that have it configured (e.g. BD); it is not on your project scheme."
   ).requiredOption("--project <key>", "Project key (e.g. BD)", text).requiredOption("--summary <text>", "Pre-Condition summary (title)", text).addOption(
-    new Option10("--type <type>", "Pre-Condition type").choices(["manual", "generic", "cucumber"]).default("manual")
+    new Option11("--type <type>", "Pre-Condition type").choices(["manual", "generic", "cucumber"]).default("manual")
   );
   textOrFileOption(cmd, "condition", { description: "Pre-condition body / definition text" });
   textOrFileOption(cmd, "description", { description: "Pre-Condition issue description" });
@@ -3230,9 +3563,9 @@ function remove4(parent) {
 }
 
 // src/commands/xray/precondition/update.ts
-import { Option as Option11 } from "commander";
+import { Option as Option12 } from "commander";
 function update9(parent) {
-  const cmd = parent.command("update").description("Update an Xray Pre-Condition issue").argument("<preKey>", "Pre-Condition issue key (e.g. PROJ-50)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option11("--type <type>", "New Pre-Condition type").choices(["manual", "generic", "cucumber"]));
+  const cmd = parent.command("update").description("Update an Xray Pre-Condition issue").argument("<preKey>", "Pre-Condition issue key (e.g. PROJ-50)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option12("--type <type>", "New Pre-Condition type").choices(["manual", "generic", "cucumber"]));
   textOrFileOption(cmd, "condition", { description: "New pre-condition body / definition text" });
   textOrFileOption(cmd, "description", { description: "New Pre-Condition issue description" });
   examples(cmd, ['PROJ-50 --summary "Updated precondition"', 'PROJ-50 --type generic --condition "apiKey != null"']);
@@ -3255,12 +3588,12 @@ function update9(parent) {
             fieldMap: map
           });
           const typeId = map["precondition-type"];
-          if (!typeId) throw new Error("Xray field for 'Pre-Condition Type' not found on this instance.");
+          if (!typeId) throw new CliNotFoundError("Xray field for 'Pre-Condition Type' not found on this instance.");
           customFields[typeId] = { value: typeValue };
         }
         if (condition !== void 0) {
           const bodyId = map["precondition-body"];
-          if (!bodyId) throw new Error("Xray field for 'Conditions' not found on this instance.");
+          if (!bodyId) throw new CliNotFoundError("Xray field for 'Conditions' not found on this instance.");
           customFields[bodyId] = condition;
         }
       }
@@ -3291,9 +3624,10 @@ function registerPreconditionCommands(xray) {
 // src/utils/xray/run-id.ts
 async function resolveRunId(client, o) {
   if (o.runId !== void 0) return o.runId;
-  if (!o.execution || !o.test) throw new Error("Provide a run id, or both --execution and --test to resolve the run.");
+  if (!o.execution || !o.test)
+    throw new CliUsageError("Provide a run id, or both --execution and --test to resolve the run.");
   const run = await client.testRuns.resolve({ execKey: o.execution, testKey: o.test });
-  if (!run?.id) throw new Error(`No test run found for ${o.test} in ${o.execution}.`);
+  if (!run?.id) throw new CliNotFoundError(`No test run found for ${o.test} in ${o.execution}.`);
   return Number(run.id);
 }
 
@@ -3665,7 +3999,7 @@ function update12(parent) {
       const data = resolveTextOrFile(opts, "data", { required: false });
       const result = resolveTextOrFile(opts, "result", { required: false });
       if (action === void 0 && data === void 0 && result === void 0) {
-        throw new Error(
+        throw new CliUsageError(
           "Provide at least one of --action (or --action-file), --data (or --data-file), --result (or --result-file)."
         );
       }
@@ -3689,16 +4023,16 @@ function registerStepCommands(xray) {
 }
 
 // src/commands/xray/test/create.ts
-import { Option as Option12 } from "commander";
-import { z as z4 } from "zod";
-var stepsSchema = z4.array(
-  z4.object({ action: z4.string(), data: z4.string().optional(), result: z4.string().optional() })
+import { Option as Option13 } from "commander";
+import { z as z5 } from "zod";
+var stepsSchema = z5.array(
+  z5.object({ action: z5.string(), data: z5.string().optional(), result: z5.string().optional() })
 );
 function create11(parent) {
   const cmd = parent.command("create").description("Create a new Xray Test issue").requiredOption("--project <key>", "Project key (e.g. AI)", text).requiredOption("--summary <text>", "Test summary (title)", text).addOption(
-    new Option12("--type <type>", "Test type (when cucumber: also pass --gherkin; when generic: --definition)").choices(["manual", "cucumber", "generic"]).default("manual")
+    new Option13("--type <type>", "Test type (when cucumber: also pass --gherkin; when generic: --definition)").choices(["manual", "cucumber", "generic"]).default("manual")
   ).addOption(
-    new Option12("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+    new Option13("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
       "scenario",
       "scenario-outline"
     ])
@@ -3726,10 +4060,10 @@ function create11(parent) {
       const definition = resolveTextOrFile(opts, "definition", { required: false });
       const description = resolveTextOrFile(opts, "description", { required: false });
       if (opts.type === "cucumber" && !gherkin) {
-        throw new Error("--gherkin (or --gherkin-file) is required when --type is cucumber.");
+        throw new CliUsageError("--gherkin (or --gherkin-file) is required when --type is cucumber.");
       }
       if (opts.type === "generic" && !definition) {
-        throw new Error("--definition (or --definition-file) is required when --type is generic.");
+        throw new CliUsageError("--definition (or --definition-file) is required when --type is generic.");
       }
       const cucumberType = opts.cucumberType === "scenario" ? "Scenario" : opts.cucumberType === "scenario-outline" ? "Scenario Outline" : void 0;
       const client = getClient();
@@ -3804,13 +4138,13 @@ function list18(parent) {
       const client = getClient();
       if (opts.folder !== void 0) {
         if (!opts.project) {
-          throw new Error("--project is required when --folder is specified.");
+          throw new CliUsageError("--project is required when --folder is specified.");
         }
         const otherScopes = ["set", "plan", "execution", "precondition"].filter(
           (k) => opts[k] !== void 0
         );
         if (otherScopes.length > 0) {
-          throw new Error(
+          throw new CliUsageError(
             `--folder cannot be combined with ${otherScopes.map((k) => `--${k}`).join(", ")}. Use --folder with --project only.`
           );
         }
@@ -3868,10 +4202,10 @@ function list18(parent) {
 }
 
 // src/commands/xray/test/update.ts
-import { Option as Option13 } from "commander";
+import { Option as Option14 } from "commander";
 function update13(parent) {
-  const cmd = parent.command("update").description("Update an Xray Test issue").argument("<testKey>", "Test issue key (e.g. PROJ-584)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option13("--type <type>", "Test type").choices(["manual", "cucumber", "generic"])).addOption(
-    new Option13("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
+  const cmd = parent.command("update").description("Update an Xray Test issue").argument("<testKey>", "Test issue key (e.g. PROJ-584)", issueKey).option("--summary <text>", "New summary (title)", text).addOption(new Option14("--type <type>", "Test type").choices(["manual", "cucumber", "generic"])).addOption(
+    new Option14("--cucumber-type <cucumberType>", "Cucumber scenario type (required when --type cucumber)").choices([
       "scenario",
       "scenario-outline"
     ])
@@ -3902,10 +4236,10 @@ function update13(parent) {
       if (opts.reporter !== void 0) fields.reporter = { name: opts.reporter };
       if (opts.type !== void 0) {
         if (opts.type === "cucumber" && !gherkin) {
-          throw new Error("--gherkin (or --gherkin-file) is required when --type is cucumber.");
+          throw new CliUsageError("--gherkin (or --gherkin-file) is required when --type is cucumber.");
         }
         if (opts.type === "generic" && !definition) {
-          throw new Error("--definition (or --definition-file) is required when --type is generic.");
+          throw new CliUsageError("--definition (or --definition-file) is required when --type is generic.");
         }
         const cucumberType = opts.cucumberType === "scenario" ? "Scenario" : opts.cucumberType === "scenario-outline" ? "Scenario Outline" : void 0;
         const projectKey = testKey.split("-")[0];
@@ -4059,7 +4393,7 @@ function registerXrayCommands(program) {
 var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
 function buildProgram() {
-  const program = new Command16();
+  const program = new Command17();
   program.name("jiradc").description("Jira Data Center CLI").version(readPackageVersion(import.meta.url)).configureHelp({
     styleTitle: (str) => styleText("bold", str),
     styleUsage: (str) => styleText("dim", str),
@@ -4120,10 +4454,33 @@ function getCredentialInfo() {
   };
 }
 
+// src/utils/field-error-recovery.ts
+var CUSTOM_FIELD_KEY = /^customfield_(\d+)$/;
+function customFieldIds(detail) {
+  if (!detail || typeof detail !== "object") return [];
+  const errors = detail.errors;
+  if (!errors || typeof errors !== "object") return [];
+  return Object.keys(errors).filter((k) => CUSTOM_FIELD_KEY.test(k));
+}
+function adaptFieldErrors(normalized) {
+  const ids = customFieldIds(normalized.detail);
+  if (ids.length === 0) return normalized;
+  const numbers = ids.map((id) => CUSTOM_FIELD_KEY.exec(id)?.[1] ?? id);
+  const lookup = numbers.map((n) => `jiradc field search ${n}`).join(", ");
+  const plural = ids.length > 1 ? "s" : "";
+  return {
+    ...normalized,
+    recovery: `Jira rejected field${plural} ${ids.join(", ")}. Run ${lookup} to see the field's name and type before retrying. For the values a field accepts, use issue transitions (transition screens), issue createmeta (create) or issue editmeta (edit).`
+  };
+}
+
 // src/index.ts
 await runCli(buildProgram(), {
   credentialInfo: getCredentialInfo,
   service: "Jira",
   authRecovery: "Set the JIRA_URL and JIRA_TOKEN environment variables.",
-  urlEnvVar: "JIRA_URL"
+  urlEnvVar: "JIRA_URL",
+  // Jira names rejected fields by custom-field id. The generic recovery leaves
+  // an agent holding an opaque id, so point it at the command that explains one.
+  adapt: adaptFieldErrors
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jiradc-cli",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "publish": true,
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
   "dependencies": {
     "commander": "^13.1.0",
     "zod": "^3.25.67",
-    "jira-data-center-client": "1.0.42"
+    "jira-data-center-client": "1.0.44"
   },
   "devDependencies": {
     "@types/node": "24.10.4",