linmux 0.1.0

package/dist/commands/issue/list.js

@@ -0,0 +1,93 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { issueListRuntime } from "../../lib/issue-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/issue/list.ts
+/**
+* `linmux issue list` — first vertical-slice read command.
+*
+* Implementation lives in `src/lib/issue-list-runtime.ts` (per the same
+* pattern PLAN-04 established for workspace commands). This file exports
+* BOTH the oclif Command class AND a named `runIssueList(args)` function so
+* tests can call the runtime without spawning a subprocess (PATTERNS § "Each
+* `src/commands/<topic>/<verb>.ts` exports BOTH the oclif Command class AND a
+* named `run<Cmd>(args)` async function").
+*
+* Per CONTEXT § `issue list` (First Vertical Slice):
+*   - Filters in Phase 1: --state, --assignee, --team
+*   - Pagination: --limit (default 25, max 100), --cursor (opaque)
+*   - Projection: --fields (preset|csv)
+*   - Workspace selection: --workspace flag honored, otherwise resolver chain
+*/
+async function runIssueList(args) {
+	const runArgs = {
+		commandPath: "issue list",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = { fields: args.fields ?? "defaults" };
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.limit !== void 0) runtimeFlags.limit = args.limit;
+			if (args.cursor !== void 0) runtimeFlags.cursor = args.cursor;
+			if (args.state !== void 0) runtimeFlags.state = args.state;
+			if (args.assignee !== void 0) runtimeFlags.assignee = args.assignee;
+			if (args.team !== void 0) runtimeFlags.team = args.team;
+			if (args.include !== void 0) runtimeFlags.include = args.include;
+			const result = await issueListRuntime({
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssueList = class IssueList extends Command {
+	static description = "List Linear issues, with --fields, --limit, --cursor, and Phase 1 filters.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		...PAGINATION_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		state: Flags.string({ description: "Filter by workflow state name or ID" }),
+		assignee: Flags.string({ description: "Filter by assignee email, ID, or \"me\"" }),
+		team: Flags.string({ description: "Filter by team key, ID, or name" }),
+		include: Flags.string({
+			description: "Hydrate related entities in a single GraphQL round-trip (e.g. comments, labels). Available: comments, labels, attachments, subscribers, history.",
+			multiple: true
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(IssueList);
+		const callArgs = { pretty: flags.pretty };
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.limit !== void 0) callArgs.limit = flags.limit;
+		if (flags.cursor !== void 0) callArgs.cursor = flags.cursor;
+		if (flags.state !== void 0) callArgs.state = flags.state;
+		if (flags.assignee !== void 0) callArgs.assignee = flags.assignee;
+		if (flags.team !== void 0) callArgs.team = flags.team;
+		if (flags.include !== void 0) callArgs.include = flags.include;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssueList(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssueList as default, runIssueList };

package/dist/commands/issue/purge.js

@@ -0,0 +1,81 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issuePurgeRuntime } from "../../lib/issue-purge-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/purge.ts
+/**
+* `linmux issue purge <identifier> --yes` -- Phase 2 PLAN 02-05
+* Task 1, ISS-06.purge.
+*
+* PERMANENT delete (calls `client.deleteIssue(uuid, { permanentlyDelete:
+* true })`). REQUIRES `--yes`; without it the runtime throws
+* CONFIRMATION_REQUIRED (exit 2) BEFORE any SDK call (T-02-22 mitigation).
+*
+* WSP-06 enforced in the runtime BEFORE the confirmation gate, so a missing
+* --workspace surfaces as WORKSPACE_REQUIRED_FOR_WRITE rather than
+* CONFIRMATION_REQUIRED -- the workspace gate is the more dangerous mistake.
+*
+* Implementation lives in `src/lib/issue-purge-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runIssuePurge(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssuePurge(args) {
+	const runArgs = {
+		commandPath: "issue purge",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.yes !== void 0) runtimeFlags.yes = args.yes;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags.allowActiveWorkspaceWrite = args.allowActiveWorkspaceWrite;
+			const result = await issuePurgeRuntime({
+				args: { identifier: args.identifier },
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssuePurge = class IssuePurge extends Command {
+	static description = "PERMANENTLY delete a Linear issue. Irreversible. Requires --yes to confirm.";
+	static enableJsonFlag = true;
+	static args = { identifier: Args.string({
+		required: true,
+		description: "Issue identifier (ENG-123) or UUID"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		"allow-active-workspace-write": Flags.boolean({ description: "Per-invocation opt-in to use the active default workspace for this write (WSP-06)" }),
+		yes: Flags.boolean({ description: "Confirm permanent deletion (REQUIRED for purge)" })
+	};
+	async run() {
+		const { args, flags } = await this.parse(IssuePurge);
+		const callArgs = {
+			identifier: args.identifier,
+			pretty: flags.pretty,
+			allowActiveWorkspaceWrite: flags["allow-active-workspace-write"],
+			yes: flags.yes
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssuePurge(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssuePurge as default, runIssuePurge };

package/dist/commands/issue/search.js

@@ -0,0 +1,109 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { issueSearchRuntime } from "../../lib/issue-search-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/search.ts
+/**
+* `linmux issue search <query>` -- Phase 2 PLAN 02-05 Task 2, ISS-07.
+*
+* Full-text search via `client.searchIssues(term, vars)`. Read command, no
+* WSP-06. Filter parity with `issue list` (state / assignee / team / label
+* / project / cycle), Linear's snippet metadata projected as a top-level
+* `snippet` field (default on; --no-snippet to drop), --include-archived
+* passthrough.
+*
+* Implementation lives in `src/lib/issue-search-runtime.ts` per the Phase
+* 1 PLAN-04 invariant. This file exports BOTH the oclif Command class AND
+* a named `runIssueSearch(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssueSearch(args) {
+	const runArgs = {
+		commandPath: "issue search",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.limit !== void 0) runtimeFlags.limit = args.limit;
+			if (args.cursor !== void 0) runtimeFlags.cursor = args.cursor;
+			if (args.state !== void 0) runtimeFlags.state = args.state;
+			if (args.assignee !== void 0) runtimeFlags.assignee = args.assignee;
+			if (args.team !== void 0) runtimeFlags.team = args.team;
+			if (args.label !== void 0) runtimeFlags.label = args.label;
+			if (args.project !== void 0) runtimeFlags.project = args.project;
+			if (args.cycle !== void 0) runtimeFlags.cycle = args.cycle;
+			if (args.noSnippet !== void 0) runtimeFlags.noSnippet = args.noSnippet;
+			if (args.includeArchived !== void 0) runtimeFlags.includeArchived = args.includeArchived;
+			const result = await issueSearchRuntime({
+				args: { query: args.query },
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssueSearch = class IssueSearch extends Command {
+	static description = "Full-text search Linear issues. Surfaces match snippets in metadata; supports the same filter flags as `issue list`.";
+	static enableJsonFlag = true;
+	static args = { query: Args.string({
+		required: true,
+		description: "Full-text search query"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		...PAGINATION_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		state: Flags.string({ description: "Filter by workflow state name or ID" }),
+		assignee: Flags.string({ description: "Filter by assignee email, ID, or \"me\"" }),
+		team: Flags.string({ description: "Filter by team key, ID, or name" }),
+		label: Flags.string({ description: "Filter by label name or UUID" }),
+		project: Flags.string({ description: "Filter by project name or UUID" }),
+		cycle: Flags.string({ description: "Filter by cycle UUID" }),
+		"no-snippet": Flags.boolean({ description: "Drop the snippet field from each result (token tightening)" }),
+		"include-archived": Flags.boolean({ description: "Include archived issues in search results (default false)" })
+	};
+	async run() {
+		const { args, flags } = await this.parse(IssueSearch);
+		const callArgs = {
+			query: args.query,
+			pretty: flags.pretty,
+			noSnippet: flags["no-snippet"],
+			includeArchived: flags["include-archived"]
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.limit !== void 0) callArgs.limit = flags.limit;
+		if (flags.cursor !== void 0) callArgs.cursor = flags.cursor;
+		if (flags.state !== void 0) callArgs.state = flags.state;
+		if (flags.assignee !== void 0) callArgs.assignee = flags.assignee;
+		if (flags.team !== void 0) callArgs.team = flags.team;
+		if (flags.label !== void 0) callArgs.label = flags.label;
+		if (flags.project !== void 0) callArgs.project = flags.project;
+		if (flags.cycle !== void 0) callArgs.cycle = flags.cycle;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssueSearch(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssueSearch as default, runIssueSearch };

package/dist/commands/issue/transition.js

@@ -0,0 +1,91 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueTransitionRuntime } from "../../lib/issue-transition-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/transition.ts
+/**
+* `linmux issue transition <identifier> <state>` — Phase 2 PLAN 02-03
+* Task 2, ISS-05.
+*
+* Write command. Resolves the issue (identifier or UUID), reads its team,
+* resolves the state name (or UUID passthrough), and mutates via
+* `client.updateIssue(id, { stateId })`. WSP-06 enforcement runs in the
+* runtime BEFORE any SDK call.
+*
+* Implementation lives in `src/lib/issue-transition-runtime.ts` per the
+* Phase 1 PLAN-04 invariant. This file exports BOTH the oclif Command class
+* AND a named `runIssueTransition(args)` function so tests can call the
+* runtime without spawning a subprocess.
+*/
+async function runIssueTransition(args) {
+	const runArgs = {
+		commandPath: "issue transition",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags.allowActiveWorkspaceWrite = args.allowActiveWorkspaceWrite;
+			const result = await issueTransitionRuntime({
+				args: {
+					identifier: args.identifier,
+					state: args.state
+				},
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssueTransition = class IssueTransition extends Command {
+	static description = "Transition a Linear issue to a different workflow state by name or UUID.";
+	static enableJsonFlag = true;
+	static args = {
+		identifier: Args.string({
+			required: true,
+			description: "Issue identifier (ENG-123) or UUID"
+		}),
+		state: Args.string({
+			required: true,
+			description: "Workflow state name (e.g. \"In Progress\") or UUID"
+		})
+	};
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		"allow-active-workspace-write": Flags.boolean({ description: "Per-invocation opt-in to use the active default workspace for this write (WSP-06)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(IssueTransition);
+		const callArgs = {
+			identifier: args.identifier,
+			state: args.state,
+			pretty: flags.pretty,
+			allowActiveWorkspaceWrite: flags["allow-active-workspace-write"]
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssueTransition(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssueTransition as default, runIssueTransition };

package/dist/commands/issue/trash.js

@@ -0,0 +1,75 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueTrashRuntime } from "../../lib/issue-trash-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/trash.ts
+/**
+* `linmux issue trash <identifier>` -- Phase 2 PLAN 02-05 Task 1,
+* ISS-06.trash.
+*
+* Soft 30-day delete (calls `client.deleteIssue(uuid)`, default
+* permanentlyDelete=false). WSP-06 enforced in the runtime BEFORE the SDK
+* call. NO `--yes` flag (CONTEXT line 49 -- trash is reversible within 30
+* days via the Linear UI).
+*
+* Implementation lives in `src/lib/issue-trash-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runIssueTrash(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssueTrash(args) {
+	const runArgs = {
+		commandPath: "issue trash",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags.allowActiveWorkspaceWrite = args.allowActiveWorkspaceWrite;
+			const result = await issueTrashRuntime({
+				args: { identifier: args.identifier },
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssueTrash = class IssueTrash extends Command {
+	static description = "Trash a Linear issue (soft delete, recoverable for ~30 days via the Linear UI).";
+	static enableJsonFlag = true;
+	static args = { identifier: Args.string({
+		required: true,
+		description: "Issue identifier (ENG-123) or UUID"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		"allow-active-workspace-write": Flags.boolean({ description: "Per-invocation opt-in to use the active default workspace for this write (WSP-06)" })
+	};
+	async run() {
+		const { args, flags } = await this.parse(IssueTrash);
+		const callArgs = {
+			identifier: args.identifier,
+			pretty: flags.pretty,
+			allowActiveWorkspaceWrite: flags["allow-active-workspace-write"]
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssueTrash(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssueTrash as default, runIssueTrash };

package/dist/commands/issue/update.js

@@ -0,0 +1,126 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueUpdateRuntime } from "../../lib/issue-update-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/update.ts
+/**
+* `linmux issue update <identifier>` -- Phase 2 PLAN 02-04 Task 2,
+* ISS-04.
+*
+* Write command. Resolves the issue (identifier or UUID), reads its team
+* for team-scoped resolvers, builds an `IssueUpdateInput` from any of 11
+* partial field flags. WSP-06 enforcement and VALIDATION_NO_FIELDS guard
+* both run in the runtime BEFORE any SDK call.
+*
+* Three label modes co-exist (CONTEXT line 44):
+*   - `--labels p0,bug`        replace mode -> labelIds
+*   - `--add-label p0`  (xN)   add mode     -> addedLabelIds
+*   - `--remove-label legacy`  remove mode  -> removedLabelIds
+*
+* Implementation lives in `src/lib/issue-update-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runIssueUpdate(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssueUpdate(args) {
+	const runArgs = {
+		commandPath: "issue update",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags.allowActiveWorkspaceWrite = args.allowActiveWorkspaceWrite;
+			if (args.title !== void 0) runtimeFlags.title = args.title;
+			if (args.description !== void 0) runtimeFlags.description = args.description;
+			if (args.state !== void 0) runtimeFlags.state = args.state;
+			if (args.assignee !== void 0) runtimeFlags.assignee = args.assignee;
+			if (args.labels !== void 0) runtimeFlags.labels = args.labels;
+			if (args.addLabel !== void 0) runtimeFlags.addLabel = args.addLabel;
+			if (args.removeLabel !== void 0) runtimeFlags.removeLabel = args.removeLabel;
+			if (args.project !== void 0) runtimeFlags.project = args.project;
+			if (args.cycle !== void 0) runtimeFlags.cycle = args.cycle;
+			if (args.priority !== void 0) runtimeFlags.priority = args.priority;
+			const result = await issueUpdateRuntime({
+				args: { identifier: args.identifier },
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var IssueUpdate = class IssueUpdate extends Command {
+	static description = "Update a Linear issue. Three label modes co-exist: --labels (replace), --add-label (additive), --remove-label (subtractive). At least one field flag is required.";
+	static enableJsonFlag = true;
+	static args = { identifier: Args.string({
+		required: true,
+		description: "Issue identifier (ENG-123) or UUID"
+	}) };
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		"allow-active-workspace-write": Flags.boolean({ description: "Per-invocation opt-in to use the active default workspace for this write (WSP-06)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		title: Flags.string({ description: "New issue title" }),
+		description: Flags.string({ description: "New issue description (markdown). Pass \"\" to clear." }),
+		state: Flags.string({ description: "Workflow state name (e.g. \"In Progress\") or UUID" }),
+		assignee: Flags.string({ description: "\"me\", email, name, or user UUID" }),
+		labels: Flags.string({ description: "Comma-separated label names or UUIDs (REPLACE mode -- maps to labelIds)" }),
+		"add-label": Flags.string({
+			multiple: true,
+			description: "Label name or UUID to add (ADD mode -- repeatable; maps to addedLabelIds)"
+		}),
+		"remove-label": Flags.string({
+			multiple: true,
+			description: "Label name or UUID to remove (REMOVE mode -- repeatable; maps to removedLabelIds)"
+		}),
+		project: Flags.string({ description: "Project name or UUID" }),
+		cycle: Flags.string({ description: "Cycle ref (current|next|previous|+N|-N|UUID|name)" }),
+		priority: Flags.integer({
+			description: "Priority (0=no priority, 1=urgent, 2=high, 3=medium, 4=low)",
+			min: 0,
+			max: 4
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(IssueUpdate);
+		const callArgs = {
+			identifier: args.identifier,
+			pretty: flags.pretty,
+			allowActiveWorkspaceWrite: flags["allow-active-workspace-write"]
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.title !== void 0) callArgs.title = flags.title;
+		if (flags.description !== void 0) callArgs.description = flags.description;
+		if (flags.state !== void 0) callArgs.state = flags.state;
+		if (flags.assignee !== void 0) callArgs.assignee = flags.assignee;
+		if (flags.labels !== void 0) callArgs.labels = flags.labels;
+		if (flags["add-label"] !== void 0) callArgs.addLabel = flags["add-label"];
+		if (flags["remove-label"] !== void 0) callArgs.removeLabel = flags["remove-label"];
+		if (flags.project !== void 0) callArgs.project = flags.project;
+		if (flags.cycle !== void 0) callArgs.cycle = flags.cycle;
+		if (flags.priority !== void 0) callArgs.priority = flags.priority;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runIssueUpdate(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { IssueUpdate as default, runIssueUpdate };

package/dist/commands/label/create.js

@@ -0,0 +1,91 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { labelCreateRuntime } from "../../lib/label-create-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/label/create.ts
+/**
+* `linmux label create` -- Phase 2 PLAN 02-09 Task 2, LBL-01.create.
+*
+* Write command -- the only write in plan 02-09. Creates a Linear issue label
+* scoped to a team. RESEARCH § Pitfall 13: every label gets a `teamId`; the
+* `--team` flag is REQUIRED. Implementation lives in
+* `src/lib/label-create-runtime.ts` per the Phase 1 PLAN-04 invariant.
+*
+* Exports BOTH the default Command class AND a named `runLabelCreate(args)`
+* function.
+*/
+async function runLabelCreate(args) {
+	const runArgs = {
+		commandPath: "label create",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = {};
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.fields !== void 0) runtimeFlags.fields = args.fields;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags.allowActiveWorkspaceWrite = args.allowActiveWorkspaceWrite;
+			if (args.name !== void 0) runtimeFlags.name = args.name;
+			if (args.team !== void 0) runtimeFlags.team = args.team;
+			if (args.color !== void 0) runtimeFlags.color = args.color;
+			if (args.description !== void 0) runtimeFlags.description = args.description;
+			const result = await labelCreateRuntime({
+				args: {},
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			});
+			return {
+				data: result.data,
+				meta: result.meta
+			};
+		}
+	};
+	if (args.noMeta !== void 0) runArgs.noMeta = args.noMeta;
+	if (args.quiet !== void 0) runArgs.quiet = args.quiet;
+	if (args.retry !== void 0) runArgs.retry = args.retry;
+	return runCommand(runArgs);
+}
+var LabelCreate = class LabelCreate extends Command {
+	static description = "Create a Linear issue label scoped to a team. --name + --team required.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (required for write unless --allow-active-workspace-write)" }),
+		"allow-active-workspace-write": Flags.boolean({ description: "Per-invocation opt-in to use the active default workspace for this write (WSP-06)" }),
+		fields: Flags.string({
+			default: "defaults",
+			description: "Field preset (ids|defaults|full) or comma-separated list"
+		}),
+		name: Flags.string({
+			required: true,
+			description: "Label name"
+		}),
+		team: Flags.string({
+			required: true,
+			description: "Team key (e.g. ENG), UUID, or name"
+		}),
+		color: Flags.string({ description: "Label color (hex, e.g. #ff0000)" }),
+		description: Flags.string({ description: "Label description" })
+	};
+	async run() {
+		const { flags } = await this.parse(LabelCreate);
+		const callArgs = {
+			pretty: flags.pretty,
+			allowActiveWorkspaceWrite: flags["allow-active-workspace-write"]
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		if (flags.name !== void 0) callArgs.name = flags.name;
+		if (flags.team !== void 0) callArgs.team = flags.team;
+		if (flags.color !== void 0) callArgs.color = flags.color;
+		if (flags.description !== void 0) callArgs.description = flags.description;
+		if (flags.quiet !== void 0) callArgs.quiet = flags.quiet;
+		if (flags.noMeta !== void 0) callArgs.noMeta = flags.noMeta;
+		if (flags.retry !== void 0) callArgs.retry = flags.retry;
+		const out = await runLabelCreate(callArgs);
+		if (!flags.json) process.stdout.write(out.stdout);
+		if (out.stderr) process.stderr.write(out.stderr);
+		if (out.exitCode !== 0) process.exitCode = out.exitCode;
+		return JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { LabelCreate as default, runLabelCreate };