@rigkit/cli 0.2.5 → 0.2.7

package/README.md

@@ -5,9 +5,9 @@ Global `rig` CLI.
 ```bash
 npm i -g @rigkit/cli
 rig init
-rig run plan
+rig plan
 rig ls
-rig run plan github:owner/repo
+rig plan github:owner/repo
 ```
 
 `rig init` asks for a project name, Freestyle API key, and package manager. It creates a project folder containing a workflow-based `rig.config.ts`, `.env`, `.env.example`, `package.json`, and local ignore rules.
@@ -16,7 +16,7 @@ Interactive terminals use Inquirer prompts and a chalk/log-update run timeline.
 
 Interactive providers can ask the CLI to open provider-owned URLs. For example, Freestyle terminal sessions are served by the Freestyle provider, while the CLI only opens the presented URL in a browser.
 
-Workspace-specific operations run as `rig run <workspace>/<operation>`, for example `rig run website-workspace/open-cmux` or `rig run website-workspace/remove -y`.
+Workspace-specific operations run as `rig run <workspace> <operation>`, for example `rig run website-workspace open-cmux` or `rig run website-workspace remove -y`.
 
 `rig ls` lists workspaces for the selected project. `rig ls snapshots` lists cached snapshot runs, and `rig ls config` shows the resolved project paths.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "repository": {
     "type": "git",
@@ -25,9 +25,9 @@
     "log-symbols": "^7.0.1",
     "log-update": "^8.0.0",
     "ora": "^9.4.0",
-    "@rigkit/engine": "0.2.5",
-    "@rigkit/runtime-client": "0.2.5",
-    "@rigkit/provider-cmux": "0.2.5"
+    "@rigkit/provider-cmux": "0.2.7",
+    "@rigkit/runtime-client": "0.2.7",
+    "@rigkit/engine": "0.2.7"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/cli.test.ts

@@ -23,7 +23,8 @@ describe("CLI entrypoint", () => {
     expect(rootHelp.exitCode).toBe(0);
     expect(rootHelp.stderr).toBe("");
     expect(rootHelp.stdout).toContain("rig ");
-    expect(rootHelp.stdout).toContain("run         Run a project operation exposed by the runtime");
+    expect(rootHelp.stdout).toContain("plan        Plan project workflow changes");
+    expect(rootHelp.stdout).toContain("run         Run a workspace operation");
 
     const version = await runCli(["version"]);
     expect(version.exitCode).toBe(0);
@@ -34,7 +35,8 @@ describe("CLI entrypoint", () => {
     expect(help.exitCode).toBe(0);
     expect(help.stderr).toBe("");
     expect(help.stdout).toContain("rig ");
-    expect(help.stdout).toContain("run         Run a project operation exposed by the runtime");
+    expect(help.stdout).toContain("plan        Plan project workflow changes");
+    expect(help.stdout).toContain("run         Run a workspace operation");
   });
 
   test("rejects operation shorthand at the root", async () => {
@@ -110,7 +112,7 @@ describe("CLI entrypoint", () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-cli-create-name-"));
 
     await withWorkspaceRuntime({ projectDir }, async ({ env }) => {
-      const result = await runCli(["-C", projectDir, "run", "create", "--name", "some workspace", "--json"], { env });
+      const result = await runCli(["-C", projectDir, "create", "--name", "some workspace", "--json"], { env });
 
       expect(result.exitCode).toBe(1);
       expect(result.stdout).toBe("");
@@ -122,7 +124,7 @@ describe("CLI entrypoint", () => {
     const cwd = mkdtempSync(join(tmpdir(), "rigkit-cli-run-all-"));
 
     try {
-      const result = await runCli(["run", "plan", "--all", "--json"], { cwd });
+      const result = await runCli(["plan", "--all", "--json"], { cwd });
 
       expect(result.exitCode).toBe(1);
       expect(result.stdout).toBe("");
@@ -140,7 +142,7 @@ describe("CLI entrypoint", () => {
     writeFileSync(join(cwd, "web", "rig.config.ts"), "export default {}\n");
 
     try {
-      const result = await runCli(["run", "plan", "--discover", "--json"], { cwd });
+      const result = await runCli(["plan", "--discover", "--json"], { cwd });
 
       expect(result.exitCode).toBe(1);
       expect(result.stdout).toBe("");

package/src/cli.ts

@@ -36,6 +36,7 @@ import {
   resolveCompletionShell,
   type CompletionShell,
 } from "./completion.ts";
+import { generateWorkspaceName } from "./workspace-name.ts";
 
 type GlobalOptions = {
   project?: string;
@@ -196,22 +197,46 @@ async function runCli(argv: string[]): Promise<void> {
       });
     });
 
+  for (const operation of ["plan", "apply"] as const) {
+    program
+      .command(`${operation} [args...]`)
+      .description(operation === "plan" ? "Plan project workflow changes" : "Apply project workflow changes")
+      .allowUnknownOption(true)
+      .option("--all", "Run against every discovered project")
+      .option("--discover", "Discover projects below the selected directory")
+      .option("--json", "Print machine-readable JSON")
+      .action(async (args: string[], options: { all?: boolean; discover?: boolean; json?: boolean }) => {
+        await runProjectOperation(makeInvocation(rootOptions(program), options.json), operation, args ?? [], {
+          all: Boolean(options.all),
+          discover: Boolean(options.discover),
+        });
+      });
+  }
+
+  program
+    .command("create [args...]")
+    .description("Create a workspace")
+    .allowUnknownOption(true)
+    .option("--json", "Print machine-readable JSON")
+    .action(async (args: string[], options: { json?: boolean }) => {
+      await runProjectOperation(makeInvocation(rootOptions(program), options.json), "create", args ?? [], {
+        all: false,
+        discover: false,
+      });
+    });
+
   program
-    .command("run <operation> [args...]")
-    .description("Run a project operation exposed by the runtime")
+    .command("run <workspace> <operation> [args...]")
+    .description("Run a workspace operation")
     .allowUnknownOption(true)
-    .option("--all", "Run against every discovered project")
-    .option("--discover", "Discover projects below the selected directory")
     .option("--json", "Print machine-readable JSON")
     .action(async (
+      workspace: string,
       operation: string,
       args: string[],
-      options: { all?: boolean; discover?: boolean; json?: boolean },
+      options: { json?: boolean },
     ) => {
-      await runProjectOperation(makeInvocation(rootOptions(program), options.json), operation, args ?? [], {
-        all: Boolean(options.all),
-        discover: Boolean(options.discover),
-      });
+      await runWorkspaceOperation(makeInvocation(rootOptions(program), options.json), workspace, operation, args ?? []);
     });
 
   program
@@ -468,11 +493,12 @@ async function promptPackageManager(defaultValue: PackageManager): Promise<Packa
   return answers.packageManager;
 }
 
-async function promptWorkspaceName(): Promise<string> {
+async function promptWorkspaceName(defaultValue: string): Promise<string> {
   const answers = await inquirer.prompt<{ name: string }>([{
     type: "input",
     name: "name",
     message: "Workspace name:",
+    default: defaultValue,
     validate(value: string) {
       return validateWorkspaceName(value.trim());
     },
@@ -497,21 +523,11 @@ function assertValidWorkspaceName(value: unknown): void {
   if (valid !== true) throw new Error(`Invalid workspace name "${value}". ${valid}`);
 }
 
-async function promptWorkspaceOperation(
-  workspace: string,
-  operations: RuntimeOperationDefinition[],
-): Promise<string> {
-  const answers = await inquirer.prompt<{ operation: string }>([{
-    type: "select",
-    name: "operation",
-    message: `Operation for ${workspace}:`,
-    choices: operations.map((operation) => ({
-      name: operation.id,
-      value: operation.id,
-      description: operation.description || operation.title || "workspace operation",
-    })),
-  }]);
-  return answers.operation;
+async function defaultWorkspaceName(runtime: RuntimeClient): Promise<string> {
+  const existingNames = await runtime.control.workspaces()
+    .then((response) => response.workspaces.map((workspace) => workspace.name))
+    .catch(() => []);
+  return generateWorkspaceName(existingNames);
 }
 
 async function runPackageManagerInstall(
@@ -595,7 +611,7 @@ function printInitResult(result: InitProjectResult, install: InitInstallResult):
   if (install.skipped) {
     console.log(`  ${detectInstallCommand(result.packageJsonPath)}`);
   }
-  console.log("  rig run plan");
+  console.log("  rig plan");
 }
 
 function displayProjectDir(projectDir: string): string {
@@ -667,6 +683,47 @@ async function runProjectOperation(
   printInteractiveOutputGap(invocation);
 }
 
+async function runWorkspaceOperation(
+  invocation: CliInvocation,
+  workspaceName: string,
+  requestedOperation: string,
+  args: string[],
+): Promise<void> {
+  const runtime = await loadRuntime(invocation);
+  const manifest = await readRuntimeOperations(runtime);
+  const operation = (manifest.workspaceOperations ?? []).find((item) =>
+    item.id === requestedOperation || item.aliases?.includes(requestedOperation)
+  );
+  if (!operation) {
+    throw new Error(`This project does not define a workspace operation named "${requestedOperation}".`);
+  }
+
+  const workspaces = await runtime.control.workspaces()
+    .then((response) => response.workspaces as WorkspaceRecord[])
+    .catch(() => []);
+  if (!workspaces.some((workspace) => workspace.name === workspaceName)) {
+    throw new Error(`This project does not have a workspace named "${workspaceName}".`);
+  }
+
+  const parsed = parseOperationArgs(operation, args);
+  enforceHostOnlyBooleanGuards(operation, parsed);
+
+  const result = await runRuntimeOperation<unknown>(
+    runtime,
+    `${workspaceName}/${operation.id}`,
+    parsed.input,
+    { renderEvents: !wantsJson(invocation) },
+  );
+
+  if (wantsJson(invocation)) {
+    printJson(result);
+    return;
+  }
+
+  await renderOperationResult(operation, result, parsed.hostOptions);
+  printInteractiveOutputGap(invocation);
+}
+
 async function runDiscoveredProjectOperation(
   invocation: CliInvocation,
   requestedOperation: string,
@@ -791,13 +848,13 @@ async function executeRuntimeOperation(
   result: unknown;
 }> {
   const manifest = await readRuntimeOperations(runtime);
-  const resolved = await resolveRequestedRuntimeOperation(invocation, runtime, manifest, requestedOperation);
+  const resolved = findRuntimeOperation(manifest, requestedOperation);
   if (!resolved) {
     throw new Error(`This project does not define a Rigkit operation named "${requestedOperation}".`);
   }
   const { operation, runOperation } = resolved;
 
-  const parsed = await parseOperationArgsWithPrompts(invocation, operation, args);
+  const parsed = await parseOperationArgsWithPrompts(invocation, runtime, operation, args);
   enforceHostOnlyBooleanGuards(operation, parsed);
 
   const result = await runRuntimeOperation<unknown>(
@@ -810,55 +867,19 @@ async function executeRuntimeOperation(
   return { operation, parsed, result };
 }
 
-async function resolveRequestedRuntimeOperation(
-  invocation: CliInvocation,
-  runtime: RuntimeClient,
-  manifest: RuntimeOperationManifest,
-  requestedOperation: string,
-): Promise<{ operation: RuntimeOperationDefinition; runOperation: string } | undefined> {
-  const resolved = findRuntimeOperation(manifest, requestedOperation);
-  if (resolved) return resolved;
-
-  if (requestedOperation.includes("/") || wantsJson(invocation) || !canPrompt()) return undefined;
-
-  const workspaces = await runtime.control.workspaces()
-    .then((response) => response.workspaces as WorkspaceRecord[])
-    .catch(() => []);
-  const workspace = workspaces.find((item) => item.name === requestedOperation);
-  if (!workspace || (manifest.workspaceOperations ?? []).length === 0) return undefined;
-
-  const operationId = await promptWorkspaceOperation(workspace.name, manifest.workspaceOperations ?? []);
-  const operation = (manifest.workspaceOperations ?? []).find((item) => item.id === operationId);
-  return operation ? { operation, runOperation: `${workspace.name}/${operation.id}` } : undefined;
-}
-
 function findRuntimeOperation(
   manifest: RuntimeOperationManifest,
   requestedOperation: string,
 ): { operation: RuntimeOperationDefinition; runOperation: string } | undefined {
-  const workspaceOperation = parseWorkspaceOperationId(requestedOperation);
-  if (workspaceOperation) {
-    const operation = (manifest.workspaceOperations ?? []).find((item) => item.id === workspaceOperation.operation);
-    return operation ? { operation, runOperation: requestedOperation } : undefined;
-  }
-
   const operation = manifest.operations.find((operation) =>
     operation.id === requestedOperation || operation.aliases?.includes(requestedOperation)
   );
   return operation ? { operation, runOperation: operation.id } : undefined;
 }
 
-function parseWorkspaceOperationId(value: string): { workspace: string; operation: string } | undefined {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) return undefined;
-  return {
-    workspace: value.slice(0, slash),
-    operation: value.slice(slash + 1),
-  };
-}
-
 async function parseOperationArgsWithPrompts(
   invocation: CliInvocation,
+  runtime: RuntimeClient,
   operation: RuntimeOperationDefinition,
   args: string[],
 ): Promise<ParsedOperationInput> {
@@ -872,7 +893,7 @@ async function parseOperationArgsWithPrompts(
     !wantsJson(invocation) &&
     canPrompt()
   ) {
-    parsed.input.name = await promptWorkspaceName();
+    parsed.input.name = await promptWorkspaceName(await defaultWorkspaceName(runtime));
   }
   if (operation.createsWorkspace && parsed.input.name !== undefined) {
     assertValidWorkspaceName(parsed.input.name);
@@ -1148,7 +1169,10 @@ async function runHelp(invocation: CliInvocation): Promise<void> {
       commands: [
         { name: "help", description: "Show Rigkit CLI help" },
         { name: "init", description: "Initialize a Rigkit project" },
-        { name: "run", description: "Run a project operation exposed by the runtime" },
+        { name: "plan", description: "Plan project workflow changes" },
+        { name: "apply", description: "Apply project workflow changes" },
+        { name: "create", description: "Create a workspace" },
+        { name: "run", description: "Run a workspace operation" },
         { name: "ls", description: "List project workspaces" },
         { name: "projects", description: "Discover Rigkit projects below the current directory" },
         { name: "doctor", description: "Show Rigkit runtime diagnostics" },
@@ -1167,7 +1191,10 @@ async function runHelp(invocation: CliInvocation): Promise<void> {
     "Commands:",
     "  help        Show Rigkit CLI help",
     "  init        Initialize a Rigkit project",
-    "  run         Run a project operation exposed by the runtime",
+    "  plan        Plan project workflow changes",
+    "  apply       Apply project workflow changes",
+    "  create      Create a workspace",
+    "  run         Run a workspace operation",
     "  ls          List project workspaces",
     "  projects    Discover Rigkit projects below the current directory",
     "  doctor      Show Rigkit runtime diagnostics",

package/src/completion.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { projectIdFor, runtimeFingerprintFor, runtimePaths, SUPPORTED_RUNTIME_API_VERSION } from "@rigkit/runtime-client";
-import { completeRig, formatCompletionItems, renderCompletionScript } from "./completion.ts";
+import { completeRig, formatCompletionItems, formatWorkspaceAge, renderCompletionScript } from "./completion.ts";
 
 describe("CLI completion", () => {
   test("completes workspace targets from the runtime", async () => {
@@ -11,12 +11,12 @@ describe("CLI completion", () => {
     await withWorkspaceRuntime({ projectDir }, async () => {
       const items = await completeRig({
         cwd: projectDir,
-        words: ["rig", "run", "ssh", ""],
-        currentIndex: 3,
+        words: ["rig", "run", ""],
+        currentIndex: 2,
       });
 
       expect(items.map((item) => item.value)).toEqual(["api", "web"]);
-      expect(items[0]?.description).toBe("smoke");
+      expect(items[0]?.description).toBe("created 2h ago");
     });
   });
 
@@ -25,8 +25,8 @@ describe("CLI completion", () => {
     await withWorkspaceRuntime({ projectDir }, async () => {
       const items = await completeRig({
         cwd: projectDir,
-        words: ["rig", "run", "ssh", "vm-"],
-        currentIndex: 3,
+        words: ["rig", "run", "vm-"],
+        currentIndex: 2,
       });
 
       expect(items).toEqual([]);
@@ -39,8 +39,8 @@ describe("CLI completion", () => {
     await withWorkspaceRuntime({ projectDir, cleanupDir: parentDir }, async () => {
       const items = await completeRig({
         cwd: parentDir,
-        words: ["rig", "-C", "project", "run", "ssh", ""],
-        currentIndex: 5,
+        words: ["rig", "-C", "project", "run", ""],
+        currentIndex: 4,
       });
 
       expect(items.map((item) => item.value)).toEqual(["api", "web"]);
@@ -55,42 +55,42 @@ describe("CLI completion", () => {
         words: ["rig", "run", ""],
         currentIndex: 2,
       });
-      expect(roots.map((item) => item.value)).toContain("api");
-      expect(roots.map((item) => item.value)).toContain("ssh");
+      expect(roots.map((item) => item.value)).toEqual(["api", "web"]);
+      expect(roots[0]).toMatchObject({ description: "created 2h ago" });
 
       const exactWorkspace = await completeRig({
         cwd: projectDir,
         words: ["rig", "run", "api"],
         currentIndex: 2,
       });
-      expect(exactWorkspace.map((item) => item.value)).toEqual(["api/remove", "api/open-cmux"]);
+      expect(exactWorkspace.map((item) => item.value)).toEqual(["api"]);
 
       const workspaceAfterSpace = await completeRig({
         cwd: projectDir,
         words: ["rig", "run", "api", ""],
         currentIndex: 3,
       });
-      expect(workspaceAfterSpace.map((item) => item.value)).toEqual(["api/remove", "api/open-cmux"]);
+      expect(workspaceAfterSpace.map((item) => item.value)).toEqual(["remove", "open-cmux"]);
 
-      const slashWorkspace = await completeRig({
+      const operationPrefix = await completeRig({
         cwd: projectDir,
-        words: ["rig", "run", "api/"],
-        currentIndex: 2,
+        words: ["rig", "run", "api", "open"],
+        currentIndex: 3,
       });
-      expect(slashWorkspace.map((item) => item.value)).toEqual(["api/remove", "api/open-cmux"]);
+      expect(operationPrefix.map((item) => item.value)).toEqual(["open-cmux"]);
     });
   });
 
-  test("does not complete runtime operations at the root command position", async () => {
+  test("completes top-level project commands at the root command position", async () => {
     const projectDir = mkdtempSync(join(tmpdir(), "rigkit-completion-"));
     await withWorkspaceRuntime({ projectDir }, async () => {
       const items = await completeRig({
         cwd: projectDir,
-        words: ["rig", "s"],
+        words: ["rig", "p"],
         currentIndex: 1,
       });
 
-      expect(items.map((item) => item.value)).not.toContain("ssh");
+      expect(items.map((item) => item.value)).toEqual(["plan", "projects"]);
     });
   });
 
@@ -102,7 +102,20 @@ describe("CLI completion", () => {
     expect(formatCompletionItems([{ value: "api", description: "workspace smoke", noSpace: true }], "zsh"))
       .toBe("api\tworkspace smoke\tnospace");
     expect(renderCompletionScript("zsh")).toContain("rig __complete");
-    expect(renderCompletionScript("zsh")).toContain("compadd -S ''");
+    expect(renderCompletionScript("zsh")).toContain("compadd -ld displays -a values");
+    expect(renderCompletionScript("zsh")).toContain("compadd -S '' -ld nospace_displays -a nospace_values");
+    expect(renderCompletionScript("zsh")).toContain('display="${value} -- ${description}"');
+    expect(renderCompletionScript("zsh")).not.toContain("_describe");
+  });
+
+  test("formats workspace ages", () => {
+    const now = Date.parse("2026-05-14T12:00:00.000Z");
+
+    expect(formatWorkspaceAge("2026-05-14T11:59:45.000Z", now)).toBe("just now");
+    expect(formatWorkspaceAge("2026-05-14T11:30:00.000Z", now)).toBe("30m ago");
+    expect(formatWorkspaceAge("2026-05-14T09:00:00.000Z", now)).toBe("3h ago");
+    expect(formatWorkspaceAge("2026-05-11T12:00:00.000Z", now)).toBe("3d ago");
+    expect(formatWorkspaceAge("not-a-date", now)).toBeUndefined();
   });
 
   test("completes ls targets", async () => {
@@ -154,7 +167,10 @@ async function withWorkspaceRuntime(
         });
       }
       if (pathname === "/workspaces") {
-        const now = new Date(0).toISOString();
+        const nowMs = Date.now();
+        const apiCreatedAt = new Date(nowMs - 2 * 60 * 60 * 1000).toISOString();
+        const webCreatedAt = new Date(nowMs - 5 * 60 * 1000).toISOString();
+        const updatedAt = new Date(nowMs).toISOString();
         return runtimeJson({
           workspaces: [
             {
@@ -162,16 +178,16 @@ async function withWorkspaceRuntime(
               name: "api",
               workflow: "smoke",
               ctx: {},
-              createdAt: now,
-              updatedAt: now,
+              createdAt: apiCreatedAt,
+              updatedAt,
             },
             {
               id: "workspace-web",
               name: "web",
               workflow: "smoke",
               ctx: {},
-              createdAt: now,
-              updatedAt: now,
+              createdAt: webCreatedAt,
+              updatedAt,
             },
           ],
         });

package/src/completion.ts

@@ -18,7 +18,10 @@ type CompleteRigInput = {
 const COMMANDS: CompletionItem[] = [
   { value: "help", description: "show CLI help" },
   { value: "init", description: "initialize a Rigkit project" },
-  { value: "run", description: "run a project operation" },
+  { value: "plan", description: "plan project workflow changes" },
+  { value: "apply", description: "apply project workflow changes" },
+  { value: "create", description: "create a workspace" },
+  { value: "run", description: "run a workspace operation" },
   { value: "ls", description: "list project workspaces" },
   { value: "projects", description: "discover Rigkit projects" },
   { value: "doctor", description: "show runtime diagnostics" },
@@ -46,11 +49,22 @@ const COMMAND_OPTIONS: Record<string, CompletionItem[]> = {
     { value: "--force", description: "overwrite existing config" },
     { value: "--json", description: "print JSON" },
   ],
-  operation: [
+  plan: [
     { value: "--all", description: "run against every discovered project" },
     { value: "--discover", description: "discover projects below the selected directory" },
     { value: "--json", description: "print JSON" },
   ],
+  apply: [
+    { value: "--all", description: "run against every discovered project" },
+    { value: "--discover", description: "discover projects below the selected directory" },
+    { value: "--json", description: "print JSON" },
+  ],
+  create: [
+    { value: "--json", description: "print JSON" },
+  ],
+  run: [
+    { value: "--json", description: "print JSON" },
+  ],
   ls: [
     { value: "workspaces", description: "list workspaces" },
     { value: "snapshots", description: "list snapshots" },
@@ -67,6 +81,8 @@ const COMMAND_OPTIONS: Record<string, CompletionItem[]> = {
   ],
 };
 
+const PROJECT_OPERATION_COMMANDS = new Set(["plan", "apply", "create"]);
+
 const OPTIONS_WITH_VALUES = new Set([
   "-C",
   "--project",
@@ -92,6 +108,13 @@ type RuntimeOperationDefinition = {
   };
 };
 
+type RuntimeWorkspaceCompletion = {
+  name: string;
+  workflow: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
 export async function completeRig(input: CompleteRigInput): Promise<CompletionItem[]> {
   const cwd = input.cwd ?? process.cwd();
   const words = input.words.length > 0 ? input.words : ["rig"];
@@ -113,38 +136,39 @@ export async function completeRig(input: CompleteRigInput): Promise<CompletionIt
 
   if (current.startsWith("-")) {
     if (command === "run") {
-      const run = parseRunCommand(before);
-      if (run.operation) {
-        const operation = await safeResolveRuntimeOperation(resolveProjectDir(words, cwd), run.operation);
+      const run = parseWorkspaceRunCommand(before);
+      if (run.workspace && run.operation) {
+        const operation = await safeResolveWorkspaceOperation(resolveProjectDir(words, cwd), run.operation);
         return filterItems([
           ...(operation?.cli?.options ?? []).flatMap((option) => [
             { value: option.flag, description: option.name },
             ...(option.aliases ?? []).map((alias) => ({ value: alias, description: option.name })),
           ]),
-          ...COMMAND_OPTIONS.operation,
+          ...COMMAND_OPTIONS.run,
           ...GLOBAL_OPTIONS,
         ], current);
       }
     }
+    if (PROJECT_OPERATION_COMMANDS.has(command)) {
+      const operation = await safeResolveRuntimeOperation(resolveProjectDir(words, cwd), command);
+      return filterItems([
+        ...(operation?.cli?.options ?? []).flatMap((option) => [
+          { value: option.flag, description: option.name },
+          ...(option.aliases ?? []).map((alias) => ({ value: alias, description: option.name })),
+        ]),
+        ...(COMMAND_OPTIONS[command] ?? []),
+        ...GLOBAL_OPTIONS,
+      ], current);
+    }
     return filterItems([...(COMMAND_OPTIONS[command] ?? []), ...GLOBAL_OPTIONS], current);
   }
 
   const positionalCount = countPositionals(before, command);
 
   if (command === "run") {
-    const run = parseRunCommand(before);
-    if (!run.operation) {
-      return filterItems(await safeOperationTargets(resolveProjectDir(words, cwd), current), current);
-    }
-    const operation = await safeResolveRuntimeOperation(resolveProjectDir(words, cwd), run.operation);
-    if (!operation && run.args.length === 0) {
-      return filterItems(await safeWorkspaceOperationTargets(resolveProjectDir(words, cwd), run.operation), current);
-    }
-    const operationPositionalCount = countRunOperationPositionals(run.args);
-    const positional = operation?.cli?.positionals?.find((item) => item.index === operationPositionalCount);
-    if (positional && /workspace|vm/i.test(positional.name)) {
-      return filterItems(await workspaceTargets(resolveProjectDir(words, cwd), current, /vm/i.test(positional.name)), current);
-    }
+    const run = parseWorkspaceRunCommand(before);
+    if (!run.workspace) return filterItems(await workspaceTargets(resolveProjectDir(words, cwd)), current);
+    if (!run.operation) return filterItems(await safeWorkspaceOperationTargets(resolveProjectDir(words, cwd)), current);
   }
 
   if (command === "completion" && positionalCount === 0) {
@@ -206,8 +230,8 @@ complete -c rig -f -a "(__rig_complete)"
 return `#compdef rig
 # rig zsh completion
 _rig() {
-  local -a raw values descriptions nospace_values nospace_descriptions
-  local line value description rest marker
+  local -a raw values displays nospace_values nospace_displays
+  local line value description rest marker display
   raw=("\${(@f)$(command rig __complete --shell zsh --index $((CURRENT - 1)) -- "\${words[@]}" 2>/dev/null)}")
   for line in "\${raw[@]}"; do
     value="\${line%%$'\\t'*}"
@@ -220,16 +244,20 @@ _rig() {
         marker="\${rest#*$'\\t'}"
       fi
     fi
+    display="\${value}"
+    if [[ -n "$description" ]]; then
+      display="\${value} -- \${description}"
+    fi
     if [[ "$marker" == "nospace" ]]; then
       nospace_values+=("\${value}")
-      nospace_descriptions+=("\${description}")
+      nospace_displays+=("\${display}")
     else
       values+=("\${value}")
-      descriptions+=("\${description}")
+      displays+=("\${display}")
     fi
   done
-  (( \${#nospace_values} )) && compadd -S '' -d nospace_descriptions -a nospace_values
-  (( \${#values} )) && compadd -d descriptions -a values
+  (( \${#nospace_values} )) && compadd -S '' -ld nospace_displays -a nospace_values
+  (( \${#values} )) && compadd -ld displays -a values
 }
 compdef _rig rig
 `;
@@ -275,7 +303,7 @@ function countPositionals(words: string[], command: string): number {
   return count;
 }
 
-function parseRunCommand(words: string[]): { operation?: string; args: string[] } {
+function parseWorkspaceRunCommand(words: string[]): { workspace?: string; operation?: string; args: string[] } {
   let foundRun = false;
   const args: string[] = [];
   for (let index = 0; index < words.length; index += 1) {
@@ -292,22 +320,7 @@ function parseRunCommand(words: string[]): { operation?: string; args: string[]
     }
     args.push(word);
   }
-  return { operation: args[0], args: args.slice(1) };
-}
-
-function countRunOperationPositionals(args: string[]): number {
-  let count = 0;
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index]!;
-    if (OPTIONS_WITH_VALUES.has(arg)) {
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--") && arg.includes("=")) continue;
-    if (arg.startsWith("-")) continue;
-    count += 1;
-  }
-  return count;
+  return { workspace: args[0], operation: args[1], args: args.slice(2) };
 }
 
 function expectsOptionValue(words: string[]): boolean {
@@ -344,112 +357,85 @@ function projectPaths(projectDir: string): { projectDir: string; configPath: str
 
 async function workspaceTargets(
   paths: { projectDir: string; configPath: string },
-  _current: string,
-  _includeVmIds: boolean,
 ): Promise<CompletionItem[]> {
   const workspaces = await readWorkspaces(paths);
   const items = workspaces.map((workspace) => ({
     value: workspace.name,
-    description: workspace.workflow,
+    description: workspaceDescription(workspace),
   }));
 
   return dedupeItems(items);
 }
 
-async function readWorkspaces(paths: { projectDir: string; configPath: string }): Promise<Array<{ name: string; workflow: string }>> {
+async function readWorkspaces(paths: { projectDir: string; configPath: string }): Promise<RuntimeWorkspaceCompletion[]> {
   const runtime = await getOrStartRuntime(paths);
   const { workspaces } = await runtime.control.workspaces();
   return workspaces.map((workspace) => ({
     name: workspace.name,
     workflow: workspace.workflow,
+    createdAt: workspace.createdAt,
+    updatedAt: workspace.updatedAt,
   }));
 }
 
-async function operationTargets(
-  paths: { projectDir: string; configPath: string },
-  current: string,
-): Promise<CompletionItem[]> {
-  const manifest = await readOperations(paths);
-  if (current.includes("/")) {
-    return workspaceOperationTargets(manifest, current);
-  }
-  const workspaces = await readWorkspaces(paths).catch(() => []);
-  if (workspaces.some((workspace) => workspace.name === current)) {
-    return workspaceOperationTargets(manifest, `${current}/`);
-  }
-  return manifest.operations.flatMap((operation) => [
-    { value: operation.id, description: operation.description },
-    ...(operation.aliases ?? []).map((alias) => ({ value: alias, description: operation.description })),
-  ]).concat(workspaces.map((workspace) => ({
-    value: workspace.name,
-    description: `workspace ${workspace.workflow}`,
-    noSpace: true,
-  })));
-}
-
 async function safeWorkspaceOperationTargets(
   paths: { projectDir: string; configPath: string },
-  workspace: string,
 ): Promise<CompletionItem[]> {
   try {
-    const [manifest, workspaces] = await Promise.all([
-      readOperations(paths),
-      readWorkspaces(paths),
-    ]);
-    if (!workspaces.some((item) => item.name === workspace)) return [];
-    return workspaceOperationTargets(manifest, `${workspace}/`);
+    const manifest = await readOperations(paths);
+    return workspaceOperationTargets(manifest);
   } catch {
     return [];
   }
 }
 
-function workspaceOperationTargets(manifest: RuntimeOperationManifest, current: string): CompletionItem[] {
-  const slash = current.indexOf("/");
-  if (slash < 0) return [];
-  const workspace = current.slice(0, slash);
-  if (!workspace) return [];
+function workspaceOperationTargets(manifest: RuntimeOperationManifest): CompletionItem[] {
   return (manifest.workspaceOperations ?? []).flatMap((operation) => [
-    { value: `${workspace}/${operation.id}`, description: operation.description ?? "workspace operation" },
+    { value: operation.id, description: operation.description ?? "workspace operation" },
     ...(operation.aliases ?? []).map((alias) => ({
-      value: `${workspace}/${alias}`,
+      value: alias,
       description: operation.description ?? "workspace operation",
     })),
   ]);
 }
 
-async function safeOperationTargets(
+async function resolveRuntimeOperation(
   paths: { projectDir: string; configPath: string },
-  current: string,
-): Promise<CompletionItem[]> {
+  operationId: string,
+): Promise<RuntimeOperationDefinition | undefined> {
+  const manifest = await readOperations(paths);
+  return manifest.operations.find((operation) =>
+    operation.id === operationId || operation.aliases?.includes(operationId)
+  );
+}
+
+async function safeResolveRuntimeOperation(
+  paths: { projectDir: string; configPath: string },
+  operationId: string,
+): Promise<RuntimeOperationDefinition | undefined> {
   try {
-    return await operationTargets(paths, current);
+    return await resolveRuntimeOperation(paths, operationId);
   } catch {
-    return [];
+    return undefined;
   }
 }
 
-async function resolveRuntimeOperation(
+async function resolveWorkspaceOperation(
   paths: { projectDir: string; configPath: string },
   operationId: string,
 ): Promise<RuntimeOperationDefinition | undefined> {
   const manifest = await readOperations(paths);
-  const workspaceOperation = parseWorkspaceOperationId(operationId);
-  if (workspaceOperation) {
-    return (manifest.workspaceOperations ?? []).find((operation) =>
-      operation.id === workspaceOperation.operation || operation.aliases?.includes(workspaceOperation.operation)
-    );
-  }
-  return manifest.operations.find((operation) =>
+  return (manifest.workspaceOperations ?? []).find((operation) =>
     operation.id === operationId || operation.aliases?.includes(operationId)
   );
 }
 
-async function safeResolveRuntimeOperation(
+async function safeResolveWorkspaceOperation(
   paths: { projectDir: string; configPath: string },
   operationId: string,
 ): Promise<RuntimeOperationDefinition | undefined> {
   try {
-    return await resolveRuntimeOperation(paths, operationId);
+    return await resolveWorkspaceOperation(paths, operationId);
   } catch {
     return undefined;
   }
@@ -460,15 +446,6 @@ async function readOperations(paths: { projectDir: string; configPath: string })
   return await runtime.control.operations() as unknown as RuntimeOperationManifest;
 }
 
-function parseWorkspaceOperationId(value: string): { workspace: string; operation: string } | undefined {
-  const slash = value.indexOf("/");
-  if (slash <= 0 || slash === value.length - 1) return undefined;
-  return {
-    workspace: value.slice(0, slash),
-    operation: value.slice(slash + 1),
-  };
-}
-
 function filterItems(items: CompletionItem[], current: string): CompletionItem[] {
   return dedupeItems(items).filter((item) => item.value.startsWith(current));
 }
@@ -483,3 +460,30 @@ function dedupeItems(items: CompletionItem[]): CompletionItem[] {
   }
   return deduped;
 }
+
+function workspaceDescription(workspace: RuntimeWorkspaceCompletion): string {
+  const age = formatWorkspaceAge(workspace.createdAt);
+  return age ? `created ${age}` : "created date unknown";
+}
+
+export function formatWorkspaceAge(createdAt: string, nowMs = Date.now()): string | undefined {
+  const createdAtMs = Date.parse(createdAt);
+  if (!Number.isFinite(createdAtMs)) return undefined;
+
+  const elapsedSeconds = Math.max(0, Math.floor((nowMs - createdAtMs) / 1000));
+  if (elapsedSeconds < 60) return "just now";
+
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  if (elapsedMinutes < 60) return `${elapsedMinutes}m ago`;
+
+  const elapsedHours = Math.floor(elapsedMinutes / 60);
+  if (elapsedHours < 48) return `${elapsedHours}h ago`;
+
+  const elapsedDays = Math.floor(elapsedHours / 24);
+  if (elapsedDays < 30) return `${elapsedDays}d ago`;
+
+  const elapsedMonths = Math.floor(elapsedDays / 30);
+  if (elapsedMonths < 24) return `${elapsedMonths}mo ago`;
+
+  return `${Math.floor(elapsedMonths / 12)}y ago`;
+}

package/src/init.test.ts

@@ -42,8 +42,8 @@ describe("initProject", () => {
 
     const pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8"));
     expect(pkg.name).toBe("platform-api");
-    expect(pkg.scripts.plan).toBe("rig run plan");
-    expect(pkg.scripts.apply).toBe("rig run apply");
+    expect(pkg.scripts.plan).toBe("rig plan");
+    expect(pkg.scripts.apply).toBe("rig apply");
     expect(pkg.devDependencies[PROJECT_PACKAGE_NAME]).toBe(RIGKIT_CLI_VERSION);
     expect(pkg.devDependencies[FREESTYLE_PROVIDER_PACKAGE_NAME]).toBe(RIGKIT_CLI_VERSION);
     expect(pkg.devDependencies[FREESTYLE_SDK_PACKAGE_NAME]).toBe(FREESTYLE_SDK_PACKAGE_VERSION);
@@ -74,7 +74,7 @@ describe("initProject", () => {
     const pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8"));
     expect(pkg.name).toBe("existing");
     expect(pkg.scripts.test).toBe("bun test");
-    expect(pkg.scripts.plan).toBe("rig run plan");
+    expect(pkg.scripts.plan).toBe("rig plan");
   });
 });
 

package/src/init.ts

@@ -229,7 +229,7 @@ function ensureProjectPackageJson(
   }
 
   const scripts = pkg.scripts as Record<string, string>;
-  for (const [key, value] of Object.entries({ plan: "rig run plan", apply: "rig run apply" })) {
+  for (const [key, value] of Object.entries({ plan: "rig plan", apply: "rig apply" })) {
     if (scripts[key] !== value) {
       scripts[key] = value;
       updated = true;

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_CLI_VERSION = "0.2.5";
+export const RIGKIT_CLI_VERSION = "0.2.7";

package/src/workspace-name.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "bun:test";
+import { generateWorkspaceName } from "./workspace-name.ts";
+
+describe("workspace name defaults", () => {
+  test("generates shell-safe adjective noun names", () => {
+    expect(generateWorkspaceName([], () => 0)).toBe("snowy-ridge");
+  });
+
+  test("skips generated names that already exist", () => {
+    const randomValues = [0, 0, 0.5, 0.5];
+    let index = 0;
+    const name = generateWorkspaceName(["snowy-ridge"], () => randomValues[index++] ?? 0.5);
+
+    expect(name).not.toBe("snowy-ridge");
+    expect(name).toMatch(/^(?!-)[A-Za-z0-9._-]+$/);
+  });
+});

package/src/workspace-name.ts

@@ -0,0 +1,59 @@
+const adjectives = [
+  "snowy",
+  "bright",
+  "quiet",
+  "rapid",
+  "silver",
+  "clear",
+  "steady",
+  "bold",
+  "lucky",
+  "fresh",
+  "golden",
+  "nimble",
+  "calm",
+  "brisk",
+  "sharp",
+  "sunny",
+] as const;
+
+const nouns = [
+  "ridge",
+  "harbor",
+  "signal",
+  "orbit",
+  "bridge",
+  "summit",
+  "field",
+  "grove",
+  "spark",
+  "stone",
+  "valley",
+  "meadow",
+  "trail",
+  "cove",
+  "anchor",
+  "beacon",
+] as const;
+
+export function generateWorkspaceName(
+  existingNames: Iterable<string> = [],
+  random: () => number = Math.random,
+): string {
+  const existing = new Set(existingNames);
+
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const name = `${pick(adjectives, random)}-${pick(nouns, random)}`;
+    if (!existing.has(name)) return name;
+  }
+
+  return `workspace-${Date.now().toString(36)}-${Math.floor(random() * 10000).toString(36)}`;
+}
+
+function pick<const Values extends readonly string[]>(
+  values: Values,
+  random: () => number,
+): Values[number] {
+  const index = Math.min(values.length - 1, Math.floor(random() * values.length));
+  return values[index]!;
+}