linmux 0.1.0

package/dist/commands/cycle/list.js

@@ -0,0 +1,84 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { cycleListRuntime } from "../../lib/cycle-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/cycle/list.ts
+/**
+* `linmux cycle list` -- Phase 2 PLAN 02-08 Task 1, CYC-01.list.
+*
+* Read command. Lists Linear cycles with optional --team filter, --fields,
+* --limit, --cursor. NO WSP-06 enforcement -- reads are allowed against the
+* active default workspace.
+*
+* Implementation lives in `src/lib/cycle-list-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runCycleList(args)` async function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runCycleList(args) {
+	const runArgs = {
+		commandPath: "cycle list",
+		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.team !== void 0) runtimeFlags.team = args.team;
+			if (args.include !== void 0) runtimeFlags.include = args.include;
+			const result = await cycleListRuntime({
+				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 CycleList = class CycleList extends Command {
+	static description = "List Linear cycles, optionally filtered to a single team via --team. Supports --fields, --limit, --cursor.";
+	static enableJsonFlag = true;
+	static flags = {
+		...BASE_FLAGS,
+		...PAGINATION_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		team: Flags.string({ description: "Team key (e.g. \"ENG\"), name, or UUID -- filters cycles to one team" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		include: Flags.string({
+			description: "Hydrate related entities in a single GraphQL round-trip (e.g. issues). Available: issues.",
+			multiple: true
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(CycleList);
+		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.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 runCycleList(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 { CycleList as default, runCycleList };

package/dist/commands/cycle/move.js

@@ -0,0 +1,91 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { cycleMoveRuntime } from "../../lib/cycle-move-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/cycle/move.ts
+/**
+* `linmux cycle move <issue-ref> --to <cycle-ref>` --
+* Phase 2 PLAN 02-08 Task 2, CYC-01.move.
+*
+* Write command. Moves a Linear issue to a different cycle. Linear has NO
+* dedicated "move cycle" mutation; cycle is a property on Issue. The runtime
+* calls `client.updateIssue(issueId, { cycleId })`.
+*
+* `<cycle-ref>` accepts 7 shapes via the cycle resolver from Plan 02-02
+* (UUID, +N/-N/0, current/next/previous, or cycle name).
+*
+* Implementation lives in `src/lib/cycle-move-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runCycleMove(args)` async function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runCycleMove(args) {
+	const runArgs = {
+		commandPath: "cycle move",
+		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 cycleMoveRuntime({
+				args: {
+					issue: args.issue,
+					to: args.to
+				},
+				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 CycleMove = class CycleMove extends Command {
+	static description = "Move a Linear issue to a different cycle. Calls updateIssue({ cycleId }); cycle is a property on Issue.";
+	static enableJsonFlag = true;
+	static args = { issue: 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"
+		}),
+		to: Flags.string({
+			required: true,
+			description: "Cycle ref: UUID, +N/-N/0, current/next/previous, or cycle name"
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(CycleMove);
+		const callArgs = {
+			issue: args.issue,
+			to: flags.to,
+			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 runCycleMove(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 { CycleMove as default, runCycleMove };

package/dist/commands/describe.js

@@ -0,0 +1,65 @@
+import { describeRuntime } from "../lib/describe-runtime.js";
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { Args, Command } from "@oclif/core";
+//#region src/commands/describe.ts
+/**
+* `linmux describe <command>` — Phase 4 PLAN 04-03, INT-02.
+*
+* Returns input JSON Schema (from Zod) + examples for curated commands,
+* and input JSON Schema + SDL fragment for raw GraphQL operations.
+*
+* Zero network calls — introspects local registries only.
+* No --workspace flag (WSP-06 does not apply to local introspection).
+*
+* Disambiguation:
+*   - "issue list" (lowercase or space) → curated command
+*   - "IssueCreate" (PascalCase single token) → raw operation
+*
+* Two-export pattern (S1): named `runDescribe` function + default Command class.
+* Tests target the runtime; this file is the thin oclif adapter.
+*/
+async function runDescribe(args) {
+	const runArgs = {
+		commandPath: "describe",
+		pretty: args.pretty,
+		handler: async (_retryOpts) => {
+			return {
+				data: (await describeRuntime({
+					args: { command: args.command },
+					flags: {}
+				})).data,
+				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 Describe = class Describe extends Command {
+	static description = "Return input/output JSON Schema and examples for a curated or raw command.";
+	static enableJsonFlag = true;
+	static args = { command: Args.string({
+		description: "Command id (e.g. \"issue list\") or raw operation name (e.g. \"IssueCreate\")",
+		required: true
+	}) };
+	static flags = { ...BASE_FLAGS };
+	async run() {
+		const { args, flags } = await this.parse(Describe);
+		const callArgs = {
+			command: args.command,
+			pretty: flags.pretty
+		};
+		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 runDescribe(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 { Describe as default, runDescribe };

package/dist/commands/graphql/index.js

@@ -0,0 +1,92 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { runGraphql } from "../../lib/graphql-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/graphql/index.ts
+/**
+* `linmux graphql` — free-form GraphQL escape hatch for Phase 3 RAW-03.
+*
+* Execute any GraphQL query/mutation against the Linear API. The query is
+* locally validated against the vendored schema before dispatch — syntax
+* errors and unknown fields are caught WITHOUT spending a Linear API call.
+*
+* Canonical agent surface: `--query=@file.graphql` (file reference).
+* Inline form: `--query='{ viewer { id } }'` also supported for ergonomics.
+*
+* This file exports BOTH:
+*   - `export default class GraphqlCommand` — the oclif Command class
+*   - `export { runGraphql }` — named re-export for test seam (tests call
+*     the runtime directly without spawning a subprocess)
+*/
+var GraphqlCommand = class GraphqlCommand extends Command {
+	static enableJsonFlag = true;
+	static description = "Execute a free-form GraphQL query against Linear (locally validated against vendored schema before dispatch).";
+	static examples = [
+		"<%= config.bin %> graphql --query=@./query.graphql --vars '{\"id\": \"...\"}'",
+		"<%= config.bin %> graphql --query='{ viewer { id name } }'",
+		"<%= config.bin %> graphql --query=@./mutation.graphql --allow-mutations --workspace acme"
+	];
+	static flags = {
+		...BASE_FLAGS,
+		workspace: Flags.string({ description: "Workspace name (overrides active default and LINEAR_WORKSPACE)" }),
+		"allow-active-workspace-write": Flags.boolean({
+			default: false,
+			description: "Per-invocation opt-in to use the active default workspace for mutation operations (WSP-06)"
+		}),
+		"allow-mutations": Flags.boolean({
+			default: false,
+			description: "Required flag to execute mutation operations. Prevents accidental data modification."
+		}),
+		query: Flags.string({
+			required: true,
+			description: "GraphQL query source: inline string (e.g. \"{ viewer { id } }\") OR file reference (@./query.graphql)"
+		}),
+		vars: Flags.string({ description: "Variables as inline JSON (e.g. '{\"id\": \"...\"}') OR file reference (@./vars.json)" })
+	};
+	async run() {
+		const { flags } = await this.parse(GraphqlCommand);
+		const callArgs = {
+			query: flags.query,
+			pretty: flags.pretty
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags["allow-active-workspace-write"] !== void 0) callArgs.allowActiveWorkspaceWrite = flags["allow-active-workspace-write"];
+		if (flags["allow-mutations"] !== void 0) callArgs.allowMutations = flags["allow-mutations"];
+		if (flags.vars !== void 0) callArgs.vars = flags.vars;
+		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 runGraphqlCommand(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);
+	}
+};
+async function runGraphqlCommand(args) {
+	const runArgs = {
+		commandPath: "graphql",
+		pretty: args.pretty,
+		handler: async (retryOpts) => {
+			const runtimeFlags = { query: args.query };
+			if (args.workspace !== void 0) runtimeFlags.workspace = args.workspace;
+			if (args.allowActiveWorkspaceWrite !== void 0) runtimeFlags["allow-active-workspace-write"] = args.allowActiveWorkspaceWrite;
+			if (args.allowMutations !== void 0) runtimeFlags["allow-mutations"] = args.allowMutations;
+			if (args.vars !== void 0) runtimeFlags.vars = args.vars;
+			const result = await runGraphql({
+				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);
+}
+//#endregion
+export { GraphqlCommand as default, runGraphql };

package/dist/commands/install-skill.js

@@ -0,0 +1,54 @@
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { installSkillRuntime } from "../lib/install-skill-runtime.js";
+import { Command } from "@oclif/core";
+//#region src/commands/install-skill.ts
+/**
+* `linmux install-skill` — Phase 5 PLAN 05-02 Task 3, DST-06.
+*
+* Top-level command. Copies the bundled SKILL.md into
+* `~/.claude/skills/linmux/SKILL.md`. No flags in v1; deterministic
+* overwrite is the contract.
+*
+* Two-export pattern (S1): default oclif `Command` class + named
+* `runInstallSkill` wrapper. Tests target the named export; oclif discovers
+* the default class through the manifest.
+*
+* Workspace-less: this command makes ZERO network calls and does not call
+* `resolveWorkspace`. Mirrors `list-tools` exactly.
+*/
+async function runInstallSkill(args) {
+	const runArgs = {
+		commandPath: "install-skill",
+		pretty: args.pretty,
+		handler: async (_retryOpts) => {
+			const result = await installSkillRuntime({ env: process.env });
+			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 InstallSkill = class InstallSkill extends Command {
+	static description = "Copy the bundled Claude Code skill to ~/.claude/skills/linmux/SKILL.md.";
+	static enableJsonFlag = true;
+	static flags = { ...BASE_FLAGS };
+	async run() {
+		const { flags } = await this.parse(InstallSkill);
+		const callArgs = { pretty: flags.pretty };
+		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 runInstallSkill(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 flags.pretty ? void 0 : JSON.parse(out.stdout);
+	}
+};
+//#endregion
+export { InstallSkill as default, runInstallSkill };

package/dist/commands/issue/archive.js

@@ -0,0 +1,75 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueArchiveRuntime } from "../../lib/issue-archive-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/archive.ts
+/**
+* `linmux issue archive <identifier>` -- Phase 2 PLAN 02-05 Task 1,
+* ISS-06.archive.
+*
+* Reversible archive (Linear preserves the issue and lets it be unarchived).
+* Calls `client.archiveIssue(uuid)`. WSP-06 enforced in the runtime BEFORE
+* the SDK call. NO `--yes` flag (CONTEXT line 49 -- archive is reversible
+* via the Linear UI).
+*
+* Implementation lives in `src/lib/issue-archive-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runIssueArchive(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssueArchive(args) {
+	const runArgs = {
+		commandPath: "issue archive",
+		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 issueArchiveRuntime({
+				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 IssueArchive = class IssueArchive extends Command {
+	static description = "Archive a Linear issue (reversible). Linear keeps the issue and supports unarchive.";
+	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(IssueArchive);
+		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 runIssueArchive(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 { IssueArchive as default, runIssueArchive };

package/dist/commands/issue/create.js

@@ -0,0 +1,115 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueCreateRuntime } from "../../lib/issue-create-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/issue/create.ts
+/**
+* `linmux issue create` — Phase 2 PLAN 02-04 Task 1, ISS-03.
+*
+* Write command. Mints a Linear issue with `--title` + `--team` (the only
+* required flags per CONTEXT line 47) and any of 9 optional fields. WSP-06
+* enforcement and required-flag validation both run in the runtime BEFORE
+* any SDK call.
+*
+* Implementation lives in `src/lib/issue-create-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runIssueCreate(args)` function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runIssueCreate(args) {
+	const runArgs = {
+		commandPath: "issue 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.title !== void 0) runtimeFlags.title = args.title;
+			if (args.team !== void 0) runtimeFlags.team = args.team;
+			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.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;
+			if (args.parent !== void 0) runtimeFlags.parent = args.parent;
+			const result = await issueCreateRuntime({
+				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 IssueCreate = class IssueCreate extends Command {
+	static description = "Create a Linear issue (--title + --team required; --description, --state, --assignee, --labels, --project, --cycle, --priority, --parent optional).";
+	static enableJsonFlag = true;
+	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({
+			required: true,
+			description: "Issue title (required)"
+		}),
+		team: Flags.string({
+			required: true,
+			description: "Team key (ENG), team name, or team UUID (required)"
+		}),
+		description: Flags.string({ description: "Issue description (markdown)" }),
+		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)" }),
+		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
+		}),
+		parent: Flags.string({ description: "Parent issue identifier (ENG-42) or UUID" })
+	};
+	async run() {
+		const { flags } = await this.parse(IssueCreate);
+		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.title !== void 0) callArgs.title = flags.title;
+		if (flags.team !== void 0) callArgs.team = flags.team;
+		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.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.parent !== void 0) callArgs.parent = flags.parent;
+		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 runIssueCreate(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 { IssueCreate as default, runIssueCreate };

package/dist/commands/issue/get.js

@@ -0,0 +1,84 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { issueGetRuntime } from "../../lib/issue-get-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/issue/get.ts
+/**
+* `linmux issue get <identifier>` — Phase 2 PLAN 02-03 Task 1, ISS-02.
+*
+* Single-entity read. Accepts a Linear identifier (`ENG-123`) OR a UUID;
+* shape detection lives in `issue-get-runtime.ts`. Implementation lives in
+* `src/lib/issue-get-runtime.ts` per the Phase 1 PLAN-04 invariant — oclif's
+* manifest scans every file under `src/commands/` as a Command class, so
+* non-Command helpers must live elsewhere (`src/lib/` is the canonical home).
+*
+* Both the oclif Command class AND a named `runIssueGet(args)` function are
+* exported from this file 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").
+*/
+async function runIssueGet(args) {
+	const runArgs = {
+		commandPath: "issue get",
+		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.include !== void 0) runtimeFlags.include = args.include;
+			const result = await issueGetRuntime({
+				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 IssueGet = class IssueGet extends Command {
+	static description = "Get a single Linear issue by identifier (ENG-123) or UUID.";
+	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)" }),
+		fields: Flags.string({
+			description: "Field preset (ids|defaults|full) or comma-separated list",
+			default: "defaults"
+		}),
+		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 { args, flags } = await this.parse(IssueGet);
+		const callArgs = {
+			identifier: args.identifier,
+			pretty: flags.pretty
+		};
+		if (flags.workspace !== void 0) callArgs.workspace = flags.workspace;
+		if (flags.fields !== void 0) callArgs.fields = flags.fields;
+		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 runIssueGet(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 { IssueGet as default, runIssueGet };