[codex] Add workspace routine run tab (#4958)

## Thinking Path

> - Paperclip orchestrates AI agents through reusable execution
workspaces and routines
> - Operators need a fast way to run workspace-aware routines against a
specific execution workspace
> - The existing workspace detail surface showed configuration, runtime
logs, and linked issues, but not routines that depend on workspace
variables
> - Routine runs also needed to prefill the selected execution workspace
so branch variables resolve correctly
> - This pull request adds a workspace routines tab and prefilled
routine-run dialog support
> - The benefit is a tighter workflow for rerunning reviews, smoke
checks, and other workspace-specific routines

## What Changed

- Added an execution workspace `Routines` tab and company-prefixed
routes.
- Listed routines that declare or reference workspace-specific
variables.
- Added `Run now` support that preselects the current execution
workspace in `RoutineRunVariablesDialog`.
- Centralized reusable execution workspace ordering/deduplication for
issue creation and workspace cards.
- Added focused UI helper and dialog regression tests.

## Verification

- `pnpm exec vitest run ui/src/lib/reusable-execution-workspaces.test.ts
ui/src/lib/workspace-routines.test.ts
ui/src/components/RoutineRunVariablesDialog.test.tsx
ui/src/lib/company-routes.test.ts`
- Screenshots were not captured in this PR split; the visible flow is
covered by focused component/helper tests and should get browser QA in
the follow-up issue.

## Risks

- Medium risk: this adds a new workspace detail tab and routine-run
path. It is isolated to workspace-scoped routines and uses existing
routine run APIs.

> For core feature work, check [`ROADMAP.md`](ROADMAP.md) first and
discuss it in `#dev` before opening the PR. Feature PRs that overlap
with planned core work may need to be redirected — check the roadmap
first. See `CONTRIBUTING.md`.

## Model Used

- OpenAI Codex, GPT-5 coding agent, tool use and local command
execution. Exact context window was not exposed in the runtime.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [ ] If this change affects the UI, I have included before/after
screenshots
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Paperclip <noreply@paperclip.ing>

ui/src/lib/company-routes.test.ts

@@ -9,15 +9,22 @@ import {
 describe("company routes", () => {
   it("treats execution workspace paths as board routes that need a company prefix", () => {
     expect(isBoardPathWithoutPrefix("/execution-workspaces/workspace-123")).toBe(true);
+    expect(isBoardPathWithoutPrefix("/execution-workspaces/workspace-123/routines")).toBe(true);
     expect(extractCompanyPrefixFromPath("/execution-workspaces/workspace-123")).toBeNull();
     expect(applyCompanyPrefix("/execution-workspaces/workspace-123", "PAP")).toBe(
       "/PAP/execution-workspaces/workspace-123",
     );
+    expect(applyCompanyPrefix("/execution-workspaces/workspace-123/routines", "PAP")).toBe(
+      "/PAP/execution-workspaces/workspace-123/routines",
+    );
   });
 
   it("normalizes prefixed execution workspace paths back to company-relative paths", () => {
     expect(toCompanyRelativePath("/PAP/execution-workspaces/workspace-123")).toBe(
       "/execution-workspaces/workspace-123",
     );
+    expect(toCompanyRelativePath("/PAP/execution-workspaces/workspace-123/routines")).toBe(
+      "/execution-workspaces/workspace-123/routines",
+    );
   });
 });

ui/src/lib/queryKeys.ts

@@ -64,7 +64,8 @@ export const queryKeys = {
     workProducts: (issueId: string) => ["issues", "work-products", issueId] as const,
   },
   routines: {
-    list: (companyId: string) => ["routines", companyId] as const,
+    list: (companyId: string, filters?: { projectId?: string | null }) =>
+      ["routines", companyId, filters?.projectId ?? "__all-projects__"] as const,
     detail: (id: string) => ["routines", "detail", id] as const,
     runs: (id: string) => ["routines", "runs", id] as const,
     activity: (companyId: string, id: string) => ["routines", "activity", companyId, id] as const,

ui/src/lib/reusable-execution-workspaces.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from "vitest";
+import { orderReusableExecutionWorkspaces, type ReusableExecutionWorkspaceLike } from "./reusable-execution-workspaces";
+
+function workspace(overrides: Partial<ReusableExecutionWorkspaceLike>): ReusableExecutionWorkspaceLike {
+  return {
+    id: overrides.id ?? "workspace-id",
+    name: overrides.name ?? "Workspace",
+    cwd: overrides.cwd ?? null,
+    lastUsedAt: overrides.lastUsedAt ?? "2026-01-01T00:00:00.000Z",
+  };
+}
+
+describe("orderReusableExecutionWorkspaces", () => {
+  it("puts the most recently used workspace first and sorts the rest alphabetically", () => {
+    const workspaces = [
+      workspace({ id: "charlie", name: "Charlie", lastUsedAt: "2026-01-03T00:00:00.000Z" }),
+      workspace({ id: "zulu", name: "Zulu", lastUsedAt: "2026-01-05T00:00:00.000Z" }),
+      workspace({ id: "alpha", name: "Alpha", lastUsedAt: "2026-01-01T00:00:00.000Z" }),
+      workspace({ id: "bravo", name: "Bravo", lastUsedAt: "2026-01-04T00:00:00.000Z" }),
+    ];
+
+    expect(orderReusableExecutionWorkspaces(workspaces).map((item) => item.id)).toEqual([
+      "zulu",
+      "alpha",
+      "bravo",
+      "charlie",
+    ]);
+  });
+
+  it("keeps only the latest used workspace for duplicate paths before sorting", () => {
+    const workspaces = [
+      workspace({
+        id: "older-duplicate",
+        name: "Older duplicate",
+        cwd: "/tmp/shared",
+        lastUsedAt: "2026-01-01T00:00:00.000Z",
+      }),
+      workspace({ id: "beta", name: "Beta", cwd: "/tmp/beta", lastUsedAt: "2026-01-02T00:00:00.000Z" }),
+      workspace({
+        id: "newer-duplicate",
+        name: "Newer duplicate",
+        cwd: "/tmp/shared",
+        lastUsedAt: "2026-01-04T00:00:00.000Z",
+      }),
+      workspace({ id: "alpha", name: "Alpha", cwd: "/tmp/alpha", lastUsedAt: "2026-01-03T00:00:00.000Z" }),
+    ];
+
+    expect(orderReusableExecutionWorkspaces(workspaces).map((item) => item.id)).toEqual([
+      "newer-duplicate",
+      "alpha",
+      "beta",
+    ]);
+  });
+
+  it("does not let updatedAt churn outrank the last used workspace", () => {
+    type WorkspaceWithUpdatedAt = ReusableExecutionWorkspaceLike & { updatedAt: Date | string };
+    const workspaces: WorkspaceWithUpdatedAt[] = [
+      {
+        ...workspace({
+          id: "recently-used",
+          name: "Recently used",
+          cwd: "/tmp/shared",
+          lastUsedAt: "2026-01-04T00:00:00.000Z",
+        }),
+        updatedAt: "2026-01-01T00:00:00.000Z",
+      },
+      {
+        ...workspace({
+          id: "recently-updated",
+          name: "Recently updated",
+          cwd: "/tmp/shared",
+          lastUsedAt: "2026-01-01T00:00:00.000Z",
+        }),
+        updatedAt: "2026-01-05T00:00:00.000Z",
+      },
+    ];
+
+    expect(orderReusableExecutionWorkspaces(workspaces).map((item) => item.id)).toEqual([
+      "recently-used",
+    ]);
+  });
+});

ui/src/lib/reusable-execution-workspaces.ts

@@ -0,0 +1,49 @@
+export interface ReusableExecutionWorkspaceLike {
+  id: string;
+  name: string;
+  cwd: string | null;
+  lastUsedAt: Date | string;
+}
+
+function workspaceLastUsedTime(workspace: Pick<ReusableExecutionWorkspaceLike, "lastUsedAt">) {
+  const time = new Date(workspace.lastUsedAt).getTime();
+  return Number.isFinite(time) ? time : 0;
+}
+
+function compareWorkspaceNames(a: ReusableExecutionWorkspaceLike, b: ReusableExecutionWorkspaceLike) {
+  const nameCompare = a.name.localeCompare(b.name, undefined, {
+    numeric: true,
+    sensitivity: "base",
+  });
+  if (nameCompare !== 0) return nameCompare;
+  return a.id.localeCompare(b.id);
+}
+
+export function orderReusableExecutionWorkspaces<T extends ReusableExecutionWorkspaceLike>(
+  workspaces: readonly T[],
+): T[] {
+  const deduplicatedByPath = new Map<string, T>();
+
+  for (const workspace of workspaces) {
+    const key = workspace.cwd ?? workspace.id;
+    const existing = deduplicatedByPath.get(key);
+    if (!existing || workspaceLastUsedTime(workspace) > workspaceLastUsedTime(existing)) {
+      deduplicatedByPath.set(key, workspace);
+    }
+  }
+
+  const alphabetized = Array.from(deduplicatedByPath.values()).sort(compareWorkspaceNames);
+  if (alphabetized.length <= 1) return alphabetized;
+
+  let mostRecentlyUsed = alphabetized[0]!;
+  for (const workspace of alphabetized.slice(1)) {
+    if (workspaceLastUsedTime(workspace) > workspaceLastUsedTime(mostRecentlyUsed)) {
+      mostRecentlyUsed = workspace;
+    }
+  }
+
+  return [
+    mostRecentlyUsed,
+    ...alphabetized.filter((workspace) => workspace.id !== mostRecentlyUsed.id),
+  ];
+}

ui/src/lib/workspace-routines.test.ts

@@ -0,0 +1,69 @@
+import type { RoutineListItem } from "@paperclipai/shared";
+import { describe, expect, it } from "vitest";
+import {
+  getWorkspaceSpecificRoutineVariableNames,
+  routineHasWorkspaceSpecificVariables,
+} from "./workspace-routines";
+
+function createRoutine(overrides: Partial<RoutineListItem> = {}): RoutineListItem {
+  return {
+    id: "routine-1",
+    companyId: "company-1",
+    projectId: "project-1",
+    goalId: null,
+    parentIssueId: null,
+    title: "Routine title",
+    description: null,
+    assigneeAgentId: "agent-1",
+    priority: "medium",
+    status: "active",
+    concurrencyPolicy: "coalesce_if_active",
+    catchUpPolicy: "skip_missed",
+    variables: [],
+    createdByAgentId: null,
+    createdByUserId: null,
+    updatedByAgentId: null,
+    updatedByUserId: null,
+    lastTriggeredAt: null,
+    lastEnqueuedAt: null,
+    createdAt: new Date("2026-04-30T00:00:00.000Z"),
+    updatedAt: new Date("2026-04-30T00:00:00.000Z"),
+    triggers: [],
+    lastRun: null,
+    activeIssue: null,
+    ...overrides,
+  };
+}
+
+describe("workspace routine helpers", () => {
+  it("matches routines with explicit workspace variables", () => {
+    const routine = createRoutine({
+      variables: [
+        { name: "workspaceBranch", label: null, type: "text", defaultValue: null, required: true, options: [] },
+      ],
+    });
+
+    expect(routineHasWorkspaceSpecificVariables(routine)).toBe(true);
+    expect(getWorkspaceSpecificRoutineVariableNames(routine)).toEqual(["workspaceBranch"]);
+  });
+
+  it("matches routines that reference workspace variables in templates", () => {
+    const routine = createRoutine({
+      title: "Review {{ workspaceBranch }}",
+      description: "Check branch {{workspaceBranch}}",
+    });
+
+    expect(getWorkspaceSpecificRoutineVariableNames(routine)).toEqual(["workspaceBranch"]);
+  });
+
+  it("ignores routines with only non-workspace variables", () => {
+    const routine = createRoutine({
+      title: "Review {{repo}}",
+      variables: [
+        { name: "repo", label: null, type: "text", defaultValue: null, required: true, options: [] },
+      ],
+    });
+
+    expect(routineHasWorkspaceSpecificVariables(routine)).toBe(false);
+  });
+});

ui/src/lib/workspace-routines.ts

@@ -0,0 +1,31 @@
+import {
+  extractRoutineVariableNames,
+  WORKSPACE_BRANCH_ROUTINE_VARIABLE,
+  type RoutineListItem,
+} from "@paperclipai/shared";
+
+const WORKSPACE_SPECIFIC_ROUTINE_VARIABLES = new Set([
+  WORKSPACE_BRANCH_ROUTINE_VARIABLE,
+]);
+
+export function getWorkspaceSpecificRoutineVariableNames(routine: RoutineListItem): string[] {
+  const names = new Set<string>();
+
+  for (const variable of routine.variables) {
+    if (WORKSPACE_SPECIFIC_ROUTINE_VARIABLES.has(variable.name)) {
+      names.add(variable.name);
+    }
+  }
+
+  for (const name of extractRoutineVariableNames([routine.title, routine.description])) {
+    if (WORKSPACE_SPECIFIC_ROUTINE_VARIABLES.has(name)) {
+      names.add(name);
+    }
+  }
+
+  return [...names];
+}
+
+export function routineHasWorkspaceSpecificVariables(routine: RoutineListItem): boolean {
+  return getWorkspaceSpecificRoutineVariableNames(routine).length > 0;
+}