linmux 0.1.0

package/dist/lib/issue-archive-runtime.js

@@ -0,0 +1,89 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { ISSUE_IDENTIFIER_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/issue-archive-runtime.ts
+async function issueArchiveRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const { id, identifier } = await resolveIssueRef(client, ref, input.retryOptsOverride);
+		const payload = await withRateLimitRetry(() => client.archiveIssue(id), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "archiveIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		const data = {
+			id,
+			archived: true
+		};
+		if (identifier !== void 0) data.identifier = identifier;
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+/**
+* Resolve a user-typed issue ref (ENG-123 or UUID) to a UUID + identifier.
+* UUID path is a no-op (no SDK round-trip); identifier path uses the
+* team-key + number filter. Inlined per the plan note: each runtime in this
+* plan keeps its own resolution helper for cross-plan independence.
+*/
+async function resolveIssueRef(client, ref, retryOpts) {
+	if (UUID_RE.test(ref)) return { id: ref };
+	const m = ref.match(ISSUE_IDENTIFIER_RE);
+	if (!m) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `invalid issue ref: ${ref}`,
+		details: { ref }
+	});
+	const teamKey = m[1].toUpperCase();
+	const number = Number(m[2]);
+	const issue = (await withRateLimitRetry(() => client.issues({
+		filter: {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		},
+		first: 1
+	}), retryOpts)).nodes[0];
+	if (!issue) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRaw = issue.id;
+	if (typeof idRaw !== "string") throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRes = { id: idRaw };
+	const idn = issue.identifier;
+	if (typeof idn === "string") idRes.identifier = idn;
+	return idRes;
+}
+//#endregion
+export { issueArchiveRuntime };

package/dist/lib/issue-create-runtime.js

@@ -0,0 +1,175 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { EMAIL_RE, ISSUE_IDENTIFIER_RE, UUID_RE } from "./filter-heuristics.js";
+import { resolveCycleId } from "../core/resolvers/cycle.js";
+import { resolveLabelIds } from "../core/resolvers/label.js";
+import { resolveProjectId } from "../core/resolvers/project.js";
+import { resolveStateNameToId } from "../core/resolvers/state.js";
+import { resolveTeamId } from "../core/resolvers/team.js";
+import "../core/resolvers/index.js";
+//#region src/lib/issue-create-runtime.ts
+async function issueCreateRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	if (input.flags.title === void 0 || input.flags.title === "") throw LinearAgentError.usage("--title is required");
+	if (input.flags.team === void 0 || input.flags.team === "") throw LinearAgentError.usage("--team is required");
+	const title = input.flags.title;
+	const teamRef = input.flags.team;
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const teamId = await resolveTeamId(client, workspaceKey, teamRef, input.retryOptsOverride);
+		const flags = input.flags;
+		const [stateId, labelIds, projectId, cycleId, parentId, assigneeId] = await Promise.all([
+			flags.state !== void 0 ? resolveStateNameToId(client, workspaceKey, teamId, flags.state, input.retryOptsOverride) : Promise.resolve(void 0),
+			flags.labels !== void 0 && flags.labels !== "" ? resolveLabelIds(client, workspaceKey, teamId, flags.labels.split(",").map((s) => s.trim()).filter(Boolean), input.retryOptsOverride) : Promise.resolve(void 0),
+			flags.project !== void 0 ? resolveProjectId(client, workspaceKey, flags.project, input.retryOptsOverride) : Promise.resolve(void 0),
+			flags.cycle !== void 0 ? resolveCycleId(client, workspaceKey, teamId, flags.cycle, input.retryOptsOverride) : Promise.resolve(void 0),
+			flags.parent !== void 0 ? resolveIssueRefToUuid(client, flags.parent, input.retryOptsOverride) : Promise.resolve(void 0),
+			flags.assignee !== void 0 ? resolveAssignee(client, flags.assignee, input.retryOptsOverride) : Promise.resolve(void 0)
+		]);
+		const createInput = {
+			teamId,
+			title
+		};
+		if (flags.description !== void 0) createInput.description = flags.description;
+		if (stateId !== void 0) createInput.stateId = stateId;
+		if (assigneeId !== void 0) createInput.assigneeId = assigneeId;
+		if (labelIds !== void 0) createInput.labelIds = labelIds;
+		if (projectId !== void 0) createInput.projectId = projectId;
+		if (cycleId !== void 0) createInput.cycleId = cycleId;
+		if (flags.priority !== void 0) createInput.priority = flags.priority;
+		if (parentId !== void 0) createInput.parentId = parentId;
+		const payload = await withRateLimitRetry(() => client.createIssue(createInput), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "createIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let created;
+		if (payload.issue !== void 0) {
+			const i = await Promise.resolve(payload.issue);
+			if (i !== void 0 && i !== null) created = i;
+		}
+		let data;
+		if (created) data = project(await hydrateForProjection(created, fields), fields);
+		else data = {};
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+/**
+* Resolve a parent issue reference (`ENG-42` or UUID) to an issue UUID.
+* Mirrors the `resolveIssue` helper in `issue-get-runtime.ts` but limited to
+* the parent-id use case (no full issue hydration needed).
+*/
+async function resolveIssueRefToUuid(client, ref, retryOpts) {
+	if (UUID_RE.test(ref)) return ref;
+	const m = ISSUE_IDENTIFIER_RE.exec(ref);
+	if (!m) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `parent issue not found: ${ref}`,
+		details: { ref }
+	});
+	const teamKey = m[1].toUpperCase();
+	const number = Number(m[2]);
+	const filter = {
+		team: { key: { eq: teamKey } },
+		number: { eq: number }
+	};
+	const node = (await withRateLimitRetry(() => client.issues({
+		filter,
+		first: 1
+	}), retryOpts)).nodes[0];
+	if (!node) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `parent issue not found: ${ref}`,
+		details: { ref }
+	});
+	return node.id;
+}
+/**
+* Resolve a free-form assignee reference to a user UUID:
+*   - `me`           → `client.viewer.id`
+*   - UUID           → passthrough
+*   - email-shaped   → `client.users({ filter: { email: { eq } }, first: 1 })`
+*   - other          → `client.users({ filter: { name: { eq } }, first: 1 })`
+*/
+async function resolveAssignee(client, ref, retryOpts) {
+	if (ref === "me") return (await withRateLimitRetry(() => Promise.resolve(client.viewer), retryOpts)).id;
+	if (UUID_RE.test(ref)) return ref;
+	const filter = EMAIL_RE.test(ref) ? { email: { eq: ref } } : { name: { eq: ref } };
+	const node = (await withRateLimitRetry(() => client.users({
+		filter,
+		first: 1
+	}), retryOpts)).nodes[0];
+	if (!node) throw LinearAgentError.linear.apiError({
+		message: `assignee not found: ${ref}`,
+		details: { ref }
+	});
+	return node.id;
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(issue)) if (!RELATION_KEYS.has(k)) out[k] = issue[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(issue)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = issue[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = issue[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+//#endregion
+export { issueCreateRuntime, resolveAssignee };

package/dist/lib/issue-get-runtime.js

@@ -0,0 +1,153 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { redact } from "../core/redact/redact.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { ISSUE_IDENTIFIER_RE } from "./filter-heuristics.js";
+import { validateAndMergeIncludes } from "./include-fragments.js";
+//#region src/lib/issue-get-runtime.ts
+async function issueGetRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	const includes = input.flags.include ?? [];
+	if (includes.length === 0) return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const issue = await resolveIssue(client, ref, input.retryOptsOverride);
+		if (!issue) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const data = project(await hydrateForProjection(issue, fields), fields);
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+	const query = composeIssueGetWithIncludes(validateAndMergeIncludes("issue get", includes));
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const response = await withRateLimitRetry(() => client.client.rawRequest(query, { id: ref }), input.retryOptsOverride);
+		if (response.error ?? !response.data) {
+			const safeMessage = redact(response.error ?? "no data returned from Linear API");
+			const safeCause = response.error !== void 0 ? redact(response.error) : void 0;
+			throw LinearAgentError.linear.apiError({
+				message: safeMessage,
+				details: {
+					command: "issue get",
+					cause: safeCause
+				}
+			});
+		}
+		const issueData = response.data.issue;
+		if (!issueData) throw new LinearAgentError({
+			code: "ISSUE_NOT_FOUND",
+			message: `issue not found: ${ref}`,
+			details: { ref }
+		});
+		const data = project(issueData, fields);
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+async function resolveIssue(client, ref, retryOpts) {
+	const m = ISSUE_IDENTIFIER_RE.exec(ref);
+	if (m) {
+		const teamKey = m[1].toUpperCase();
+		const number = Number(m[2]);
+		const filter = {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		};
+		return (await withRateLimitRetry(() => client.issues({
+			filter,
+			first: 1
+		}), retryOpts)).nodes[0];
+	}
+	return await withRateLimitRetry(() => client.issue(ref), retryOpts) ?? void 0;
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(issue)) if (!RELATION_KEYS.has(k)) out[k] = issue[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(issue)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = issue[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = issue[k];
+	return hydrated;
+}
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+function composeIssueGetWithIncludes(fragmentText) {
+	return `
+    query IssueWithIncludes($id: String!) {
+      issue(id: $id) {
+        id identifier title description priority priorityLabel
+        estimate sortOrder number url
+        createdAt updatedAt archivedAt completedAt startedAt canceledAt
+        dueDate snoozedUntilAt
+        state { id name type }
+        assignee { id email name }
+        team { id key name }
+        project { id name }
+        cycle { id number }
+        parent { id identifier }
+        ${fragmentText}
+      }
+    }
+  `.trim();
+}
+//#endregion
+export { issueGetRuntime };

package/dist/lib/issue-list-runtime.js

@@ -0,0 +1,164 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { redact } from "../core/redact/redact.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { parseFields, project } from "../core/projection/project.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { parsePagination } from "../core/pagination/flags.js";
+import "../core/pagination/index.js";
+import { buildIssueFilter } from "./filter-heuristics.js";
+import { validateAndMergeIncludes } from "./include-fragments.js";
+//#region src/lib/issue-list-runtime.ts
+async function issueListRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	const fields = parseFields(input.flags.fields ?? "defaults", "issue");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	const filter = buildIssueFilter(input.flags);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	const includes = input.flags.include ?? [];
+	if (includes.length === 0) return withFetchInterception(async () => {
+		const issuesArgs = { first };
+		if (after !== void 0) issuesArgs.after = after;
+		if (filter !== void 0) issuesArgs.filter = filter;
+		const connection = await withRateLimitRetry(() => client.issues(issuesArgs), input.retryOptsOverride);
+		const projected = await Promise.all(connection.nodes.map(async (issue) => {
+			return project(await hydrateForProjection(issue, fields), fields);
+		}));
+		const complexity = getLastComplexity();
+		return {
+			data: projected,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				pageInfo: {
+					hasNextPage: Boolean(connection.pageInfo?.hasNextPage),
+					endCursor: connection.pageInfo?.endCursor ?? null,
+					hasPreviousPage: Boolean(connection.pageInfo?.hasPreviousPage),
+					startCursor: connection.pageInfo?.startCursor ?? null
+				},
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+	const query = composeIssueListWithIncludes(validateAndMergeIncludes("issue list", includes));
+	return withFetchInterception(async () => {
+		const vars = { first };
+		if (after !== void 0) vars.after = after;
+		if (filter !== void 0) vars.filter = filter;
+		const response = await withRateLimitRetry(() => client.client.rawRequest(query, vars), input.retryOptsOverride);
+		if (response.error ?? !response.data) {
+			const safeMessage = redact(response.error ?? "no data returned from Linear API");
+			const safeCause = response.error !== void 0 ? redact(response.error) : void 0;
+			throw LinearAgentError.linear.apiError({
+				message: safeMessage,
+				details: {
+					command: "issue list",
+					cause: safeCause
+				}
+			});
+		}
+		const root = response.data.issues;
+		if (!root) throw LinearAgentError.linear.apiError({
+			message: "unexpected response shape: missing issues field",
+			details: { command: "issue list" }
+		});
+		const projected = root.nodes.map((issue) => project(issue, fields));
+		const complexity = getLastComplexity();
+		return {
+			data: projected,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				pageInfo: {
+					hasNextPage: Boolean(root.pageInfo?.hasNextPage),
+					endCursor: root.pageInfo?.endCursor ?? null,
+					hasPreviousPage: Boolean(root.pageInfo?.hasPreviousPage),
+					startCursor: root.pageInfo?.startCursor ?? null
+				},
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+/**
+* The typed SDK exposes `issue.state`, `issue.assignee`, `issue.team` as
+* lazy promise getters. To project paths like `state.name`, we must `await`
+* each. We hydrate ONLY the related entities the projection spec actually
+* references — narrows N+1 surface for the common `--fields=ids` case.
+*
+* Phase 2 will replace this with a single GraphQL fragment query that pulls
+* the related entities in one round-trip; documented in PITFALLS as the
+* known scaling cliff this Phase 1 implementation deliberately accepts.
+*/
+async function hydrateForProjection(issue, spec) {
+	const needs = neededRelations(spec);
+	const hydrated = { ...issue };
+	if (needs.has("state") && hydrated.state !== void 0) hydrated.state = await resolveLazy(hydrated.state);
+	if (needs.has("assignee") && hydrated.assignee !== void 0) hydrated.assignee = await resolveLazy(hydrated.assignee);
+	if (needs.has("team") && hydrated.team !== void 0) hydrated.team = await resolveLazy(hydrated.team);
+	if (needs.has("project") && hydrated.project !== void 0) hydrated.project = await resolveLazy(hydrated.project);
+	if (needs.has("cycle") && hydrated.cycle !== void 0) hydrated.cycle = await resolveLazy(hydrated.cycle);
+	if (needs.has("parent") && hydrated.parent !== void 0) hydrated.parent = await resolveLazy(hydrated.parent);
+	return hydrated;
+}
+const RELATION_KEYS = new Set([
+	"state",
+	"assignee",
+	"team",
+	"project",
+	"cycle",
+	"parent"
+]);
+function neededRelations(spec) {
+	if (spec === "*") return new Set(RELATION_KEYS);
+	const out = /* @__PURE__ */ new Set();
+	for (const path of spec) {
+		const head = path.split(".")[0];
+		if (head && RELATION_KEYS.has(head)) out.add(head);
+	}
+	return out;
+}
+async function resolveLazy(value) {
+	if (value && typeof value.then === "function") return await value;
+	return value;
+}
+function composeIssueListWithIncludes(fragmentText) {
+	return `
+    query IssuesWithIncludes($filter: IssueFilter, $first: Int, $after: String) {
+      issues(filter: $filter, first: $first, after: $after) {
+        nodes {
+          id identifier title description priority priorityLabel
+          estimate sortOrder number url
+          createdAt updatedAt archivedAt completedAt startedAt canceledAt
+          dueDate snoozedUntilAt
+          state { id name type }
+          assignee { id email name }
+          team { id key name }
+          project { id name }
+          cycle { id number }
+          parent { id identifier }
+          ${fragmentText}
+        }
+        pageInfo { hasNextPage endCursor hasPreviousPage startCursor }
+      }
+    }
+  `.trim();
+}
+//#endregion
+export { issueListRuntime };

package/dist/lib/issue-purge-runtime.js

@@ -0,0 +1,89 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { getLastComplexity, withFetchInterception } from "../core/transport/fetch-interceptor.js";
+import { withRateLimitRetry } from "../core/transport/rate-limit.js";
+import "../core/transport/index.js";
+import { createLinearClient } from "../core/client/factory.js";
+import "../core/client/index.js";
+import { loadConfig } from "../core/config/store.js";
+import "../core/config/index.js";
+import { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { ISSUE_IDENTIFIER_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/issue-purge-runtime.ts
+async function issuePurgeRuntime(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (input.env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = input.env.LINEAR_WORKSPACE;
+	if (input.env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = input.env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	requireExplicitWorkspaceForWrite(resolved, input.flags.allowActiveWorkspaceWrite ?? false);
+	if (!input.flags.yes) throw new LinearAgentError({
+		code: "CONFIRMATION_REQUIRED",
+		message: "purge is permanent -- re-run with --yes to confirm",
+		details: { remediation: "pass --yes to confirm permanent deletion" }
+	});
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const ref = input.args.identifier;
+		const { id, identifier } = await resolveIssueRef(client, ref, input.retryOptsOverride);
+		const payload = await withRateLimitRetry(() => client.deleteIssue(id, { permanentlyDelete: true }), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "deleteIssue returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		const data = {
+			id,
+			permanentlyDeleted: true
+		};
+		if (identifier !== void 0) data.identifier = identifier;
+		const complexity = getLastComplexity();
+		return {
+			data,
+			meta: {
+				workspace: resolved.name,
+				workspaceSource: resolved.source,
+				...complexity !== void 0 ? { complexity } : {}
+			}
+		};
+	});
+}
+async function resolveIssueRef(client, ref, retryOpts) {
+	if (UUID_RE.test(ref)) return { id: ref };
+	const m = ref.match(ISSUE_IDENTIFIER_RE);
+	if (!m) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `invalid issue ref: ${ref}`,
+		details: { ref }
+	});
+	const teamKey = m[1].toUpperCase();
+	const number = Number(m[2]);
+	const issue = (await withRateLimitRetry(() => client.issues({
+		filter: {
+			team: { key: { eq: teamKey } },
+			number: { eq: number }
+		},
+		first: 1,
+		includeArchived: true
+	}), retryOpts)).nodes[0];
+	if (!issue) throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRaw = issue.id;
+	if (typeof idRaw !== "string") throw new LinearAgentError({
+		code: "ISSUE_NOT_FOUND",
+		message: `issue not found: ${ref}`,
+		details: { ref }
+	});
+	const idRes = { id: idRaw };
+	const idn = issue.identifier;
+	if (typeof idn === "string") idRes.identifier = idn;
+	return idRes;
+}
+//#endregion
+export { issuePurgeRuntime };