linmux 0.1.0

package/dist/commands/label/list.js

@@ -0,0 +1,76 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { labelListRuntime } from "../../lib/label-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/label/list.ts
+/**
+* `linmux label list` -- Phase 2 PLAN 02-09 Task 2, LBL-01.list.
+*
+* Read command. Lists issue labels either workspace-wide or scoped to one
+* team via `--team` (UUID, key, or name). Implementation lives in
+* `src/lib/label-list-runtime.ts`.
+*
+* Exports BOTH the default Command class AND a named `runLabelList(args)`
+* function.
+*/
+async function runLabelList(args) {
+	const runArgs = {
+		commandPath: "label 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;
+			const result = await labelListRuntime({
+				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 LabelList = class LabelList extends Command {
+	static description = "List Linear issue labels. Pass --team <UUID|key|name> to scope to one team.";
+	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"
+		}),
+		team: Flags.string({ description: "Optional team filter (UUID, key, or name)" })
+	};
+	async run() {
+		const { flags } = await this.parse(LabelList);
+		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.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 runLabelList(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 { LabelList as default, runLabelList };

package/dist/commands/list-tools.js

@@ -0,0 +1,47 @@
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { listToolsRuntime } from "../lib/list-tools-runtime.js";
+import { Command } from "@oclif/core";
+//#region src/commands/list-tools.ts
+/**
+* `linmux list-tools` — Phase 4 PLAN 04-02, INT-01.
+*
+* Enumerates every curated and raw command, marking curated→raw mappings.
+* Zero network calls — all data is assembled from static registries.
+*
+* Two-export pattern (S1): default oclif class + named `runListTools` wrapper.
+*/
+async function runListTools(args) {
+	const runArgs = {
+		commandPath: "list-tools",
+		pretty: args.pretty,
+		handler: async (_retryOpts) => {
+			return {
+				data: (await listToolsRuntime({ 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 ListTools = class ListTools extends Command {
+	static description = "Enumerate every curated and raw command with curated→raw mappings.";
+	static enableJsonFlag = true;
+	static flags = { ...BASE_FLAGS };
+	async run() {
+		const { flags } = await this.parse(ListTools);
+		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 runListTools(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 { ListTools as default, runListTools };

package/dist/commands/me.js

@@ -0,0 +1,71 @@
+import { BASE_FLAGS, runCommand } from "../lib/workspace-runtime.js";
+import { meRuntime } from "../lib/me-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/me.ts
+/**
+* `linmux me` -- Phase 2 PLAN 02-09 Task 1, WHO-01.
+*
+* Read command. Prints the resolved viewer (current user) and their
+* organization for the active workspace. Shares `src/lib/me-runtime.ts`
+* with `whoami` -- both commands emit IDENTICAL envelopes except for
+* `meta.command` (`'me'` vs `'whoami'`). `whoami` exists purely for
+* discoverability per CONTEXT § Specifics line 65.
+*
+* Exports BOTH the default Command class AND a named `runMe(args)`
+* function.
+*/
+async function runMe(args) {
+	const runArgs = {
+		commandPath: "me",
+		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;
+			const meInput = {
+				flags: runtimeFlags,
+				env: process.env,
+				retryOptsOverride: retryOpts
+			};
+			if (args.loadConfigOverride !== void 0) meInput.loadConfigOverride = args.loadConfigOverride;
+			if (args.clientFactoryOverride !== void 0) meInput.clientFactoryOverride = args.clientFactoryOverride;
+			const result = await meRuntime(meInput);
+			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 Me = class Me extends Command {
+	static description = "Print the resolved viewer (user) and organization for the current workspace.";
+	static enableJsonFlag = true;
+	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"
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(Me);
+		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.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 runMe(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 { Me as default, runMe };

package/dist/commands/project/create.js

@@ -0,0 +1,101 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { projectCreateRuntime } from "../../lib/project-create-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/project/create.ts
+/**
+* `linmux project create` -- Phase 2 PLAN 02-07 Task 2, PRJ-01.create.
+*
+* Write command. Required: `--name` + `--teams` (comma-separated team
+* keys/UUIDs/names; >=1). Optional: --description, --state, --lead,
+* --start-date, --target-date.
+*
+* Implementation lives in `src/lib/project-create-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runProjectCreate(args)` async function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runProjectCreate(args) {
+	const runArgs = {
+		commandPath: "project 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.teams !== void 0) runtimeFlags.teams = args.teams;
+			if (args.description !== void 0) runtimeFlags.description = args.description;
+			if (args.state !== void 0) runtimeFlags.state = args.state;
+			if (args.lead !== void 0) runtimeFlags.lead = args.lead;
+			if (args.startDate !== void 0) runtimeFlags.startDate = args.startDate;
+			if (args.targetDate !== void 0) runtimeFlags.targetDate = args.targetDate;
+			const result = await projectCreateRuntime({
+				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 ProjectCreate = class ProjectCreate extends Command {
+	static description = "Create a Linear project (--name + --teams required; --description, --state, --lead, --start-date, --target-date 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"
+		}),
+		name: Flags.string({
+			required: true,
+			description: "Project name (required)"
+		}),
+		teams: Flags.string({
+			required: true,
+			description: "Comma-separated team keys (ENG), names (Engineering), or UUIDs; at least one required"
+		}),
+		description: Flags.string({ description: "Project description (markdown)" }),
+		state: Flags.string({ description: "Project state ('planned' | 'started' | 'paused' | 'completed' | 'canceled' | 'backlog')" }),
+		lead: Flags.string({ description: "\"me\", email, name, or user UUID" }),
+		"start-date": Flags.string({ description: "Project start date (ISO 8601, e.g. 2026-10-01)" }),
+		"target-date": Flags.string({ description: "Project target date (ISO 8601, e.g. 2026-12-31)" })
+	};
+	async run() {
+		const { flags } = await this.parse(ProjectCreate);
+		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.teams !== void 0) callArgs.teams = flags.teams;
+		if (flags.description !== void 0) callArgs.description = flags.description;
+		if (flags.state !== void 0) callArgs.state = flags.state;
+		if (flags.lead !== void 0) callArgs.lead = flags.lead;
+		if (flags["start-date"] !== void 0) callArgs.startDate = flags["start-date"];
+		if (flags["target-date"] !== void 0) callArgs.targetDate = flags["target-date"];
+		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 runProjectCreate(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 { ProjectCreate as default, runProjectCreate };

package/dist/commands/project/get.js

@@ -0,0 +1,83 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { projectGetRuntime } from "../../lib/project-get-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/project/get.ts
+/**
+* `linmux project get <ref>` -- Phase 2 PLAN 02-07 Task 1, PRJ-01.get.
+*
+* Single-entity read. Accepts a project name or UUID. UUIDs short-circuit
+* resolveProjectId; names go through the workspace-scoped resolver from
+* Plan 02-02. NO WSP-06 enforcement -- reads are allowed against the active
+* default workspace.
+*
+* Implementation lives in `src/lib/project-get-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runProjectGet(args)` async function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runProjectGet(args) {
+	const runArgs = {
+		commandPath: "project 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 projectGetRuntime({
+				args: { ref: args.ref },
+				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 ProjectGet = class ProjectGet extends Command {
+	static description = "Get a single Linear project by name or UUID.";
+	static enableJsonFlag = true;
+	static args = { ref: Args.string({
+		required: true,
+		description: "Project name 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. members, teams). Available: members, teams, projectMilestones, documents.",
+			multiple: true
+		})
+	};
+	async run() {
+		const { args, flags } = await this.parse(ProjectGet);
+		const callArgs = {
+			ref: args.ref,
+			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 runProjectGet(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 { ProjectGet as default, runProjectGet };

package/dist/commands/project/list.js

@@ -0,0 +1,75 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { PAGINATION_FLAGS } from "../../core/pagination/flags.js";
+import "../../core/pagination/index.js";
+import { projectListRuntime } from "../../lib/project-list-runtime.js";
+import { Command, Flags } from "@oclif/core";
+//#region src/commands/project/list.ts
+/**
+* `linmux project list` -- Phase 2 PLAN 02-07 Task 1, PRJ-01.list.
+*
+* Read command. Lists workspace-wide projects with --fields, --limit, and
+* --cursor. NO WSP-06 enforcement -- reads are allowed against the active
+* default workspace.
+*
+* Implementation lives in `src/lib/project-list-runtime.ts` per the Phase 1
+* PLAN-04 invariant. This file exports BOTH the oclif Command class AND a
+* named `runProjectList(args)` async function so tests can call the runtime
+* without spawning a subprocess.
+*/
+async function runProjectList(args) {
+	const runArgs = {
+		commandPath: "project 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;
+			const result = await projectListRuntime({
+				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 ProjectList = class ProjectList extends Command {
+	static description = "List Linear projects in the active workspace, with --fields, --limit, --cursor.";
+	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"
+		})
+	};
+	async run() {
+		const { flags } = await this.parse(ProjectList);
+		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.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 runProjectList(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 { ProjectList as default, runProjectList };

package/dist/commands/project/update-status.js

@@ -0,0 +1,99 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { projectUpdateStatusRuntime } from "../../lib/project-update-status-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/project/update-status.ts
+/**
+* `linmux project update-status <ref> <status>` --
+* Phase 2 PLAN 02-07 Task 2, PRJ-01.update-status.
+*
+* **Multi-word command file**: oclif resolves
+* `src/commands/project/update-status.ts` to `linmux project update-status`
+* (filename-to-command separator is space; the dash inside the filename is
+* preserved verbatim per RESEARCH 02-07 line 252).
+*
+* Sets a project's CURRENT status by calling
+* `client.updateProject(projectId, { statusId })`. The SDK's status-
+* DEFINITION mutator (an admin operation that would rename / recolor /
+* reposition the status row workspace-wide) is explicitly NOT called from
+* this code path -- see RESEARCH § Pitfall 5. The runtime file's header
+* documents the trap; this command is the agent-meaningful "set this
+* project to <status>" path.
+*
+* Implementation lives in `src/lib/project-update-status-runtime.ts` per the
+* Phase 1 PLAN-04 invariant. This file exports BOTH the oclif Command class
+* AND a named `runProjectUpdateStatus(args)` async function so tests can call
+* the runtime without spawning a subprocess.
+*/
+async function runProjectUpdateStatus(args) {
+	const runArgs = {
+		commandPath: "project update-status",
+		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 projectUpdateStatusRuntime({
+				args: {
+					ref: args.ref,
+					status: args.status
+				},
+				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 ProjectUpdateStatus = class ProjectUpdateStatus extends Command {
+	static description = "Set a Linear project's current status (e.g. \"On Track\" -> \"At Risk\"). Calls updateProject({ statusId }); does NOT mutate the workspace-level status definition.";
+	static enableJsonFlag = true;
+	static args = {
+		ref: Args.string({
+			required: true,
+			description: "Project name or UUID"
+		}),
+		status: Args.string({
+			required: true,
+			description: "Status name (e.g. \"At Risk\") 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(ProjectUpdateStatus);
+		const callArgs = {
+			ref: args.ref,
+			status: args.status,
+			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 runProjectUpdateStatus(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 { ProjectUpdateStatus as default, runProjectUpdateStatus };

package/dist/commands/project/update.js

@@ -0,0 +1,99 @@
+import { BASE_FLAGS, runCommand } from "../../lib/workspace-runtime.js";
+import { projectUpdateRuntime } from "../../lib/project-update-runtime.js";
+import { Args, Command, Flags } from "@oclif/core";
+//#region src/commands/project/update.ts
+/**
+* `linmux project update <ref>` -- Phase 2 PLAN 02-07 Task 2,
+* PRJ-01.update.
+*
+* Write command. Resolves a project ref (name or UUID) and applies any subset
+* of partial field flags via `client.updateProject`. WSP-06 enforcement and
+* VALIDATION_NO_FIELDS guard both run BEFORE any SDK call.
+*
+* NOTE: To change a project's CURRENT status, use the dedicated
+* `linmux project update-status <ref> <status>` sub-command -- it
+* routes through the same `updateProject({ statusId })` mutation, but the
+* dedicated command keeps the load-bearing operation discoverable + the input
+* shape un-ambiguous (per RESEARCH § Pitfall 5).
+*/
+async function runProjectUpdate(args) {
+	const runArgs = {
+		commandPath: "project 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.name !== void 0) runtimeFlags.name = args.name;
+			if (args.description !== void 0) runtimeFlags.description = args.description;
+			if (args.state !== void 0) runtimeFlags.state = args.state;
+			if (args.lead !== void 0) runtimeFlags.lead = args.lead;
+			if (args.startDate !== void 0) runtimeFlags.startDate = args.startDate;
+			if (args.targetDate !== void 0) runtimeFlags.targetDate = args.targetDate;
+			const result = await projectUpdateRuntime({
+				args: { ref: args.ref },
+				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 ProjectUpdate = class ProjectUpdate extends Command {
+	static description = "Update a Linear project. At least one field flag is required. Use `project update-status` to change the project's current status.";
+	static enableJsonFlag = true;
+	static args = { ref: Args.string({
+		required: true,
+		description: "Project name 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"
+		}),
+		name: Flags.string({ description: "New project name" }),
+		description: Flags.string({ description: "New project description (markdown). Pass \"\" to clear." }),
+		state: Flags.string({ description: "Project state ('planned' | 'started' | 'paused' | 'completed' | 'canceled' | 'backlog')" }),
+		lead: Flags.string({ description: "\"me\", email, name, or user UUID" }),
+		"start-date": Flags.string({ description: "Project start date (ISO 8601, e.g. 2026-10-01)" }),
+		"target-date": Flags.string({ description: "Project target date (ISO 8601, e.g. 2026-12-31)" })
+	};
+	async run() {
+		const { args, flags } = await this.parse(ProjectUpdate);
+		const callArgs = {
+			ref: args.ref,
+			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.description !== void 0) callArgs.description = flags.description;
+		if (flags.state !== void 0) callArgs.state = flags.state;
+		if (flags.lead !== void 0) callArgs.lead = flags.lead;
+		if (flags["start-date"] !== void 0) callArgs.startDate = flags["start-date"];
+		if (flags["target-date"] !== void 0) callArgs.targetDate = flags["target-date"];
+		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 runProjectUpdate(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 { ProjectUpdate as default, runProjectUpdate };