linmux 0.1.0

package/dist/lib/project-update-status-runtime.js

@@ -0,0 +1,91 @@
+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 { resolveProjectId } from "../core/resolvers/project.js";
+import { resolveProjectStatusId } from "../core/resolvers/project-status.js";
+import "../core/resolvers/index.js";
+//#region src/lib/project-update-status-runtime.ts
+async function projectUpdateStatusRuntime(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 fields = parseFields(input.flags.fields ?? "defaults", "project");
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const workspaceKey = resolved.name ?? "_api-key-env_";
+		const [projectId, statusId] = await Promise.all([resolveProjectId(client, workspaceKey, input.args.ref, input.retryOptsOverride), resolveProjectStatusId(client, workspaceKey, input.args.status, input.retryOptsOverride)]);
+		const payload = await withRateLimitRetry(() => client.updateProject(projectId, { statusId }), input.retryOptsOverride);
+		if (!payload.success) throw LinearAgentError.linear.apiError({
+			message: "updateProject returned success=false",
+			details: { lastSyncId: payload.lastSyncId }
+		});
+		let updated;
+		if (payload.project !== void 0) {
+			const u = await Promise.resolve(payload.project);
+			if (u !== void 0 && u !== null) updated = u;
+		}
+		let data;
+		if (updated) data = project(await hydrateForProjection(updated, fields), fields);
+		else data = {
+			id: projectId,
+			statusId
+		};
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data,
+			meta
+		};
+	});
+}
+const RELATION_KEYS = new Set(["lead", "creator"]);
+async function hydrateForProjection(proj, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(proj)) if (!RELATION_KEYS.has(k)) out[k] = proj[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(proj)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = proj[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = proj[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 { projectUpdateStatusRuntime };

package/dist/lib/raw-batch-runtime.js

@@ -0,0 +1,229 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { OPERATION_REGISTRY } from "../generated/operations.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 { runRaw } from "./raw-runtime.js";
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+//#region src/lib/raw-batch-runtime.ts
+/**
+* `raw batch` runtime — Phase 3 PLAN 03-05, RAW-05.
+*
+* Safety-gated batch dispatcher. Runs a JSON plan of operations in sequence.
+* Owns:
+*   - RAW-05: `raw batch --plan=@file.json` with default dry-run + explicit --yes to execute
+*
+* **9-step pipeline:**
+*   1. resolveWorkspace (S2 verbatim)
+*   2. Validate plan flag has @ prefix → load + parse + Zod-validate → BATCH_PLAN_INVALID
+*   3. Registry lookup each entry's operation → BATCH_PLAN_INVALID with details.entry_index on miss
+*   4. Compute kinds = { query: N, mutation: M }
+*   5. If M > 0: requireExplicitWorkspaceForWrite (WSP-06 FIRST — Pitfall 7)
+*   6. If M > 0 && !allow-mutations: RAW_MUTATION_REQUIRES_FLAG
+*   7. Determine intent:
+*      - dryRun = flags['dry-run'] !== false (default true; --dry-run --yes still dry-run)
+*      - if dryRun: emit dry-run envelope; STOP (ZERO SDK calls)
+*      - if !dryRun && !yes: BATCH_REQUIRES_YES (exit 2)
+*      - if !dryRun && yes: dispatch sequentially via runRaw
+*   8. Sequential dispatch (NOT parallel — RESEARCH line 769; keeps rate-limit pressure manageable)
+*   9. Aggregate results; top-level ok:true (batch ran); per-entry ok:false on failure
+*
+* **Threat mitigations:**
+*   - T-03-05-WSP06: WSP-06 fires AFTER plan validation but BEFORE any dispatch (Pitfall 7)
+*   - T-03-05-DRY-RUN: --dry-run is the DEFAULT; both --dry-run + --yes → still dry-run
+*   - T-03-05-PLAN-FILE-INJECTION: Zod validates plan shape; max(100) caps blast radius (Pitfall 6)
+*   - T-03-05-D-RATELIMIT: Sequential dispatch + 100-entry cap
+*
+* **Mutation gates apply to dry-run too (REVIEW WR-03 — intentional):**
+*   Mutation-containing plans require --workspace (WSP-06) and
+*   --allow-mutations to dry-run, not just to execute. Rationale: the
+*   safety contract is "any plan touching mutations declares both target
+*   and intent upfront, regardless of whether it would run". A dry-run
+*   that side-steps the gates would let agents inspect plans they're not
+*   authorized to run. Uniform contract beats UX convenience.
+*/
+const PlanEntrySchema = z.object({
+	operation: z.string(),
+	vars: z.record(z.string(), z.unknown())
+});
+const PlanSchema = z.array(PlanEntrySchema).min(1).max(100);
+async function runRawBatch(input) {
+	const { flags, env = process.env } = input;
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const envForResolver = {};
+	if (env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = env.LINEAR_WORKSPACE;
+	if (env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: flags.workspace ? { workspace: flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	const plan = await loadAndValidatePlan(flags.plan);
+	const registry = OPERATION_REGISTRY;
+	const enriched = plan.map((entry, index) => {
+		const reg = registry[entry.operation];
+		if (!reg) throw new LinearAgentError({
+			code: "BATCH_PLAN_INVALID",
+			message: `entry ${index}: unknown operation '${entry.operation}'`,
+			details: {
+				entry_index: index,
+				reason: `unknown_operation: '${entry.operation}' not in OPERATION_REGISTRY`,
+				operation: entry.operation
+			}
+		});
+		const varsResult = reg.varsSchema.safeParse(entry.vars);
+		if (!varsResult.success) throw new LinearAgentError({
+			code: "BATCH_PLAN_INVALID",
+			message: `entry ${index}: vars failed validation for operation '${entry.operation}'`,
+			details: {
+				entry_index: index,
+				reason: "vars_invalid",
+				operation: entry.operation,
+				issues: varsResult.error.issues.map((i) => ({
+					path: i.path,
+					message: i.message,
+					code: i.code
+				}))
+			}
+		});
+		return {
+			...entry,
+			kind: reg.kind
+		};
+	});
+	const kinds = {
+		query: enriched.filter((e) => e.kind === "query").length,
+		mutation: enriched.filter((e) => e.kind === "mutation").length
+	};
+	const batchMeta = {
+		count: enriched.length,
+		kinds
+	};
+	if (kinds.mutation > 0) requireExplicitWorkspaceForWrite(resolved, flags["allow-active-workspace-write"] ?? false);
+	if (kinds.mutation > 0 && !flags["allow-mutations"]) throw new LinearAgentError({
+		code: "RAW_MUTATION_REQUIRES_FLAG",
+		message: `batch contains ${kinds.mutation} mutation(s) and requires --allow-mutations`,
+		details: { mutation_count: kinds.mutation }
+	});
+	if (flags["dry-run"] !== false) return {
+		data: { plan: enriched.map((e) => ({
+			operation: e.operation,
+			vars: e.vars,
+			kind: e.kind,
+			workspace: resolved.name
+		})) },
+		meta: {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			batch: batchMeta
+		}
+	};
+	if (!flags.yes) throw new LinearAgentError({
+		code: "BATCH_REQUIRES_YES",
+		message: "batch execution requires --yes to confirm (or remove --no-dry-run for a dry-run preview)",
+		details: { hint: "pass --yes to confirm execution, or remove --no-dry-run for a dry-run preview" }
+	});
+	const results = [];
+	for (const entry of enriched) try {
+		const result = await runRaw({
+			args: { operation: entry.operation },
+			flags: {
+				workspace: flags.workspace,
+				"allow-active-workspace-write": flags["allow-active-workspace-write"],
+				"allow-mutations": flags["allow-mutations"],
+				vars: JSON.stringify(entry.vars)
+			},
+			env,
+			loadConfigOverride: input.loadConfigOverride,
+			retryOptsOverride: input.retryOptsOverride
+		});
+		results.push({
+			ok: true,
+			operation: entry.operation,
+			data: result.data
+		});
+	} catch (err) {
+		if (err instanceof LinearAgentError) results.push({
+			ok: false,
+			operation: entry.operation,
+			error: {
+				code: err.code,
+				message: err.message,
+				...err.details !== void 0 ? { details: err.details } : {}
+			}
+		});
+		else {
+			const e = err;
+			results.push({
+				ok: false,
+				operation: entry.operation,
+				error: {
+					code: e.code ?? "GENERIC_ERROR",
+					message: e.message ?? "unknown error"
+				}
+			});
+		}
+	}
+	return {
+		data: { results },
+		meta: {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			batch: batchMeta
+		}
+	};
+}
+/**
+* Load, parse, and Zod-validate the plan file.
+* Plan flag MUST start with '@' (it's a required file ref).
+*/
+async function loadAndValidatePlan(planFlag) {
+	if (!planFlag.startsWith("@")) throw new LinearAgentError({
+		code: "BATCH_PLAN_INVALID",
+		message: `--plan must be an @file path (e.g. --plan=@plan.json); got: '${planFlag}'`,
+		details: { reason: "@file path required: prefix the path with @" }
+	});
+	const filePath = planFlag.slice(1);
+	let rawContent;
+	try {
+		rawContent = await readFile(filePath, "utf8");
+	} catch (err) {
+		const code = err.code;
+		throw new LinearAgentError({
+			code: "BATCH_PLAN_INVALID",
+			message: `plan file not found or not readable: ${filePath}`,
+			details: {
+				path: filePath,
+				reason: "file_not_readable",
+				cause: code ?? err.message
+			}
+		});
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(rawContent);
+	} catch (err) {
+		throw new LinearAgentError({
+			code: "BATCH_PLAN_INVALID",
+			message: `plan file is not valid JSON: ${err.message}`,
+			details: { reason: "parse_error" }
+		});
+	}
+	const result = PlanSchema.safeParse(parsed);
+	if (!result.success) {
+		const firstIssue = result.error.issues[0];
+		const entryIndex = firstIssue?.path[0] !== void 0 && typeof firstIssue.path[0] === "number" ? firstIssue.path[0] : void 0;
+		const details = { reason: firstIssue?.message ?? "validation_failed" };
+		if (entryIndex !== void 0) details.entry_index = entryIndex;
+		throw new LinearAgentError({
+			code: "BATCH_PLAN_INVALID",
+			message: `plan file validation failed: ${firstIssue?.message ?? "invalid shape"}`,
+			details
+		});
+	}
+	return result.data;
+}
+//#endregion
+export { runRawBatch };

package/dist/lib/raw-runtime.js

@@ -0,0 +1,171 @@
+import { LinearAgentError } from "../core/errors/error.js";
+import { OPERATION_REGISTRY } from "../generated/operations.js";
+import { suggestClosest } from "./levenshtein.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 { resolveWorkspace } from "../core/workspace/resolver.js";
+import { requireExplicitWorkspaceForWrite } from "../core/workspace/write-guard.js";
+import { readFile } from "node:fs/promises";
+//#region src/lib/raw-runtime.ts
+/**
+* `raw <Operation>` runtime — Phase 3 PLAN 03-02, RAW-01 / RAW-02.
+*
+* Dispatches any operation in the generated GraphQL registry via
+* `client.client.rawRequest(entry.source, vars)`. Owns:
+*   - RAW-01: full registry surface (501 ops) accessible from CLI
+*   - RAW-02: mutation safety with WSP-06 + --allow-mutations gates
+*
+* **Gate ordering is load-bearing (Test 3 — WSP-06 BEFORE --allow-mutations):**
+*   1. resolveWorkspace
+*   2. registry lookup (RAW_OPERATION_NOT_FOUND on miss; closest-match suggestions)
+*   3. subscription guard (OPERATION_SUBSCRIPTIONS_UNSUPPORTED — defensive)
+*   4. requireExplicitWorkspaceForWrite (WSP-06 FIRST — precedent: issue-purge-runtime.ts:99 Test 11)
+*   5. --allow-mutations check (RAW_MUTATION_REQUIRES_FLAG)
+*   6. vars parse + Zod validation (RAW_VARS_INVALID)
+*   7. createLinearClient
+*   8. client.client.rawRequest(entry.source, vars) wrapped in S3 transport
+*   9. response.error → LINEAR_API_ERROR (Pitfall 2: STRING not LinearError instance)
+*   10. meta build with opt-in complexity spread + return envelope
+*
+* Why WSP-06 first: a missing --workspace is the more dangerous mistake
+* (cross-workspace permanent write) vs a missing --allow-mutations flag.
+* Test 3 pins this ordering. Precedent: issue-purge-runtime.ts:99 Test 11.
+*
+* Pitfall 2 (RESEARCH § Pitfall 2): `client.client.rawRequest` does NOT
+* throw on GraphQL errors — it returns `LinearRawResponse` with `error?`
+* populated as a STRING. withRateLimitRetry still handles HTTP-layer
+* rate-limits via `instanceof RatelimitedLinearError`. Runtime checks
+* `response.error` explicitly → LINEAR_API_ERROR with `details.cause`.
+*/
+async function runRaw(input) {
+	const config = (input.loadConfigOverride ?? loadConfig)();
+	const env = input.env ?? process.env;
+	const envForResolver = {};
+	if (env.LINEAR_WORKSPACE !== void 0) envForResolver.LINEAR_WORKSPACE = env.LINEAR_WORKSPACE;
+	if (env.LINEAR_API_KEY !== void 0) envForResolver.LINEAR_API_KEY = env.LINEAR_API_KEY;
+	const resolved = resolveWorkspace({
+		flags: input.flags.workspace ? { workspace: input.flags.workspace } : {},
+		env: envForResolver,
+		config
+	});
+	const registry = OPERATION_REGISTRY;
+	const entry = Object.hasOwn(registry, input.args.operation) ? registry[input.args.operation] : void 0;
+	if (!entry) {
+		const suggestions = suggestClosest(input.args.operation, Object.keys(registry));
+		throw new LinearAgentError({
+			code: "RAW_OPERATION_NOT_FOUND",
+			message: `unknown operation: ${input.args.operation}. Did you mean: ${suggestions.join(", ")}?`,
+			details: {
+				operation: input.args.operation,
+				suggestions
+			}
+		});
+	}
+	if (entry.kind === "subscription") throw new LinearAgentError({
+		code: "OPERATION_SUBSCRIPTIONS_UNSUPPORTED",
+		message: `subscription operations are not supported: ${input.args.operation}`,
+		details: {
+			operation: input.args.operation,
+			kind: "subscription"
+		}
+	});
+	if (entry.kind === "mutation") requireExplicitWorkspaceForWrite(resolved, input.flags["allow-active-workspace-write"] ?? false);
+	if (entry.kind === "mutation" && !input.flags["allow-mutations"]) throw new LinearAgentError({
+		code: "RAW_MUTATION_REQUIRES_FLAG",
+		message: `mutation '${input.args.operation}' requires --allow-mutations`,
+		details: {
+			operation: input.args.operation,
+			kind: "mutation"
+		}
+	});
+	const rawVars = await loadVars(input.flags.vars);
+	const parsed = entry.varsSchema.safeParse(rawVars);
+	if (!parsed.success) throw new LinearAgentError({
+		code: "RAW_VARS_INVALID",
+		message: `vars failed validation for operation '${input.args.operation}'`,
+		details: {
+			operation: input.args.operation,
+			issues: parsed.error.issues.map((i) => ({
+				path: i.path,
+				message: i.message,
+				code: i.code
+			}))
+		}
+	});
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const response = await withRateLimitRetry(() => client.client.rawRequest(entry.source, parsed.data), input.retryOptsOverride);
+		if (response.error !== void 0 || response.data === void 0) throw new LinearAgentError({
+			code: "LINEAR_API_ERROR",
+			message: redact(response.error ?? `rawRequest returned no data for operation '${input.args.operation}'`),
+			details: {
+				cause: response.error !== void 0 ? redact(response.error) : void 0,
+				operation: input.args.operation,
+				status: response.status
+			}
+		});
+		const complexity = getLastComplexity();
+		const meta = {
+			workspace: resolved.name,
+			workspaceSource: resolved.source,
+			...complexity !== void 0 ? { complexity } : {}
+		};
+		return {
+			data: response.data,
+			meta
+		};
+	});
+}
+/**
+* Load and parse vars from inline JSON string or @file.json path.
+* File path takes precedence (CONTEXT.md line 51 contract).
+*/
+async function loadVars(varsArg) {
+	if (!varsArg) return {};
+	if (varsArg.startsWith("@")) {
+		const path = varsArg.slice(1);
+		let raw;
+		try {
+			raw = await readFile(path, "utf8");
+		} catch (err) {
+			const code = err.code;
+			throw new LinearAgentError({
+				code: "GRAPHQL_QUERY_FILE_NOT_FOUND",
+				message: `vars file not found or not readable: ${path}`,
+				details: {
+					path,
+					cause: code ?? err.message
+				}
+			});
+		}
+		try {
+			return JSON.parse(raw);
+		} catch (err) {
+			throw new LinearAgentError({
+				code: "RAW_VARS_INVALID",
+				message: `vars file is not valid JSON: ${err.message}`,
+				details: {
+					path,
+					reason: "parse_error"
+				}
+			});
+		}
+	}
+	try {
+		return JSON.parse(varsArg);
+	} catch (err) {
+		throw new LinearAgentError({
+			code: "RAW_VARS_INVALID",
+			message: `--vars is not valid JSON: ${err.message}`,
+			details: { reason: "parse_error" }
+		});
+	}
+}
+//#endregion
+export { runRaw };

package/dist/lib/schema-loader.js

@@ -0,0 +1,41 @@
+import { buildSchema } from "graphql";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/lib/schema-loader.ts
+/**
+* Lazy module-level cached Linear schema loader.
+*
+* Only the `graphql` command pays the ~50–150ms `buildSchema` cost. The `raw`
+* and `raw batch` commands never import this module, so the cold-start budget
+* for the dominant use case remains unaffected (Phase 5 DST-03).
+*
+* The path resolver works from BOTH:
+*   - `dist/lib/schema-loader.js` (built CLI) → ../../schema.graphql
+*   - `src/lib/schema-loader.ts` (vitest) → ../../schema.graphql
+*
+* Both sit two levels under the repo root, so the relative path `../../schema.graphql`
+* resolves correctly in both contexts.
+*/
+let cachedSchema;
+/**
+* Returns the Linear GraphQLSchema, building it lazily on first call
+* and returning the cached instance on subsequent calls.
+*/
+function getLinearSchema() {
+	if (cachedSchema) return cachedSchema;
+	cachedSchema = buildSchema(readFileSync(resolveSchemaPath(), "utf8"));
+	return cachedSchema;
+}
+function resolveSchemaPath() {
+	return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "schema.graphql");
+}
+/**
+* Reset the module-level schema cache. For test isolation only — do not use
+* in production code.
+*/
+function _resetSchemaCacheForTesting() {
+	cachedSchema = void 0;
+}
+//#endregion
+export { _resetSchemaCacheForTesting, getLinearSchema };

package/dist/lib/schema-runtime.js

@@ -0,0 +1,65 @@
+import { getLinearSchema } from "./schema-loader.js";
+import { introspectionFromSchema, printSchema } from "graphql";
+//#region src/lib/schema-runtime.ts
+/**
+* Schema runtime — Phase 4 PLAN 04-04, INT-03.
+*
+* Exposes the Linear GraphQL schema in two forms:
+*   - Default: compact SDL (triple-quoted descriptions stripped) for token-budget efficiency
+*   - --full: SDL with descriptions included (opt-in verbose mode)
+*   - --json: Standard introspection JSON (__schema format) via `introspectionFromSchema`
+*
+* Zero network calls — reads the committed vendored `schema.graphql` via
+* `getLinearSchema()` (lazy-cached in schema-loader.ts).
+*
+* Counts included in all modes:
+*   types_count = 1081 (user types, excluding __* introspection builtins)
+*   queries_count = 151
+*   mutations_count = 351
+*   subscriptions_count = 75
+*/
+/**
+* Returns type counts from the Linear GraphQL schema.
+* Excludes built-in `__*` introspection types.
+*/
+function getTypeCounts(schema) {
+	const typeMap = schema.getTypeMap();
+	return {
+		types_count: Object.values(typeMap).filter((t) => !t.name.startsWith("__")).length,
+		queries_count: Object.keys(schema.getQueryType()?.getFields() ?? {}).length,
+		mutations_count: Object.keys(schema.getMutationType()?.getFields() ?? {}).length,
+		subscriptions_count: Object.keys(schema.getSubscriptionType()?.getFields() ?? {}).length
+	};
+}
+/**
+* Returns the Linear schema as compact SDL (descriptions stripped) or with descriptions,
+* or as standard introspection JSON.
+*
+* This is the named runtime export used by tests and the oclif command shim.
+*
+* Returns `{ data }` only — the command shim wraps the result in the Phase 1
+* envelope via `runCommand`, which sets `meta.command` from the commandPath.
+* No `meta` is returned here on purpose: the runtime owns the data shape and
+* the kernel owns the envelope.
+*/
+async function schemaRuntime(args) {
+	const { flags } = args;
+	const schema = getLinearSchema();
+	const counts = getTypeCounts(schema);
+	if (flags.json) return { data: {
+		schema: introspectionFromSchema(schema, {
+			descriptions: flags.full ?? false,
+			specifiedByUrl: false,
+			directiveIsRepeatable: false,
+			schemaDescription: false
+		}),
+		...counts
+	} };
+	const printed = printSchema(schema);
+	return { data: {
+		schema: flags.full ? printed : printed.replace(/"""[\s\S]*?"""\n?/g, ""),
+		...counts
+	} };
+}
+//#endregion
+export { schemaRuntime };

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

@@ -0,0 +1,93 @@
+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 { TEAM_KEY_RE, UUID_RE } from "./filter-heuristics.js";
+//#region src/lib/state-list-runtime.ts
+async function stateListRuntime(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", "state");
+	const { first, after } = parsePagination({
+		...input.flags.limit !== void 0 ? { limit: input.flags.limit } : {},
+		...input.flags.cursor !== void 0 ? { cursor: input.flags.cursor } : {}
+	});
+	let filter;
+	if (input.flags.team !== void 0 && input.flags.team !== "") filter = buildTeamFilter(input.flags.team);
+	const client = (input.clientFactoryOverride ?? createLinearClient)(resolved);
+	return withFetchInterception(async () => {
+		const args = { first };
+		if (after !== void 0) args.after = after;
+		if (filter !== void 0) args.filter = filter;
+		const connection = await withRateLimitRetry(() => client.workflowStates(args), input.retryOptsOverride);
+		const projected = await Promise.all(connection.nodes.map(async (node) => {
+			return project(await hydrateForProjection(node, 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 } : {}
+			}
+		};
+	});
+}
+function buildTeamFilter(t) {
+	if (UUID_RE.test(t)) return { team: { id: { eq: t } } };
+	if (TEAM_KEY_RE.test(t)) return { team: { key: { eq: t.toUpperCase() } } };
+	return { team: { name: { eq: t } } };
+}
+const RELATION_KEYS = new Set(["team"]);
+async function hydrateForProjection(state, spec) {
+	const needs = neededRelations(spec);
+	if (needs.size === 0) {
+		const out = {};
+		for (const k of Object.keys(state)) if (!RELATION_KEYS.has(k)) out[k] = state[k];
+		return out;
+	}
+	const hydrated = {};
+	for (const k of Object.keys(state)) if (RELATION_KEYS.has(k)) {
+		if (needs.has(k)) {
+			const value = state[k];
+			hydrated[k] = await resolveLazy(value);
+		}
+	} else hydrated[k] = state[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 { stateListRuntime };