@enrichlayer/el-linear 1.9.0 → 1.15.0

package/dist/utils/graphql-issues-service.js

@@ -1,5 +1,5 @@
 import { resolveUserDisplayName } from "../config/resolver.js";
-import { BATCH_RESOLVE_FOR_CREATE_QUERY, BATCH_RESOLVE_FOR_SEARCH_QUERY, BATCH_RESOLVE_FOR_UPDATE_QUERY, buildResolveLabelsByNameQuery, CREATE_ISSUE_MUTATION, FILTERED_SEARCH_ISSUES_QUERY, GET_ISSUE_BY_ID_QUERY, GET_ISSUE_BY_IDENTIFIER_QUERY, GET_ISSUE_TEAM_QUERY, GET_ISSUES_QUERY, SEARCH_ISSUES_QUERY, UPDATE_ISSUE_MUTATION, } from "../queries/issues.js";
+import { ARCHIVE_ISSUE_MUTATION, BATCH_RESOLVE_FOR_CREATE_QUERY, BATCH_RESOLVE_FOR_SEARCH_QUERY, BATCH_RESOLVE_FOR_UPDATE_QUERY, buildResolveLabelsByNameQuery, CREATE_ISSUE_MUTATION, DELETE_ISSUE_MUTATION, FILTERED_SEARCH_ISSUES_QUERY, GET_ISSUE_BY_ID_QUERY, GET_ISSUE_BY_IDENTIFIER_QUERY, GET_ISSUE_START_CONTEXT_QUERY, GET_ISSUE_TEAM_QUERY, GET_ISSUES_QUERY, SEARCH_ISSUES_QUERY, TEAM_STARTED_STATUSES_QUERY, UPDATE_ISSUE_MUTATION, } from "../queries/issues.js";
 import { CREATE_LABEL_MUTATION } from "../queries/labels.js";
 import { toISOStringOrNow } from "./date-format.js";
 import { extractEmbeds } from "./embed-parser.js";
@@ -14,7 +14,7 @@ function extractSummaryText(summary) {
     }
     const parts = [];
     const walk = (node) => {
-        if (node.text) {
+        if (typeof node.text === "string") {
             parts.push(node.text);
         }
         if (Array.isArray(node.content)) {
@@ -34,15 +34,12 @@ export class GraphQLIssuesService {
         this.linearService = linearService;
     }
     async getIssues(limit = 25) {
-        const result = await this.graphQLService.rawRequest(GET_ISSUES_QUERY, {
-            first: limit,
-            orderBy: "updatedAt",
-        });
-        const issues = result.issues;
-        if (!issues?.nodes) {
+        const result = await this.graphQLService.rawRequest(GET_ISSUES_QUERY, { first: limit, orderBy: "updatedAt" });
+        const nodes = result.issues?.nodes;
+        if (!nodes?.length) {
             return [];
         }
-        return issues.nodes.map((issue) => this.transformIssueData(issue));
+        return nodes.map((issue) => this.transformIssueData(issue));
     }
     async getIssueById(issueId) {
         let issueData;
@@ -55,12 +52,8 @@ export class GraphQLIssuesService {
         }
         else {
             const { teamKey, issueNumber } = parseIssueIdentifier(issueId);
-            const result = await this.graphQLService.rawRequest(GET_ISSUE_BY_IDENTIFIER_QUERY, {
-                teamKey,
-                number: issueNumber,
-            });
-            const issues = result.issues;
-            const nodes = issues?.nodes;
+            const result = await this.graphQLService.rawRequest(GET_ISSUE_BY_IDENTIFIER_QUERY, { teamKey, number: issueNumber });
+            const nodes = result.issues?.nodes;
             if (!nodes?.length) {
                 throw notFoundError("Issue", issueId);
             }
@@ -68,44 +61,116 @@ export class GraphQLIssuesService {
         }
         return this.transformIssueData(issueData);
     }
+    async startIssue(issueId) {
+        const resolvedIssueId = await this.linearService.resolveIssueId(issueId);
+        const context = await this.graphQLService.rawRequest(GET_ISSUE_START_CONTEXT_QUERY, { id: resolvedIssueId });
+        const issue = context.issue;
+        if (!issue) {
+            throw notFoundError("Issue", issueId);
+        }
+        const previousState = issue.state
+            ? {
+                id: issue.state.id,
+                name: issue.state.name,
+                type: issue.state.type,
+            }
+            : undefined;
+        if (previousState &&
+            ["started", "completed", "canceled"].includes(previousState.type)) {
+            return {
+                issue: await this.getIssueById(resolvedIssueId),
+                previousState,
+                started: false,
+            };
+        }
+        if (!issue.team?.id) {
+            throw new Error(`Issue ${issue.identifier} has no team; cannot start it.`);
+        }
+        const statuses = await this.graphQLService.rawRequest(TEAM_STARTED_STATUSES_QUERY, { teamId: issue.team.id });
+        const startedStatus = statuses.team?.states.nodes
+            .slice()
+            .sort((a, b) => a.position - b.position)[0];
+        if (!startedStatus) {
+            throw new Error(`Team ${issue.team.key} has no workflow status of type "started".`);
+        }
+        const updated = await this.updateIssue({ id: resolvedIssueId, statusId: startedStatus.id }, "adding");
+        return {
+            issue: updated,
+            previousState,
+            started: true,
+            targetState: { id: startedStatus.id, name: startedStatus.name },
+        };
+    }
     async updateIssue(args, labelMode = "overwriting") {
-        const { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult } = await this.resolveUpdateContext(args);
+        // Normalize URL/slug-id --project inputs to UUIDs before the batch
+        // resolver runs; see comment on `withNormalizedProjectId`.
+        const normalizedArgs = await this.withNormalizedProjectId(args);
+        const { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult } = await this.resolveUpdateContext(normalizedArgs);
         let teamIdForLabels = issueTeamId;
-        if (!teamIdForLabels && args.labelIds && resolvedIssueId) {
+        if (!teamIdForLabels && normalizedArgs.labelIds && resolvedIssueId) {
             teamIdForLabels = await this.fetchIssueTeamId(resolvedIssueId);
         }
-        const finalLabelIds = await this.resolveLabelsWithMode(args.labelIds, resolveResult, labelMode, currentIssueLabels, teamIdForLabels, args.teamId);
-        const finalProjectId = args.projectId
-            ? this.resolveProjectId(args.projectId, resolveResult)
+        const finalLabelIds = await this.resolveLabelsWithMode(normalizedArgs.labelIds, resolveResult, labelMode, currentIssueLabels, teamIdForLabels, normalizedArgs.teamId);
+        const finalProjectId = normalizedArgs.projectId
+            ? this.resolveProjectId(normalizedArgs.projectId, resolveResult)
             : undefined;
-        const { projectMilestoneNodes, issueProjectMilestoneNodes } = this.extractMilestoneNodes(args, resolveResult);
-        const finalMilestoneId = this.resolveMilestoneId(args.milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes);
-        const finalCycleId = await this.resolveCycleIdForUpdate(args, resolveResult, resolvedIssueId);
-        const resolvedStatusId = await this.resolveStatusIdForUpdate(args, resolvedIssueId);
+        const { projectMilestoneNodes, issueProjectMilestoneNodes } = this.extractMilestoneNodes(normalizedArgs, resolveResult);
+        const finalMilestoneId = this.resolveMilestoneId(normalizedArgs.milestoneId, resolveResult, projectMilestoneNodes, issueProjectMilestoneNodes);
+        const finalCycleId = await this.resolveCycleIdForUpdate(normalizedArgs, resolveResult, resolvedIssueId);
+        const resolvedStatusId = await this.resolveStatusIdForUpdate(normalizedArgs, resolvedIssueId);
         // Resolve assignee in place — `buildUpdateInput` reads it
         // directly. Match the createIssue pattern.
-        let assigneeId = args.assigneeId;
+        let assigneeId = normalizedArgs.assigneeId;
         if (assigneeId && !isUuid(assigneeId)) {
             assigneeId = await this.linearService.resolveUserId(assigneeId);
         }
-        const updateInput = this.buildUpdateInput({ ...args, assigneeId }, {
+        let delegateId = normalizedArgs.delegateId;
+        if (delegateId && !isUuid(delegateId)) {
+            delegateId = await this.linearService.resolveUserId(delegateId);
+        }
+        const updateInput = this.buildUpdateInput({ ...normalizedArgs, assigneeId, delegateId }, {
             statusId: resolvedStatusId,
             projectId: finalProjectId,
             labelIds: finalLabelIds,
             milestoneId: finalMilestoneId,
             cycleId: finalCycleId,
         });
-        return this.executeUpdateMutation(resolvedIssueId, args.id, updateInput);
+        return this.executeUpdateMutation(resolvedIssueId, normalizedArgs.id, updateInput);
+    }
+    async archiveIssue(issueId) {
+        const resolvedIssueId = await this.linearService.resolveIssueId(issueId);
+        const result = await this.graphQLService.rawRequest(ARCHIVE_ISSUE_MUTATION, { id: resolvedIssueId });
+        const payload = result.issueArchive;
+        if (!payload.success) {
+            throw new Error(`Failed to archive issue ${issueId}`);
+        }
+        return {
+            id: resolvedIssueId,
+            entity: payload.entity ?? undefined,
+            lastSyncId: payload.lastSyncId,
+        };
+    }
+    async deleteIssue(issueId, options = {}) {
+        const resolvedIssueId = await this.linearService.resolveIssueId(issueId);
+        const result = await this.graphQLService.rawRequest(DELETE_ISSUE_MUTATION, {
+            id: resolvedIssueId,
+            permanentlyDelete: Boolean(options.permanentlyDelete),
+        });
+        const payload = result.issueDelete;
+        if (!payload.success) {
+            throw new Error(`Failed to delete issue ${issueId}`);
+        }
+        return {
+            id: resolvedIssueId,
+            entity: payload.entity ?? undefined,
+            lastSyncId: payload.lastSyncId,
+        };
     }
     extractMilestoneNodes(args, resolveResult) {
-        const projectNodes = resolveResult.projects?.nodes;
         const projectMilestoneNodes = args.projectId
-            ? projectNodes?.[0]?.projectMilestones?.nodes
+            ? resolveResult.projects?.nodes?.[0]?.projectMilestones?.nodes
             : undefined;
-        const issueNodes = resolveResult.issues
-            ?.nodes;
-        const issueProjectMilestoneNodes = issueNodes?.[0]?.project
-            ?.projectMilestones?.nodes;
+        const issueProjectMilestoneNodes = resolveResult.issues?.nodes?.[0]?.project?.projectMilestones.nodes;
         return { projectMilestoneNodes, issueProjectMilestoneNodes };
     }
     async executeUpdateMutation(resolvedIssueId, originalId, updateInput) {
@@ -136,34 +201,72 @@ export class GraphQLIssuesService {
         return this.transformIssueData(issueUpdate.issue);
     }
     async createIssue(args) {
-        const resolveVariables = this.buildCreateResolveVariables(args);
+        // Pre-resolve URL/slug-id forms of --project to a UUID so the batch
+        // resolver below (which uses a `name eqIgnoreCase` filter) can skip
+        // the project lookup entirely. Plain name inputs flow through unchanged
+        // and get resolved by the batch query in a single round-trip.
+        const normalizedArgs = await this.withNormalizedProjectId(args);
+        const resolveVariables = this.buildCreateResolveVariables(normalizedArgs);
         let resolveResult = {};
         if (Object.keys(resolveVariables).length > 0) {
             const { __labelNames, ...queryVars } = resolveVariables;
-            const requests = [
-                this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_CREATE_QUERY, queryVars),
-            ];
+            const batchPromise = this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_CREATE_QUERY, queryVars);
             if (__labelNames) {
                 const labelQuery = buildResolveLabelsByNameQuery(__labelNames);
-                requests.push(this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables));
+                const [batch, labels] = await Promise.all([
+                    batchPromise,
+                    this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables),
+                ]);
+                resolveResult = {
+                    ...this.foldCreateBatchResult(batch),
+                    labels: labels.labels,
+                };
             }
-            const results = await Promise.all(requests);
-            resolveResult = results[0];
-            if (results[1]) {
-                resolveResult.labels = results[1].labels;
+            else {
+                resolveResult = this.foldCreateBatchResult(await batchPromise);
             }
         }
-        const resolved = await this.resolveCreateFields(args, resolveResult);
+        const resolved = await this.resolveCreateFields(normalizedArgs, resolveResult);
         // Mutate-the-input feels gross but matches the existing pattern
         // — `resolved` doesn't carry assigneeId, so the buildCreateInput
         // step reads `args.assigneeId` directly. Resolve in place.
-        let assigneeId = args.assigneeId;
+        let assigneeId = normalizedArgs.assigneeId;
         if (assigneeId && !isUuid(assigneeId)) {
             assigneeId = await this.linearService.resolveUserId(assigneeId);
         }
-        const createInput = this.buildCreateInput({ ...args, assigneeId }, resolved);
+        let delegateId = normalizedArgs.delegateId;
+        if (delegateId && !isUuid(delegateId)) {
+            delegateId = await this.linearService.resolveUserId(delegateId);
+        }
+        const createInput = this.buildCreateInput({ ...normalizedArgs, assigneeId, delegateId }, resolved);
         return this.executeCreateMutation(createInput);
     }
+    /**
+     * Folds the `@include`-gated `projectsByName` / `projectsById` aliases
+     * from a create batch response into the single `projects` field the
+     * field-resolution helpers expect. At most one project alias is ever
+     * present, since a `--project` input is either a name or a UUID.
+     */
+    foldCreateBatchResult(batch) {
+        return {
+            teams: batch.teams,
+            projects: batch.projectsByName ?? batch.projectsById,
+            milestones: batch.milestones,
+            parentIssues: batch.parentIssues,
+        };
+    }
+    /**
+     * Folds the `@include`-gated `projectsByName` / `projectsById` aliases
+     * from an update batch response into the single `projects` field the
+     * field-resolution helpers expect. See `foldCreateBatchResult`.
+     */
+    foldUpdateBatchResult(batch) {
+        return {
+            projects: batch.projectsByName ?? batch.projectsById,
+            milestones: batch.milestones,
+            issues: batch.issues,
+        };
+    }
     async resolveCreateFields(args, resolveResult) {
         let teamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
@@ -221,40 +324,65 @@ export class GraphQLIssuesService {
         if (args.teamId && !isUuid(args.teamId)) {
             Object.assign(resolveVariables, this.buildResolveVariablesForTeam(args.teamId));
         }
-        if (args.projectId && !isUuid(args.projectId)) {
-            resolveVariables.projectName = args.projectId;
+        // Only the `id` arm carries a name/UUID for resolution; `none` and
+        // `undefined` skip the resolve.
+        const projectIdArg = args.project?.kind === "id" ? args.project.id : undefined;
+        if (projectIdArg && !isUuid(projectIdArg)) {
+            resolveVariables.projectName = projectIdArg;
+            resolveVariables.hasProjectName = true;
         }
         if (args.assigneeId &&
             !isUuid(args.assigneeId) &&
             args.assigneeId.includes("@")) {
             resolveVariables.assigneeEmail = args.assigneeId;
         }
+        if (args.delegateId &&
+            !isUuid(args.delegateId) &&
+            args.delegateId.includes("@")) {
+            resolveVariables.delegateEmail = args.delegateId;
+        }
         let resolveResult = {};
         if (Object.keys(resolveVariables).length > 0) {
-            resolveResult = await this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_SEARCH_QUERY, resolveVariables);
+            resolveResult =
+                await this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_SEARCH_QUERY, resolveVariables);
         }
         const finalTeamId = args.teamId
             ? await this.resolveTeamId(args.teamId, resolveResult)
             : undefined;
-        const finalProjectId = args.projectId
-            ? this.resolveProjectId(args.projectId, resolveResult)
+        const finalProjectId = projectIdArg
+            ? this.resolveProjectId(projectIdArg, resolveResult)
             : undefined;
         const finalAssigneeId = this.resolveAssigneeId(args.assigneeId, resolveResult);
+        const finalDelegateId = await this.resolveDelegateId(args.delegateId, resolveResult);
+        // Map the public discriminant back to the internal filter shape:
+        // `{ kind: "id", id }` → `{ kind: "id", id: <resolvedUuid> }`
+        // `{ kind: "none" }`  → pass through
+        // undefined            → undefined (filter off)
+        // Reused by both the full-text and structured search paths so
+        // `--no-project` (`{ kind: "none" }`) participates in both — pre-fix,
+        // the full-text branch silently dropped `noProject` because only
+        // the resolved `projectId` was forwarded.
+        const projectFilter = args.project?.kind === "id" && finalProjectId
+            ? { kind: "id", id: finalProjectId }
+            : args.project?.kind === "none"
+                ? { kind: "none" }
+                : undefined;
         const limit = args.limit ?? 10;
         if (args.query) {
             const searchResult = await this.graphQLService.rawRequest(SEARCH_ISSUES_QUERY, {
                 term: args.query,
                 first: limit,
             });
-            const searchIssues = searchResult.searchIssues;
-            if (!searchIssues?.nodes) {
+            const nodes = searchResult.searchIssues?.nodes;
+            if (!nodes?.length) {
                 return [];
             }
-            const results = searchIssues.nodes.map((issue) => this.transformIssueData(issue));
+            const results = nodes.map((issue) => this.transformIssueData(issue));
             return this.applySearchFilters(results, {
                 teamId: finalTeamId,
                 assigneeId: finalAssigneeId,
-                projectId: finalProjectId,
+                delegateId: finalDelegateId,
+                project: projectFilter,
                 status: args.status,
                 labelNames: args.labelNames,
                 priority: args.priority,
@@ -263,8 +391,8 @@ export class GraphQLIssuesService {
         const filter = this.buildSearchFilter({
             teamId: finalTeamId,
             assigneeId: finalAssigneeId,
-            projectId: finalProjectId,
-            noProject: args.noProject,
+            delegateId: finalDelegateId,
+            project: projectFilter,
             status: args.status,
             labelNames: args.labelNames,
             priority: args.priority,
@@ -285,8 +413,7 @@ export class GraphQLIssuesService {
         if (isUuid(teamId)) {
             return teamId;
         }
-        const teams = resolveResult.teams;
-        const teamNodes = teams?.nodes;
+        const teamNodes = resolveResult.teams?.nodes;
         const resolvedTeam = teamNodes?.[0];
         if (resolvedTeam &&
             (resolvedTeam.key.toUpperCase() === teamId.toUpperCase() ||
@@ -298,10 +425,21 @@ export class GraphQLIssuesService {
     }
     resolveProjectId(projectId, resolveResult) {
         if (isUuid(projectId)) {
+            // The create/update batch queries fetch a `projectsById` block for a
+            // UUID `--project` (folded into `resolveResult.projects`). An empty
+            // `nodes` array means the block ran but matched nothing — i.e. the
+            // UUID doesn't exist. Fail clearly here instead of passing a dead
+            // UUID to the mutation, which would surface a vague server error.
+            // When no block was fetched (`projects` undefined — e.g. the search
+            // path has no `projectsById` arm) there's nothing to validate, so
+            // the UUID passes through unchanged.
+            const fetched = resolveResult.projects?.nodes;
+            if (fetched && fetched.length === 0) {
+                throw notFoundError("Project", projectId);
+            }
             return projectId;
         }
-        const projects = resolveResult.projects;
-        const projectNodes = projects?.nodes;
+        const projectNodes = resolveResult.projects?.nodes;
         if (!projectNodes?.length) {
             throw notFoundError("Project", projectId);
         }
@@ -312,13 +450,11 @@ export class GraphQLIssuesService {
      * If not, auto-switch when the project belongs to exactly one team.
      */
     validateProjectTeam(teamId, projectInput, resolveResult) {
-        const projects = resolveResult.projects;
-        const projectNode = projects?.nodes?.[0];
+        const projectNode = resolveResult.projects?.nodes?.[0];
         if (!projectNode) {
             return teamId;
         }
-        const teamsConn = projectNode.teams;
-        const teamNodes = teamsConn?.nodes;
+        const teamNodes = projectNode.teams?.nodes;
         if (!teamNodes?.length) {
             return teamId;
         }
@@ -346,8 +482,7 @@ export class GraphQLIssuesService {
             return labelIds;
         }
         const resolvedLabels = [];
-        const labels = resolveResult.labels;
-        const labelNodes = labels?.nodes;
+        const labelNodes = resolveResult.labels?.nodes;
         for (const labelIdOrName of labelIds) {
             if (isUuid(labelIdOrName)) {
                 resolvedLabels.push(labelIdOrName);
@@ -357,10 +492,7 @@ export class GraphQLIssuesService {
                 const candidates = labelNodes?.filter((l) => l.name.toLowerCase() === lowerName);
                 let label;
                 if (candidates && candidates.length > 1 && teamId) {
-                    label = candidates.find((l) => {
-                        const team = l.team;
-                        return team?.id === teamId;
-                    });
+                    label = candidates.find((l) => l.team?.id === teamId);
                 }
                 if (!label) {
                     label = candidates?.[0];
@@ -402,12 +534,10 @@ export class GraphQLIssuesService {
             }
             const result = await this.graphQLService.rawRequest(CREATE_LABEL_MUTATION, { input });
             const created = result.issueLabelCreate;
-            if (created?.success && created.issueLabel) {
-                const labelData = created.issueLabel;
-                const teamInfo = labelData.team;
-                const teamKey = teamInfo?.key ?? "";
+            if (created.success && created.issueLabel) {
+                const teamKey = created.issueLabel.team?.key ?? "";
                 logger.error(`Auto-created label "${name}" on team ${teamKey}`);
-                return labelData.id;
+                return created.issueLabel.id;
             }
             return null;
         }
@@ -435,37 +565,27 @@ export class GraphQLIssuesService {
         // Only fall back to first team if there's exactly one (unambiguous).
         // With multiple teams, returning an arbitrary one produces misleading error hints.
         const topLevelNodes = resolveResult.teams?.nodes;
-        return topLevelNodes?.length === 1
-            ? topLevelNodes[0].key
-            : undefined;
+        return topLevelNodes?.length === 1 ? topLevelNodes[0].key : undefined;
     }
     collectTeamNodes(resolveResult) {
         const nodes = [];
         const seen = new Set();
-        const topTeams = resolveResult.teams;
-        const topNodes = topTeams?.nodes;
+        const topNodes = resolveResult.teams?.nodes;
         if (topNodes) {
             for (const t of topNodes) {
-                const id = t.id;
-                if (!seen.has(id)) {
-                    seen.add(id);
+                if (!seen.has(t.id)) {
+                    seen.add(t.id);
                     nodes.push(t);
                 }
             }
         }
         // Also check project teams (which are always fetched when --project is used)
-        const projects = resolveResult.projects;
-        const projectNode = projects?.nodes?.[0];
-        if (projectNode) {
-            const projectTeams = projectNode.teams;
-            const projectTeamNodes = projectTeams?.nodes;
-            if (projectTeamNodes) {
-                for (const t of projectTeamNodes) {
-                    const id = t.id;
-                    if (!seen.has(id)) {
-                        seen.add(id);
-                        nodes.push(t);
-                    }
+        const projectTeamNodes = resolveResult.projects?.nodes?.[0]?.teams?.nodes;
+        if (projectTeamNodes) {
+            for (const t of projectTeamNodes) {
+                if (!seen.has(t.id)) {
+                    seen.add(t.id);
+                    nodes.push(t);
                 }
             }
         }
@@ -488,8 +608,7 @@ export class GraphQLIssuesService {
                 resolved = issueMilestone.id;
             }
         }
-        const milestones = resolveResult.milestones;
-        const milestoneNodes = milestones?.nodes;
+        const milestoneNodes = resolveResult.milestones?.nodes;
         if (!isUuid(resolved) && milestoneNodes?.length) {
             resolved = milestoneNodes[0].id;
         }
@@ -503,19 +622,14 @@ export class GraphQLIssuesService {
             return milestoneId;
         }
         let resolved;
-        const createProjects = resolveResult.projects;
-        const createProjectNodes = createProjects?.nodes;
-        const createProjectMilestones = createProjectNodes?.[0]
-            ?.projectMilestones;
-        const createProjectMilestoneNodes = createProjectMilestones?.nodes;
+        const createProjectMilestoneNodes = resolveResult.projects?.nodes?.[0]?.projectMilestones?.nodes;
         if (createProjectMilestoneNodes) {
             const projectMilestone = createProjectMilestoneNodes.find((m) => m.name === milestoneId);
             if (projectMilestone) {
                 resolved = projectMilestone.id;
             }
         }
-        const createMilestones = resolveResult.milestones;
-        const createMilestoneNodes = createMilestones?.nodes;
+        const createMilestoneNodes = resolveResult.milestones?.nodes;
         if (!resolved && createMilestoneNodes?.length) {
             resolved = createMilestoneNodes[0].id;
         }
@@ -528,12 +642,8 @@ export class GraphQLIssuesService {
         return resolved;
     }
     async fetchIssueTeamId(issueId) {
-        const result = await this.graphQLService.rawRequest(GET_ISSUE_TEAM_QUERY, {
-            issueId,
-        });
-        const fetchedIssue = result.issue;
-        const fetchedTeam = fetchedIssue?.team;
-        return fetchedTeam?.id;
+        const result = await this.graphQLService.rawRequest(GET_ISSUE_TEAM_QUERY, { issueId });
+        return result.issue?.team?.id;
     }
     buildCreateInput(args, resolved) {
         const input = {};
@@ -553,6 +663,9 @@ export class GraphQLIssuesService {
         if (args.assigneeId) {
             input.assigneeId = args.assigneeId;
         }
+        if (args.delegateId) {
+            input.delegateId = args.delegateId;
+        }
         if (args.priority !== undefined) {
             input.priority = args.priority;
         }
@@ -608,6 +721,9 @@ export class GraphQLIssuesService {
         if (args.assigneeId !== undefined) {
             input.assigneeId = args.assigneeId;
         }
+        if (args.delegateId !== undefined) {
+            input.delegateId = args.delegateId;
+        }
         if (resolved.projectId !== undefined) {
             input.projectId = resolved.projectId;
         }
@@ -646,8 +762,22 @@ export class GraphQLIssuesService {
         if (filters.assigneeId) {
             filtered = filtered.filter((issue) => issue.assignee?.id === filters.assigneeId);
         }
-        if (filters.projectId) {
-            filtered = filtered.filter((issue) => issue.project?.id === filters.projectId);
+        if (filters.delegateId) {
+            filtered = filtered.filter((issue) => issue.delegate?.id === filters.delegateId);
+        }
+        if (filters.project) {
+            switch (filters.project.kind) {
+                case "id": {
+                    const id = filters.project.id;
+                    filtered = filtered.filter((issue) => issue.project?.id === id);
+                    break;
+                }
+                case "none":
+                    filtered = filtered.filter((issue) => !issue.project);
+                    break;
+                default:
+                    return filters.project;
+            }
         }
         if (filters.status && filters.status.length > 0) {
             filtered = filtered.filter((issue) => filters.status.includes(issue.state?.name ?? ""));
@@ -672,11 +802,20 @@ export class GraphQLIssuesService {
         if (filters.assigneeId) {
             filter.assignee = { id: { eq: filters.assigneeId } };
         }
-        if (filters.noProject) {
-            filter.project = { null: true };
-        }
-        else if (filters.projectId) {
-            filter.project = { id: { eq: filters.projectId } };
+        if (filters.delegateId) {
+            filter.delegate = { id: { eq: filters.delegateId } };
+        }
+        if (filters.project) {
+            switch (filters.project.kind) {
+                case "id":
+                    filter.project = { id: { eq: filters.project.id } };
+                    break;
+                case "none":
+                    filter.project = { null: true };
+                    break;
+                default:
+                    return filters.project;
+            }
         }
         if (filters.status && filters.status.length > 0) {
             filter.state = { name: { in: filters.status } };
@@ -704,13 +843,25 @@ export class GraphQLIssuesService {
         if (!assigneeId || isUuid(assigneeId) || !assigneeId.includes("@")) {
             return assigneeId;
         }
-        const users = resolveResult.users;
-        const userNodes = users?.nodes;
+        const userNodes = resolveResult.users?.nodes;
         if (!userNodes?.length) {
             throw notFoundError("User", assigneeId);
         }
         return userNodes[0].id;
     }
+    async resolveDelegateId(delegateId, resolveResult) {
+        if (!delegateId || isUuid(delegateId)) {
+            return delegateId;
+        }
+        if (!delegateId.includes("@")) {
+            return this.linearService.resolveUserId(delegateId);
+        }
+        const userNodes = resolveResult.delegates?.nodes;
+        if (!userNodes?.length) {
+            throw notFoundError("Delegate", delegateId);
+        }
+        return userNodes[0].id;
+    }
     async resolveUpdateContext(args) {
         let resolvedIssueId = args.id;
         let issueTeamId;
@@ -727,36 +878,49 @@ export class GraphQLIssuesService {
                 resolveVariables.__labelNames = nonUuidLabels;
             }
         }
-        if (args.projectId && !isUuid(args.projectId)) {
-            resolveVariables.projectName = args.projectId;
+        if (args.projectId) {
+            // A UUID resolves by `id` so the project's milestones are still
+            // fetched for `--project-milestone` name resolution; a name
+            // resolves by `name`. The `has*` flags gate the `@include`d
+            // blocks so an unset input never triggers a null no-op filter.
+            if (isUuid(args.projectId)) {
+                resolveVariables.projectId = args.projectId;
+                resolveVariables.hasProjectId = true;
+            }
+            else {
+                resolveVariables.projectName = args.projectId;
+                resolveVariables.hasProjectName = true;
+            }
         }
         if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
+            resolveVariables.hasMilestoneName = true;
         }
         const { __labelNames, ...updateQueryVars } = resolveVariables;
-        const requests = [
-            this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_UPDATE_QUERY, updateQueryVars),
-        ];
+        const batchPromise = this.graphQLService.rawRequest(BATCH_RESOLVE_FOR_UPDATE_QUERY, updateQueryVars);
+        let resolveResult;
         if (__labelNames) {
             const labelQuery = buildResolveLabelsByNameQuery(__labelNames);
-            requests.push(this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables));
+            const [batch, labels] = await Promise.all([
+                batchPromise,
+                this.graphQLService.rawRequest(labelQuery.query, labelQuery.variables),
+            ]);
+            resolveResult = {
+                ...this.foldUpdateBatchResult(batch),
+                labels: labels.labels,
+            };
         }
-        const results = await Promise.all(requests);
-        const resolveResult = results[0];
-        if (results[1]) {
-            resolveResult.labels = results[1].labels;
+        else {
+            resolveResult = this.foldUpdateBatchResult(await batchPromise);
         }
         if (!isUuid(args.id)) {
-            const resolvedIssues = resolveResult.issues;
-            const resolvedIssueNodes = resolvedIssues.nodes;
+            const resolvedIssueNodes = resolveResult.issues?.nodes ?? [];
             if (!resolvedIssueNodes.length) {
                 throw notFoundError("Issue", args.id);
             }
             resolvedIssueId = resolvedIssueNodes[0].id;
-            const team = resolvedIssueNodes[0].team;
-            issueTeamId = team?.id;
-            const issueLabels = resolvedIssueNodes[0].labels;
-            currentIssueLabels = issueLabels.nodes.map((l) => l.id);
+            issueTeamId = resolvedIssueNodes[0].team?.id;
+            currentIssueLabels = resolvedIssueNodes[0].labels.nodes.map((l) => l.id);
         }
         return { resolvedIssueId, issueTeamId, currentIssueLabels, resolveResult };
     }
@@ -783,16 +947,44 @@ export class GraphQLIssuesService {
         }
         return this.linearService.resolveStatusId(args.statusId, teamId);
     }
+    /**
+     * Pre-resolve URL/slug-id project inputs to UUIDs before the batch
+     * resolver runs. Plain names and UUIDs pass through unchanged; only
+     * URL/slug-id forms incur a separate slug→UUID round-trip (the batch
+     * query's `name eqIgnoreCase` filter can't match a URL string).
+     */
+    async withNormalizedProjectId(args) {
+        if (!args.projectId) {
+            return args;
+        }
+        const normalized = await this.linearService.normalizeProjectInput(args.projectId);
+        if (normalized === args.projectId) {
+            return args;
+        }
+        return { ...args, projectId: normalized };
+    }
     buildCreateResolveVariables(args) {
         const resolveVariables = {};
         if (args.teamId && !isUuid(args.teamId)) {
             Object.assign(resolveVariables, this.buildResolveVariablesForTeam(args.teamId));
         }
-        if (args.projectId && !isUuid(args.projectId)) {
-            resolveVariables.projectName = args.projectId;
+        if (args.projectId) {
+            // A UUID is resolved by `id` so the project's team associations
+            // are still fetched for team-project validation; a name is
+            // resolved by `name`. The `has*` flags gate the `@include`d
+            // blocks so an unset input never triggers a null no-op filter.
+            if (isUuid(args.projectId)) {
+                resolveVariables.projectId = args.projectId;
+                resolveVariables.hasProjectId = true;
+            }
+            else {
+                resolveVariables.projectName = args.projectId;
+                resolveVariables.hasProjectName = true;
+            }
         }
         if (args.milestoneId && !isUuid(args.milestoneId)) {
             resolveVariables.milestoneName = args.milestoneId;
+            resolveVariables.hasMilestoneName = true;
         }
         if (args.labelIds && args.labelIds.length > 0) {
             const nonUuidLabels = args.labelIds.filter((id) => !isUuid(id));
@@ -813,30 +1005,32 @@ export class GraphQLIssuesService {
         if (!parentId || isUuid(parentId)) {
             return parentId;
         }
-        const parentIssues = resolveResult.parentIssues;
-        const parentNodes = parentIssues?.nodes;
+        const parentNodes = resolveResult.parentIssues?.nodes;
         if (!parentNodes?.length) {
             throw notFoundError("Parent issue", parentId);
         }
         return parentNodes[0].id;
     }
     transformIssueData(issue) {
-        const labels = issue.labels;
+        // `labels`/`children`/`comments` are connection fields that the
+        // fragment always selects, so production responses populate them.
+        // Test mocks pass partial objects, so read defensively to keep
+        // those test fixtures small.
         return {
             ...this.transformIssueCoreFields(issue),
             ...this.transformIssueRelations(issue),
-            summary: issue.summary
-                ? extractSummaryText(issue.summary)
-                : undefined,
+            summary: issue.summary ? extractSummaryText(issue.summary) : undefined,
             priority: issue.priority,
-            estimate: issue.estimate || undefined,
-            dueDate: issue.dueDate || undefined,
-            labels: labels.nodes.map((label) => ({
+            estimate: issue.estimate ?? undefined,
+            dueDate: issue.dueDate ?? undefined,
+            labels: (issue.labels?.nodes ?? []).map((label) => ({
                 id: label.id,
                 name: label.name,
             })),
             ...this.transformIssueHierarchy(issue),
-            comments: this.transformIssueComments(issue),
+            comments: "comments" in issue && issue.comments
+                ? this.transformIssueComments(issue)
+                : [],
             createdAt: toISOStringOrNow(issue.createdAt),
             updatedAt: toISOStringOrNow(issue.updatedAt),
         };
@@ -847,93 +1041,91 @@ export class GraphQLIssuesService {
             identifier: issue.identifier,
             url: issue.url,
             title: issue.title,
-            description: issue.description || undefined,
+            description: issue.description ?? undefined,
             branchName: issue.branchName || undefined,
-            embeds: issue.description
-                ? extractEmbeds(issue.description)
-                : undefined,
+            embeds: issue.description ? extractEmbeds(issue.description) : undefined,
         };
     }
     transformIssueRelations(issue) {
-        const state = issue.state;
-        const assignee = issue.assignee;
-        const team = issue.team;
-        const project = issue.project;
-        const cycle = issue.cycle;
-        const milestone = issue.projectMilestone;
         return {
-            state: state
-                ? { id: state.id, name: state.name }
+            state: issue.state
+                ? { id: issue.state.id, name: issue.state.name }
                 : undefined,
-            assignee: assignee
+            assignee: issue.assignee
                 ? {
-                    id: assignee.id,
-                    name: resolveUserDisplayName(assignee.id, assignee.name),
-                    url: assignee.url || undefined,
+                    id: issue.assignee.id,
+                    name: resolveUserDisplayName(issue.assignee.id, issue.assignee.name),
+                    url: issue.assignee.url ?? undefined,
                 }
                 : undefined,
-            team: team
+            delegate: issue.delegate
                 ? {
-                    id: team.id,
-                    key: team.key,
-                    name: team.name,
+                    id: issue.delegate.id,
+                    name: resolveUserDisplayName(issue.delegate.id, issue.delegate.name),
+                    url: issue.delegate.url ?? undefined,
                 }
                 : undefined,
-            project: project
-                ? { id: project.id, name: project.name }
+            team: issue.team
+                ? {
+                    id: issue.team.id,
+                    key: issue.team.key,
+                    name: issue.team.name,
+                }
+                : undefined,
+            project: issue.project
+                ? { id: issue.project.id, name: issue.project.name }
                 : undefined,
-            cycle: cycle
+            cycle: issue.cycle
                 ? {
-                    id: cycle.id,
-                    name: cycle.name,
-                    number: cycle.number,
+                    id: issue.cycle.id,
+                    name: issue.cycle.name ?? "",
+                    number: issue.cycle.number,
                 }
                 : undefined,
-            projectMilestone: milestone
+            projectMilestone: issue.projectMilestone
                 ? {
-                    id: milestone.id,
-                    name: milestone.name,
-                    targetDate: milestone.targetDate || undefined,
+                    id: issue.projectMilestone.id,
+                    name: issue.projectMilestone.name,
+                    targetDate: issue.projectMilestone.targetDate ?? undefined,
                 }
                 : undefined,
         };
     }
     transformIssueHierarchy(issue) {
-        const parent = issue.parent;
-        const children = issue.children;
+        // children is a connection field — always present in production
+        // responses. Defensive read keeps test mocks small.
+        const childNodes = issue.children?.nodes ?? [];
         return {
-            parentIssue: parent
+            parentIssue: issue.parent
                 ? {
-                    id: parent.id,
-                    identifier: parent.identifier,
-                    title: parent.title,
+                    id: issue.parent.id,
+                    identifier: issue.parent.identifier,
+                    title: issue.parent.title,
                 }
                 : undefined,
-            subIssues: children?.nodes?.map((child) => ({
-                id: child.id,
-                identifier: child.identifier,
-                title: child.title,
-            })) || undefined,
+            subIssues: childNodes.length > 0
+                ? childNodes.map((child) => ({
+                    id: child.id,
+                    identifier: child.identifier,
+                    title: child.title,
+                }))
+                : undefined,
         };
     }
     transformIssueComments(issue) {
-        const comments = issue.comments;
-        return (comments?.nodes?.map((comment) => {
-            const commentUser = comment.user;
-            return {
-                id: comment.id,
-                body: comment.body,
-                embeds: extractEmbeds(comment.body),
-                user: commentUser
-                    ? {
-                        id: commentUser.id,
-                        name: resolveUserDisplayName(commentUser.id, commentUser.name),
-                        url: commentUser.url || undefined,
-                    }
-                    : undefined,
-                createdAt: toISOStringOrNow(comment.createdAt),
-                updatedAt: toISOStringOrNow(comment.updatedAt),
-            };
-        }) || []);
+        return issue.comments.nodes.map((comment) => ({
+            id: comment.id,
+            body: comment.body,
+            embeds: extractEmbeds(comment.body),
+            user: comment.user
+                ? {
+                    id: comment.user.id,
+                    name: resolveUserDisplayName(comment.user.id, comment.user.name),
+                    url: comment.user.url ?? undefined,
+                }
+                : undefined,
+            createdAt: toISOStringOrNow(comment.createdAt),
+            updatedAt: toISOStringOrNow(comment.updatedAt),
+        }));
     }
 }