@enrichlayer/el-linear 1.10.0 → 1.15.0

package/dist/commands/issues.js

@@ -1,5 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { loadConfig } from "../config/config.js";
+import { enrichProjectResolverError, enrichValidationErrors, } from "../config/error-enrichment.js";
 import { enforceValidation, validateIssueCreation, } from "../config/issue-validation.js";
 import { resolveAssignee, resolveLabels, resolveMember, resolveTeam, } from "../config/resolver.js";
 import { resolveDefaultStatus } from "../config/status-defaults.js";
@@ -8,11 +9,11 @@ import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, } from "../qu
 import { createFileService } from "../utils/file-service.js";
 import { applyFooter } from "../utils/footer.js";
 import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-service.js";
-import { GraphQLIssuesService, } from "../utils/graphql-issues-service.js";
-import { createGraphQLService } from "../utils/graphql-service.js";
-import { createLinearService } from "../utils/linear-service.js";
+import { createGraphQLService, } from "../utils/graphql-service.js";
+import { createIssuesService } from "../utils/issues-service-bootstrap.js";
+import { createLinearService, } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
-import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
+import { handleAsyncCommand, outputSuccess, outputWarning, warnIfTruncated, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { formatCsv, formatMarkdown, formatTable, } from "../utils/table-formatter.js";
 import { parsePositiveInt, parsePriorityFilter, splitList, validatePriority, } from "../utils/validators.js";
@@ -36,6 +37,9 @@ function isImageFile(filename) {
     return ext !== -1 && IMAGE_EXTENSIONS.has(filename.slice(ext).toLowerCase());
 }
 function validateUpdateOptions(options) {
+    if (options.delegate && options.clearDelegate) {
+        throw new Error("Cannot use --delegate and --clear-delegate together");
+    }
     if (options.parentTicket && options.clearParentTicket) {
         throw new Error("Cannot use --parent-ticket and --clear-parent-ticket together");
     }
@@ -61,7 +65,7 @@ function validateUpdateOptions(options) {
         throw new Error("Cannot use --description and --append-description together");
     }
 }
-function buildUpdateArgs(issueId, options, assigneeId) {
+function buildUpdateArgs(issueId, options, assigneeId, delegateId) {
     let labelIds;
     if (options.clearLabels) {
         labelIds = [];
@@ -84,6 +88,7 @@ function buildUpdateArgs(issueId, options, assigneeId) {
         statusId: options.status,
         priority: priorityInput ? validatePriority(priorityInput) : undefined,
         assigneeId,
+        delegateId,
         projectId: options.project,
         labelIds,
         parentId: options.parentTicket || (options.clearParentTicket ? null : undefined),
@@ -136,44 +141,61 @@ function sortIssues(issues, sort) {
     }
     return sorted;
 }
+/**
+ * Map commander's `options.project` (string | false | undefined) onto the
+ * `SearchIssueArgs.project` discriminant. Commander turns `--no-project`
+ * into `false`; a missing flag is `undefined`; a string is the project
+ * name or UUID to filter to.
+ */
+function resolveProjectFlag(value) {
+    if (value === false)
+        return { kind: "none" };
+    if (value)
+        return { kind: "id", id: value };
+    return undefined;
+}
 async function handleListIssues(options, command) {
     if (options.label && !options.labels) {
         options.labels = options.label;
     }
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const hasFilters = options.team ||
         options.labels ||
         options.status ||
         options.assignee ||
+        options.delegate ||
         options.project ||
         options.project === false ||
         options.priority;
+    const limit = parsePositiveInt(options.limit, "--limit");
     if (hasFilters) {
         const searchArgs = {
             teamId: options.team ? resolveTeam(options.team) : undefined,
             assigneeId: options.assignee
                 ? await resolveAssignee(options.assignee, rootOpts)
                 : undefined,
-            projectId: options.project || undefined,
-            noProject: options.project === false,
+            delegateId: options.delegate
+                ? resolveMember(options.delegate)
+                : undefined,
+            project: resolveProjectFlag(options.project),
             labelNames: options.labels ? splitList(options.labels) : undefined,
             status: options.status ? splitList(options.status) : undefined,
             priority: options.priority
                 ? parsePriorityFilter(options.priority)
                 : undefined,
             orderBy: options.sort === "created" ? "createdAt" : "updatedAt",
-            limit: parsePositiveInt(options.limit, "--limit"),
+            limit,
         };
         const result = sortIssues(await issuesService.searchIssues(searchArgs), options.sort);
+        warnIfTruncated(result.length, limit);
         outputIssues(result, options.format, options.fields, {
             team: options.team,
         });
     }
     else {
-        const result = sortIssues(await issuesService.getIssues(parsePositiveInt(options.limit, "--limit")), options.sort);
+        const result = sortIssues(await issuesService.getIssues(limit), options.sort);
+        warnIfTruncated(result.length, limit);
         outputIssues(result, options.format, options.fields, {});
     }
 }
@@ -182,27 +204,58 @@ async function handleSearchIssues(query, options, command) {
         options.labels = options.label;
     }
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
+    const limit = parsePositiveInt(options.limit, "--limit");
     const searchArgs = {
         query,
         teamId: options.team ? resolveTeam(options.team) : undefined,
         assigneeId: options.assignee
             ? await resolveAssignee(options.assignee, rootOpts)
             : undefined,
-        projectId: options.project || undefined,
-        noProject: options.project === false,
+        delegateId: options.delegate
+            ? resolveMember(options.delegate)
+            : undefined,
+        project: resolveProjectFlag(options.project),
         status: options.status ? splitList(options.status) : undefined,
         labelNames: options.labels ? splitList(options.labels) : undefined,
         priority: options.priority
             ? parsePriorityFilter(options.priority)
             : undefined,
-        limit: parsePositiveInt(options.limit, "--limit"),
+        limit,
     };
     const result = sortIssues(await issuesService.searchIssues(searchArgs), options.sort);
+    warnIfTruncated(result.length, limit);
     outputIssues(result, options.format, options.fields, { query });
 }
+/**
+ * Run an `issuesService.createIssue` / `.updateIssue` call and, if it
+ * throws a `Project "<input>" not found` resolver error, enrich the
+ * message with team-scoped project suggestions before re-throwing. Same
+ * suggestion shape as the `Missing --project` validation path — agents
+ * get a concrete retry list whether the failure was "forgot to pass
+ * --project" or "passed --project but it didn't resolve".
+ *
+ * Best-effort: any other error class flows through unchanged, and any
+ * failure inside enrichment falls back to the original message.
+ */
+async function withProjectResolverEnrichment(fn, options, services) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (err instanceof Error && options.team) {
+            const enriched = await enrichProjectResolverError(err.message, { team: options.team, title: options.title }, services);
+            if (enriched !== err.message) {
+                // Mutate in place rather than throwing a fresh Error — preserves
+                // the original error subclass and stack trace so consumers that
+                // rely on `instanceof` (or read `.stack` via EL_LINEAR_DEBUG=1)
+                // keep working. Only the user-facing message changes.
+                err.message = enriched;
+            }
+        }
+        throw err;
+    }
+}
 async function resolveCreateInputs(title, options, rootOpts) {
     const config = loadConfig();
     enforceTerms([title, options.description], { strict: options.strict });
@@ -244,6 +297,22 @@ async function resolveCreateInputs(title, options, rootOpts) {
         if (validationResult.normalizedLabels) {
             options.labels = validationResult.normalizedLabels.join(",");
         }
+        // Match the team-resolution rule used for the create call below
+        // (line ~389): fall back to config.defaultTeam when --team is omitted.
+        // Without this, users with a configured default team would see bare
+        // validation errors with no suggestions — the exact opposite of what
+        // the AI-coding-agent use case needs.
+        const enrichTeam = options.team || config.defaultTeam;
+        if (validationResult.errors.length > 0 && enrichTeam) {
+            try {
+                const graphQLService = await createGraphQLService(rootOpts);
+                const linearService = await createLinearService(rootOpts);
+                await enrichValidationErrors(validationResult, { team: enrichTeam, title }, { graphQLService, linearService });
+            }
+            catch {
+                // Best-effort enrichment — never block the original error.
+            }
+        }
         enforceValidation(validationResult);
     }
     if (!effectivePriorityInput) {
@@ -254,9 +323,16 @@ async function resolveCreateInputs(title, options, rootOpts) {
     const assigneeId = effectiveAssignee
         ? await resolveAssignee(effectiveAssignee, rootOpts)
         : undefined;
+    const delegateId = options.delegate
+        ? resolveMember(options.delegate)
+        : undefined;
     let labelIds = [];
     if (options.labels) {
-        labelIds = resolveLabels(splitList(options.labels), teamInput);
+        // No `teamInput`: team-scoped labels are resolved API-side against the
+        // issue's *final* team, which `createIssue` may auto-switch to match
+        // the project. Resolving a team-scoped config UUID here would pin the
+        // label to the pre-switch team and Linear would reject the mismatch.
+        labelIds = resolveLabels(splitList(options.labels));
     }
     if (options.claude) {
         const claudeId = config.labels.workspace.claude;
@@ -280,6 +356,7 @@ async function resolveCreateInputs(title, options, rootOpts) {
         teamInput,
         teamId,
         assigneeId,
+        delegateId,
         labelIds,
         status,
         subscriberIds,
@@ -318,7 +395,7 @@ function buildDescriptionWithAttachments(baseDescription, uploadResults) {
 }
 async function handleCreateIssue(title, options, command) {
     const rootOpts = getRootOpts(command);
-    const { teamInput, teamId, assigneeId, labelIds, status, subscriberIds, priority, } = await resolveCreateInputs(title ?? "", options, rootOpts);
+    const { teamInput, teamId, assigneeId, delegateId, labelIds, status, subscriberIds, priority, } = await resolveCreateInputs(title ?? "", options, rootOpts);
     const uploadResults = await uploadAttachmentsIfNeeded(options, rootOpts);
     const descriptionWithAttachments = buildDescriptionWithAttachments(resolveDescription(options) || "", uploadResults);
     // Append messageFooter (config or --footer flag) so auto-link picks up any
@@ -330,14 +407,12 @@ async function handleCreateIssue(title, options, command) {
         footer: explicitFooter,
         noFooter,
     }) ?? "";
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { graphQLService, linearService, issuesService } = await createIssuesService(rootOpts);
     // Wrap valid issue identifiers as markdown links before creating, so the description
     // saved on Linear has clickable refs from the start. Self-reference can't apply here
     // because the issue doesn't exist yet — pass undefined.
     const prepared = await prepareAutoLinkedDescription(description || undefined, options, undefined, linearService, graphQLService);
-    const result = await issuesService.createIssue({
+    const result = await withProjectResolverEnrichment(() => issuesService.createIssue({
         // title is omitted when --from-template is set without an override,
         // so Linear copies the template's title server-side.
         ...(title ? { title } : {}),
@@ -345,6 +420,7 @@ async function handleCreateIssue(title, options, command) {
         teamInput,
         description: prepared.description,
         assigneeId,
+        delegateId,
         priority,
         projectId: options.project,
         statusId: status,
@@ -360,7 +436,7 @@ async function handleCreateIssue(title, options, command) {
         ...(typeof options.fromTemplate === "string" && options.fromTemplate
             ? { templateId: options.fromTemplate }
             : {}),
-    });
+    }), { team: options.team ?? loadConfig().defaultTeam, title }, { graphQLService, linearService });
     const relations = await createRelations(result.id, options, graphQLService, linearService);
     // Pass the ORIGINAL description (pre-wrap) so the extractor's prose-keyword inference
     // ("blocked by", "duplicates", etc.) sees `keyword DEV-100` instead of `keyword [DEV-100](url)`.
@@ -471,6 +547,53 @@ async function handleRelatedIssues(issueId, _options, command) {
         meta: { count: entries.length },
     });
 }
+async function handleStartIssue(issueId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const { issuesService } = await createIssuesService(rootOpts);
+    const result = await issuesService.startIssue(issueId);
+    outputSuccess({
+        ...result.issue,
+        started: result.started,
+        ...(result.previousState ? { previousState: result.previousState } : {}),
+        ...(result.targetState ? { targetState: result.targetState } : {}),
+    });
+}
+// Field-mutating options on `issues update`, post alias-normalization.
+// If none of these are set, an `issues update` invocation that carries only
+// relation flags is treated as relation-only (see handleUpdateIssue): it must
+// behave exactly like `issues relate` and NOT issue an issueUpdate mutation,
+// which would otherwise apply the config defaultPriority fallback and bump the
+// issue's activity for what the user intended as a pure relation add.
+const UPDATE_FIELD_OPTION_KEYS = [
+    "title",
+    "description",
+    "appendDescription",
+    "status",
+    "priority",
+    "assignee",
+    "delegate",
+    "clearDelegate",
+    "project",
+    "labels",
+    "clearLabels",
+    "parentTicket",
+    "clearParentTicket",
+    "projectMilestone",
+    "clearProjectMilestone",
+    "cycle",
+    "clearCycle",
+    "dueDate",
+    "clearDueDate",
+];
+function hasFieldUpdates(options) {
+    return UPDATE_FIELD_OPTION_KEYS.some((key) => options[key] !== undefined && options[key] !== false);
+}
+function hasRelationFlags(options) {
+    return Boolean(options.relatedTo ||
+        options.blocks ||
+        options.blockedBy ||
+        options.duplicateOf);
+}
 async function handleUpdateIssue(issueId, options, command) {
     // Normalize aliases
     if (options.state && !options.status) {
@@ -479,14 +602,31 @@ async function handleUpdateIssue(issueId, options, command) {
     if (options.label && !options.labels) {
         options.labels = options.label;
     }
+    if (options.parent && !options.parentTicket) {
+        options.parentTicket = options.parent;
+    }
     // Resolve --description-file before validation
     if (options.descriptionFile) {
         options.description = readDescriptionFile(options.descriptionFile);
     }
     validateUpdateOptions(options);
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
+    const { graphQLService, linearService, issuesService } = await createIssuesService(rootOpts);
+    // Relation-only update: no field changes, just relation flags. Behave
+    // identically to `issues relate` — never call updateIssue, so no
+    // defaultPriority side effect and no spurious issue activity.
+    if (!hasFieldUpdates(options) && hasRelationFlags(options)) {
+        const sourceId = await linearService.resolveIssueId(issueId);
+        const relations = await createRelations(sourceId, options, graphQLService, linearService);
+        if (relations.length === 0) {
+            throw new Error("Specify at least one of: --related-to, --blocks, --blocked-by, --duplicate-of");
+        }
+        outputSuccess({
+            data: relations,
+            meta: { count: relations.length, source: issueId },
+        });
+        return;
+    }
     if (options.appendDescription) {
         const resolved = await linearService.resolveIssueId(issueId);
         const current = await graphQLService.rawRequest("query($id: String!) { issue(id: $id) { description } }", {
@@ -516,12 +656,24 @@ async function handleUpdateIssue(issueId, options, command) {
     if (prepared.description !== undefined) {
         options.description = prepared.description;
     }
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
     const assigneeId = options.assignee
         ? await resolveAssignee(options.assignee, rootOpts)
         : undefined;
-    const updateArgs = buildUpdateArgs(issueId, options, assigneeId);
-    const result = await issuesService.updateIssue(updateArgs, options.labelBy || "adding");
+    const delegateId = options.clearDelegate
+        ? null
+        : options.delegate
+            ? resolveMember(options.delegate)
+            : undefined;
+    const updateArgs = buildUpdateArgs(issueId, options, assigneeId, delegateId);
+    const result = await withProjectResolverEnrichment(() => issuesService.updateIssue(updateArgs, options.labelBy || "adding"), {
+        team: options.team ?? loadConfig().defaultTeam,
+        title: options.title,
+    }, { graphQLService, linearService });
+    // Mirror `issues create` / `issues relate`: the --related-to / --blocks /
+    // --blocked-by / --duplicate-of flags create sidebar relations on the
+    // updated issue. Without this, callers wanting to add a relation to an
+    // existing issue have to make a second `issues relate` call.
+    const relations = await createRelations(result.id, options, graphQLService, linearService);
     const autoLinked = originalDescription
         ? await maybeAutoLink({
             issueId: result.id,
@@ -533,13 +685,15 @@ async function handleUpdateIssue(issueId, options, command) {
             linearService,
         })
         : undefined;
-    outputSuccess(autoLinked ? { ...result, autoLinked } : result);
+    outputSuccess({
+        ...result,
+        ...(relations.length > 0 ? { relations } : {}),
+        ...(autoLinked ? { autoLinked } : {}),
+    });
 }
 async function handleArchiveIssue(issueId, _options, command) {
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const result = await issuesService.archiveIssue(issueId);
     outputSuccess({
         success: true,
@@ -549,9 +703,7 @@ async function handleArchiveIssue(issueId, _options, command) {
 }
 async function handleDeleteIssue(issueId, options, command) {
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const permanentlyDelete = Boolean(options.permanentlyDelete || options.hard);
     const result = await issuesService.deleteIssue(issueId, {
         permanentlyDelete,
@@ -603,9 +755,7 @@ async function handleRetrolink(options, command) {
         ? commits.map((msg) => `- ${msg}`).join("\n")
         : `Retrolinked from branch: ${currentBranch}`;
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     let result;
     if (options.issue) {
         // Link to existing issue — fetch it and rename branch
@@ -631,7 +781,13 @@ async function handleRetrolink(options, command) {
     let newBranch;
     if (result.branchName) {
         newBranch = toBranchName(result.branchName);
-        execFileSync("git", ["branch", "-m", oldBranch, newBranch], {
+        // `--` BEFORE the ref operands terminates option parsing so a
+        // name starting with `-` (server bug, malicious slug, forked
+        // Linear-compatible API) is parsed as a ref name rather than a
+        // git flag. Defense in depth — the default feature/ prefix
+        // already blocks the common case, but the prefix is configurable
+        // (DEV-4064).
+        execFileSync("git", ["branch", "-m", "--", oldBranch, newBranch], {
             stdio: "pipe",
         });
     }
@@ -653,6 +809,7 @@ export function setupIssuesCommands(program) {
         .option("-l, --limit <number>", "limit results", "25")
         .option("--team <team>", "filter by team key (EL: resolves names)")
         .option("--assignee <assignee>", "filter by assignee (name, alias, or ID)")
+        .option("--delegate <delegate>", "filter by delegated agent (name, alias, or ID)")
         .option("--project <project>", "filter by project name or ID")
         .option("--no-project", "filter issues with no project assigned")
         .option("--labels <labels>", "filter by labels (comma-separated names)")
@@ -661,13 +818,14 @@ export function setupIssuesCommands(program) {
         .option("--priority <priority>", "filter by priority (comma-separated: urgent,high,medium,low,none or 0-4)")
         .option("--sort <field>", "sort results (priority, status, created, updated)")
         .option("--format <format>", "output format (json, summary, table, md, csv)", "json")
-        .option("--fields <fields>", "columns for table/csv (comma-separated: identifier,title,status,priority,assignee,project,team,labels,updated)")
+        .option("--fields <fields>", "columns for table/csv (comma-separated: identifier,title,status,priority,assignee,delegate,project,team,labels,updated)")
         .action(handleAsyncCommand(handleListIssues));
     issues
         .command("search <query>")
         .description("Search issues.")
         .option("--team <team>", "filter by team key, name, or ID")
         .option("--assignee <assignee>", "filter by assignee (name, alias, or ID)")
+        .option("--delegate <delegate>", "filter by delegated agent (name, alias, or ID)")
         .option("--project <project>", "filter by project name or ID")
         .option("--no-project", "filter issues with no project assigned")
         .option("--status <status>", "filter by status (comma-separated)")
@@ -688,6 +846,7 @@ export function setupIssuesCommands(program) {
         .option("--template <name>", "use a named description template from config.descriptionTemplates")
         .option("--from-template <id>", "instantiate the issue from a Linear server-side template (UUID from `el-linear templates list`). Sets templateId on the underlying issueCreate mutation; Linear copies the template's title, description, labels, priority, etc. as the new issue's defaults. Override any field with the matching --title / --description / --labels flag.")
         .option("-a, --assignee <assignee>", "assign to user (name, alias, or UUID)")
+        .option("--delegate <delegate>", "delegate implementation to an agent app user (name, alias, or UUID)")
         .option("--no-assignee", "create unassigned even when config.defaultAssignee is set")
         .option("-p, --priority <priority>", "priority: name (none/urgent/high/medium/normal/low) or number (0-4)")
         .option("--project <project>", "add to project (name or ID)")
@@ -699,6 +858,7 @@ export function setupIssuesCommands(program) {
         .option("--cycle <cycle>", "cycle name or ID")
         .option("--status <status>", "status name or ID")
         .option("--parent-ticket <parentId>", "parent issue ID or identifier")
+        .option("--parent <parentId>", "alias for --parent-ticket")
         .option("--subscriber <subscribers>", "subscribers (comma-separated names, aliases, or UUIDs)")
         .option("--strict", "strict brand validation (error instead of warning)")
         .option("--related-to <issues>", "related issues (comma-separated identifiers)")
@@ -716,6 +876,10 @@ export function setupIssuesCommands(program) {
         if (options.label && !options.labels) {
             options.labels = options.label;
         }
+        // Normalize --parent alias to --parent-ticket
+        if (options.parent && !options.parentTicket) {
+            options.parentTicket = options.parent;
+        }
         const title = options.title || titleArg;
         // --from-template lets Linear copy the template's title, so a
         // local title is optional in that path. Without --from-template,
@@ -732,7 +896,10 @@ export function setupIssuesCommands(program) {
         .alias("get")
         .alias("show")
         .description("Get issue details. Accepts multiple IDs for batch retrieval.")
-        .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.\nMultiple IDs: el-linear issue get DEV-123 DEV-456 DEV-789")
+        .option("--field <name>", 'Extract a single named section from the issue description (e.g. "Done when"). ' +
+        "Matches H2/H3 headers and bold pseudo-headers case-insensitively. " +
+        "Outputs the section text only — no JSON envelope. Single-issue only.")
+        .addHelpText("after", '\nBoth UUID and identifiers like ABC-123 are supported.\nMultiple IDs: el-linear issue get DEV-123 DEV-456 DEV-789\nExtract a section: el-linear issue read DEV-123 --field "Done when"')
         .action(handleAsyncCommand(readIssues));
     issues
         .command("update <issueId>")
@@ -748,12 +915,15 @@ export function setupIssuesCommands(program) {
         .option("--state <status>", "alias for --status (new status name or ID)")
         .option("-p, --priority <priority>", "new priority: name (none/urgent/high/medium/normal/low) or number (0-4)")
         .option("--assignee <assignee>", "new assignee (name, alias, or UUID)")
+        .option("--delegate <delegate>", "delegate implementation to an agent app user (name, alias, or UUID)")
+        .option("--clear-delegate", "remove the issue delegate")
         .option("--project <project>", "new project (name or ID)")
         .option("--labels <labels>", "labels (comma-separated names or IDs)")
         .option("--label <labels>", "alias for --labels")
         .option("--label-by <mode>", "how to apply labels: 'adding' (default) or 'overwriting'")
         .option("--clear-labels", "remove all labels from issue")
         .option("--parent-ticket <parentId>", "set parent issue")
+        .option("--parent <parentId>", "alias for --parent-ticket")
         .option("--clear-parent-ticket", "clear parent relationship")
         .option("--project-milestone <milestone>", "set project milestone")
         .option("--clear-project-milestone", "clear project milestone")
@@ -763,6 +933,10 @@ export function setupIssuesCommands(program) {
         .option("--clear-due-date", "clear due date")
         .option("--strict", "strict brand validation")
         .option("--no-auto-link", "skip auto-linking issue references found in the description")
+        .option("--related-to <issues>", "related issues (comma-separated)")
+        .option("--blocks <issues>", "issues this blocks (comma-separated)")
+        .option("--blocked-by <issues>", "issues blocking this (comma-separated)")
+        .option("--duplicate-of <issue>", "mark as duplicate of another issue")
         .action(handleAsyncCommand(handleUpdateIssue));
     issues
         .command("archive <issueId>")
@@ -786,6 +960,11 @@ export function setupIssuesCommands(program) {
         .description("Show issue state transition history (time in each status).")
         .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.")
         .action(handleAsyncCommand(handleHistoryIssue));
+    issues
+        .command("start <issueId>")
+        .description("Move an issue to the team's first started workflow state, unless it is already started or terminal.")
+        .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.")
+        .action(handleAsyncCommand(handleStartIssue));
     issues
         .command("relate <issueId>")
         .description("Create issue relations.")

package/dist/commands/labels.js

@@ -4,7 +4,7 @@ import { CREATE_LABEL_MUTATION, FIND_PARENT_LABEL_QUERY, RESTORE_LABEL_MUTATION,
 import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
-import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { handleAsyncCommand, outputSuccess, warnIfTruncated, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { parsePositiveInt, validateHexColor } from "../utils/validators.js";
 async function handleCreateLabel(name, options, command) {
@@ -82,6 +82,7 @@ export function setupLabelsCommands(program) {
             const service = await createLinearService(rootOpts);
             return service.getLabels(teamFilter, limit, nameFilter);
         });
+        warnIfTruncated(result.labels.length, limit);
         outputSuccess({
             data: result.labels,
             meta: { count: result.labels.length },

package/dist/commands/profile.js

@@ -48,6 +48,7 @@ export function setupProfileCommands(program) {
             data: {
                 name: active.name ?? "<default>",
                 configPath: active.configPath,
+                localConfigPath: active.localConfigPath,
                 tokenPath: active.tokenPath,
             },
         });

package/dist/commands/projects.d.ts

@@ -1,4 +1,6 @@
 import type { Command, OptionValues } from "commander";
+import type { LinearProject } from "../types/linear.js";
+export declare function sortActiveFirst(projects: LinearProject[]): LinearProject[];
 export declare function resolveProjectStateFilter(options: OptionValues): {
     states?: string[];
     excludeStates?: string[];