@brimveyn/aimux 1.21.0 → 1.22.2

package/src/cli/commands/{workspace → project}/switch.ts

@@ -1,14 +1,14 @@
 import type { CliCommand } from '../../registry'
 
-import { IPC_CAPABILITY_WORKSPACE_LIFECYCLE } from '../../../ipc/protocol'
-import { resolveWorkspace } from '../../client/workspace-resolver'
+import { IPC_CAPABILITY_PROJECT_LIFECYCLE } from '../../../ipc/protocol'
+import { resolveProject } from '../../client/project-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, EXIT_TIMEOUT, writeJson } from '../../output'
 
 const DEFAULT_WAIT_TIMEOUT_MS = 30_000
 
-export const workspaceSwitch: CliCommand = {
-  args: [{ complete: { kind: 'dynamic', source: 'workspace' }, name: 'workspace', required: true }],
+export const projectSwitch: CliCommand = {
+  args: [{ complete: { kind: 'dynamic', source: 'project' }, name: 'project', required: true }],
   flags: [
     ...SHARED_FLAGS,
     {
@@ -22,54 +22,54 @@ export const workspaceSwitch: CliCommand = {
       name: 'timeout',
     },
   ],
-  group: 'workspace',
+  group: 'project',
   run: async (ctx) => {
     const target = ctx.args.positionals[0]
     if (typeof target !== 'string' || target.length === 0) {
-      throw new Error('target workspace is required (id or name)')
+      throw new Error('target project is required (id or name)')
     }
-    const session = resolveWorkspace(target)
+    const project = resolveProject(target)
     const wait = ctx.args.flags.wait === true
     const timeoutMs =
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_WAIT_TIMEOUT_MS
 
     const daemon = await ctx.getDaemon()
-    if (!daemon.hasCapability(IPC_CAPABILITY_WORKSPACE_LIFECYCLE)) {
+    if (!daemon.hasCapability(IPC_CAPABILITY_PROJECT_LIFECYCLE)) {
       throw new Error(
-        'daemon predates workspaceLifecycle capability — restart aimux to pick up the new daemon'
+        'daemon predates projectLifecycle capability — restart aimux to pick up the new daemon'
       )
     }
 
     if (!wait) {
-      await daemon.expectOk('switchWorkspace', { targetSessionId: session.id })
-      writeJson({ name: session.name, targetSessionId: session.id })
+      await daemon.expectOk('switchProject', { targetProjectId: project.id })
+      writeJson({ name: project.name, targetProjectId: project.id })
       return EXIT_OK
     }
 
     // Subscribe BEFORE sending the request so we don't miss the broadcast for
-    // the no-UI path (the daemon emits `workspaceSwitched` synchronously in
+    // the no-UI path (the daemon emits `projectSwitched` synchronously in
     // that branch).
     const settled = new Promise<number>((resolve) => {
-      const off = daemon.on('workspaceSwitched', (payload) => {
-        if (payload.sessionId !== session.id) return
+      const off = daemon.on('projectSwitched', (payload) => {
+        if (payload.projectId !== project.id) return
         off()
         clearTimeout(timer)
-        writeJson({ name: session.name, targetSessionId: session.id })
+        writeJson({ name: project.name, targetProjectId: project.id })
         resolve(EXIT_OK)
       })
       const timer = setTimeout(() => {
         off()
         writeJson({
-          error: 'timed out waiting for workspaceSwitched',
-          targetSessionId: session.id,
+          error: 'timed out waiting for projectSwitched',
+          targetProjectId: project.id,
         })
         resolve(EXIT_TIMEOUT)
       }, timeoutMs)
     })
 
-    await daemon.expectOk('switchWorkspace', { targetSessionId: session.id })
+    await daemon.expectOk('switchProject', { targetProjectId: project.id })
     return settled
   },
-  summary: 'Switch the UI (or catalog when headless) to another workspace',
+  summary: 'Switch the UI (or catalog when headless) to another project',
   verb: 'switch',
 }

package/src/cli/commands/tab/await.ts

@@ -45,7 +45,7 @@ export const tabAwait: CliCommand = {
     const timeoutMs =
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (
       !daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH) ||
@@ -57,7 +57,7 @@ export const tabAwait: CliCommand = {
       )
     }
 
-    const attach = await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    const attach = await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
     const tab = attach.tabs.find((t) => t.id === tabId)
     if (!tab) {
       // Exit 3 (runtime) via runCli — NOT 4, which is reserved for

package/src/cli/commands/tab/close.ts

@@ -14,7 +14,7 @@ export const tabClose: CliCommand = {
       throw new Error('tabId is required')
     }
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
 
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
@@ -22,12 +22,12 @@ export const tabClose: CliCommand = {
         'daemon predates thinAttach capability — restart aimux to pick up the new daemon'
       )
     }
-    await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
     await daemon.expectOk('closeTab', { tabId })
 
     writeJson({ ok: true })
     return EXIT_OK
   },
-  summary: 'Close a tab in the workspace',
+  summary: 'Close a tab in the project',
   verb: 'close',
 }

package/src/cli/commands/tab/create.ts

@@ -1,6 +1,6 @@
 import { resolve as resolvePath } from 'node:path'
 
-import type { WorktreeRecord } from '../../../state/types'
+import type { WorkspaceRecord } from '../../../state/types'
 import type { CliContext } from '../../context'
 import type { CliCommand } from '../../registry'
 
@@ -22,7 +22,7 @@ import {
 } from '../../../pty/command-registry'
 import { CliUsageError, SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
-import { createWorkspaceWorktree } from '../worktree/create-core'
+import { createProjectWorkspace } from '../workspace/create-core'
 
 const FALLBACK_COLS = 200
 const FALLBACK_ROWS = 60
@@ -35,10 +35,10 @@ export interface CreateCliTabOptions {
   cwd?: string
   effort?: string
   model?: string
-  newWorktree?: boolean | string
+  newWorkspace?: boolean | string
   title?: string
   workerName?: string
-  worktreeId?: string
+  workspaceId?: string
 }
 
 export interface CreateCliTabResult {
@@ -53,26 +53,26 @@ export interface CreateCliTabResult {
   tabId: string
   title: string
   workerName: string | null
-  worktreeId: string | null
+  workspaceId: string | null
 }
 
 /**
  * Resolve the cwd a spawned tab should run in. Precedence: explicit `--cwd`
- * (resolved to absolute) > the resolved worktree's path > undefined (the
- * daemon's default). Worktree record paths are already absolute.
+ * (resolved to absolute) > the resolved workspace's path > undefined (the
+ * daemon's default). Workspace record paths are already absolute.
  */
 export function resolveTabCwd(
   cwdFlag: string | undefined,
-  worktreeRecord: { path: string } | undefined
+  workspaceRecord: { path: string } | undefined
 ): string | undefined {
   if (cwdFlag !== undefined) return resolvePath(cwdFlag)
-  return worktreeRecord?.path
+  return workspaceRecord?.path
 }
 
 /**
  * Resolve the base command a tab launches. Mirrors the UI's precedence
  * (`src/app-runtime/side-effects.ts`): an explicit `--command` override wins,
- * else the workspace's persisted `customCommands[assistantId]` (so CLI workers
+ * else the project's persisted `customCommands[assistantId]` (so CLI workers
  * inherit e.g. `claude --dangerously-skip-permissions`), else the builtin
  * default. `getAllAssistantOptions` deliberately does NOT apply builtin
  * overrides, so this lookup must be explicit.
@@ -85,13 +85,13 @@ export function resolveAssistantCommand(
   return commandOverride ?? customCommands[option.id] ?? option.command
 }
 
-async function rollbackCreatedWorktree(
-  record: WorktreeRecord,
+async function rollbackCreatedWorkspace(
+  record: WorkspaceRecord,
   ctx: CliContext,
   originalError: unknown
 ): Promise<never> {
   const daemon = await ctx.getDaemon()
-  const workspace = ctx.getWorkspace()
+  const project = ctx.getProject()
   let rollbackError: unknown
   try {
     await removeGitWorktree({
@@ -100,9 +100,9 @@ async function rollbackCreatedWorktree(
       targetPath: record.path,
     })
     await pruneEmptyWorktreeParent(record.path)
-    await daemon.expectOk('removeWorktreeRecord', {
-      sessionId: workspace.id,
-      worktreeId: record.id,
+    await daemon.expectOk('removeWorkspaceRecord', {
+      projectId: project.id,
+      workspaceId: record.id,
     })
   } catch (error) {
     rollbackError = error
@@ -117,8 +117,8 @@ async function rollbackCreatedWorktree(
 /**
  * Create a tab without writing to stdout. Worker commands compose this helper
  * with prompt dispatch/await while `tab create` remains a thin compatibility
- * adapter. All validation and daemon attachment happen before a worktree is
- * created; any later failure rolls the fresh worktree back.
+ * adapter. All validation and daemon attachment happen before a workspace is
+ * created; any later failure rolls the fresh workspace back.
  */
 export async function createCliTab(
   ctx: CliContext,
@@ -132,10 +132,10 @@ export async function createCliTab(
     cwd: cwdRaw,
     effort,
     model,
-    newWorktree,
+    newWorkspace,
     title: requestedTitle,
     workerName,
-    worktreeId: requestedWorktreeId,
+    workspaceId: requestedWorkspaceId,
   } = options
   if (assistantId.length === 0) throw new CliUsageError('--assistant is required')
   if (workerName !== undefined && workerName.trim().length === 0) {
@@ -147,18 +147,18 @@ export async function createCliTab(
     )
   }
 
-  const createFreshWorktree = newWorktree !== undefined && newWorktree !== false
-  if (createFreshWorktree && requestedWorktreeId !== undefined) {
+  const createFreshWorkspace = newWorkspace !== undefined && newWorkspace !== false
+  if (createFreshWorkspace && requestedWorkspaceId !== undefined) {
     throw new CliUsageError(
-      '--new-worktree creates its own; use --worktree <id> to co-locate instead'
+      '--new-workspace creates its own; use --workspace <id> to co-locate instead'
     )
   }
-  if (createFreshWorktree && cwdRaw !== undefined) {
-    throw new CliUsageError('--new-worktree sets the cwd to the new worktree; drop --cwd')
+  if (createFreshWorkspace && cwdRaw !== undefined) {
+    throw new CliUsageError('--new-workspace sets the cwd to the new workspace; drop --cwd')
   }
-  if (!createFreshWorktree && (base !== undefined || branch !== undefined)) {
+  if (!createFreshWorkspace && (base !== undefined || branch !== undefined)) {
     throw new CliUsageError(
-      '--base / --branch require --new-worktree (use `worktree create` otherwise)'
+      '--base / --branch require --new-workspace (use `workspace create` otherwise)'
     )
   }
 
@@ -177,7 +177,7 @@ export async function createCliTab(
   const title = requestedTitle ?? option.label
   const tabId = createPrefixedId('tab')
 
-  const workspace = ctx.getWorkspace()
+  const project = ctx.getProject()
   const daemon = await ctx.getDaemon()
   if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
     throw new Error(
@@ -193,44 +193,44 @@ export async function createCliTab(
     if (!daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
       throw new Error('daemon cannot validate worker-name uniqueness — restart aimux')
     }
-    const existing = await daemon.listTabs(workspace.id)
+    const existing = await daemon.listTabs(project.id)
     if (existing.tabs.some((tab) => tab.workerName === workerName)) {
-      throw new Error(`worker name already exists in workspace "${workspace.name}": ${workerName}`)
+      throw new Error(`worker name already exists in project "${project.name}": ${workerName}`)
     }
   }
 
-  // Attach before creating a worktree so stale daemon/session failures have no
+  // Attach before creating a workspace so stale daemon/project failures have no
   // git-side effect.
-  await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+  await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
 
-  let worktreeId = requestedWorktreeId ?? workspace.activeWorktreeId
-  let worktreeRecord =
-    worktreeId !== undefined
-      ? workspace.worktrees?.find((entry) => entry.id === worktreeId)
+  let workspaceId = requestedWorkspaceId ?? project.activeWorkspaceId
+  let workspaceRecord =
+    workspaceId !== undefined
+      ? project.workspaces?.find((entry) => entry.id === workspaceId)
       : undefined
-  if (requestedWorktreeId !== undefined && worktreeRecord === undefined) {
-    const ids = workspace.worktrees?.map((entry) => entry.id).join(', ') ?? '(none)'
-    throw new Error(`unknown worktree id: ${requestedWorktreeId} (known: ${ids})`)
+  if (requestedWorkspaceId !== undefined && workspaceRecord === undefined) {
+    const ids = project.workspaces?.map((entry) => entry.id).join(', ') ?? '(none)'
+    throw new Error(`unknown workspace id: ${requestedWorkspaceId} (known: ${ids})`)
   }
 
-  let createdWorktree: WorktreeRecord | undefined
-  if (createFreshWorktree) {
-    const worktreeName =
-      typeof newWorktree === 'string' && newWorktree !== ''
-        ? newWorktree
+  let createdWorkspace: WorkspaceRecord | undefined
+  if (createFreshWorkspace) {
+    const workspaceName =
+      typeof newWorkspace === 'string' && newWorkspace !== ''
+        ? newWorkspace
         : `${assistantId}-${tabId.slice(-6)}`
-    createdWorktree = await createWorkspaceWorktree({
+    createdWorkspace = await createProjectWorkspace({
       base: base ?? 'HEAD',
-      branch: branch ?? `aimux/${worktreeName}`,
+      branch: branch ?? `aimux/${workspaceName}`,
       daemon,
-      name: worktreeName,
-      workspace,
+      name: workspaceName,
+      project,
     })
-    worktreeId = createdWorktree.id
-    worktreeRecord = createdWorktree
+    workspaceId = createdWorkspace.id
+    workspaceRecord = createdWorkspace
   }
 
-  const cwd = resolveTabCwd(cwdRaw, worktreeRecord)
+  const cwd = resolveTabCwd(cwdRaw, workspaceRecord)
   const useFallback = daemon.hasCapability(IPC_CAPABILITY_CREATE_TAB_SIZE_FALLBACK)
   try {
     await daemon.expectOk('createTab', {
@@ -244,28 +244,28 @@ export async function createCliTab(
       tabId,
       title,
       workerName,
-      worktreeId,
+      workspaceId,
     })
   } catch (error) {
-    if (createdWorktree !== undefined) {
-      return rollbackCreatedWorktree(createdWorktree, ctx, error)
+    if (createdWorkspace !== undefined) {
+      return rollbackCreatedWorkspace(createdWorkspace, ctx, error)
     }
     throw error
   }
 
   return {
     assistant: assistantId,
-    branch: worktreeRecord?.branch ?? null,
+    branch: workspaceRecord?.branch ?? null,
     command: [executable, ...args].join(' '),
     cwd: cwd ?? null,
     effort: effort ?? null,
     model: model ?? null,
-    name: worktreeRecord?.name ?? null,
-    path: worktreeRecord?.path ?? null,
+    name: workspaceRecord?.name ?? null,
+    path: workspaceRecord?.path ?? null,
     tabId,
     title,
     workerName: workerName ?? null,
-    worktreeId: worktreeId ?? null,
+    workspaceId: workspaceId ?? null,
   }
 }
 
@@ -310,26 +310,27 @@ export const tabCreate: CliCommand = {
       name: 'effort',
     },
     {
-      complete: { kind: 'dynamic', source: 'worktree' },
-      description: 'worktree id the tab belongs to (defaults to the workspace’s active worktree)',
+      complete: { kind: 'dynamic', source: 'workspace' },
+      description: 'workspace id the tab belongs to (defaults to the project’s active workspace)',
       kind: 'string',
-      name: 'worktree',
+      name: 'workspace',
     },
     {
       complete: { kind: 'none' },
-      description: 'create a fresh worktree for this tab (optionally named: --new-worktree=<name>)',
+      description:
+        'create a fresh workspace for this tab (optionally named: --new-workspace=<name>)',
       kind: 'optional-string',
-      name: 'new-worktree',
+      name: 'new-workspace',
     },
     {
       complete: { kind: 'dynamic', source: 'git-ref' },
-      description: 'base ref for --new-worktree (default HEAD)',
+      description: 'base ref for --new-workspace (default HEAD)',
       kind: 'string',
       name: 'base',
     },
     {
       complete: { kind: 'none' },
-      description: 'branch for --new-worktree (default aimux/<name>)',
+      description: 'branch for --new-workspace (default aimux/<name>)',
       kind: 'string',
       name: 'branch',
     },
@@ -347,13 +348,13 @@ export const tabCreate: CliCommand = {
 
     const title = typeof ctx.args.flags.title === 'string' ? ctx.args.flags.title : undefined
     const cwdRaw = typeof ctx.args.flags.cwd === 'string' ? ctx.args.flags.cwd : undefined
-    const newWorktreeRaw = ctx.args.flags['new-worktree']
-    const newWorktreeFlag =
-      typeof newWorktreeRaw === 'string' || typeof newWorktreeRaw === 'boolean'
-        ? newWorktreeRaw
+    const newWorkspaceRaw = ctx.args.flags['new-workspace']
+    const newWorkspaceFlag =
+      typeof newWorkspaceRaw === 'string' || typeof newWorkspaceRaw === 'boolean'
+        ? newWorkspaceRaw
         : undefined
-    const worktreeFlag =
-      typeof ctx.args.flags.worktree === 'string' ? ctx.args.flags.worktree : undefined
+    const workspaceFlag =
+      typeof ctx.args.flags.workspace === 'string' ? ctx.args.flags.workspace : undefined
     const baseFlag = typeof ctx.args.flags.base === 'string' ? ctx.args.flags.base : undefined
     const branchFlag = typeof ctx.args.flags.branch === 'string' ? ctx.args.flags.branch : undefined
     const result = await createCliTab(ctx, {
@@ -364,9 +365,9 @@ export const tabCreate: CliCommand = {
       cwd: cwdRaw,
       effort,
       model,
-      newWorktree: newWorktreeFlag,
+      newWorkspace: newWorkspaceFlag,
       title,
-      worktreeId: worktreeFlag,
+      workspaceId: workspaceFlag,
     })
     writeJson(result)
     return EXIT_OK

package/src/cli/commands/tab/focus.ts

@@ -14,7 +14,7 @@ export const tabFocus: CliCommand = {
       throw new Error('tabId is required')
     }
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
 
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
@@ -22,12 +22,12 @@ export const tabFocus: CliCommand = {
         'daemon predates thinAttach capability — restart aimux to pick up the new daemon'
       )
     }
-    await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
     await daemon.expectOk('setActiveTab', { tabId })
 
     writeJson({ ok: true })
     return EXIT_OK
   },
-  summary: 'Set the active tab in the workspace',
+  summary: 'Set the active tab in the project',
   verb: 'focus',
 }

package/src/cli/commands/tab/list.ts

@@ -32,7 +32,7 @@ export const tabList: CliCommand = {
   ],
   group: 'tab',
   run: async (ctx) => {
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     const verbose = ctx.args.flags.verbose === true
 
@@ -43,7 +43,7 @@ export const tabList: CliCommand = {
     }
 
     if (daemon.hasCapability(IPC_CAPABILITY_LIST_TABS)) {
-      const result = await daemon.listTabs(workspace.id)
+      const result = await daemon.listTabs(project.id)
       const tabs = verbose ? result.tabs : result.tabs.map(stripLastLine)
       writeJson({ activeTabId: result.activeTabId, tabs })
       return EXIT_OK
@@ -56,12 +56,12 @@ export const tabList: CliCommand = {
     }
 
     // Fallback: thin-attach to read the same information without resizing the
-    // session. Pre-listTabs daemons that advertise thinAttach would in
+    // project. Pre-listTabs daemons that advertise thinAttach would in
     // principle land here, but that combination shouldn't ship.
     const attach = await daemon.attach({
       cols: 0,
+      projectId: project.id,
       rows: 0,
-      sessionId: workspace.id,
       thin: true,
     })
     writeJson({
@@ -73,11 +73,11 @@ export const tabList: CliCommand = {
         id: tab.id,
         status: tab.status,
         title: tab.title,
-        worktreeId: tab.worktreeId,
+        workspaceId: tab.workspaceId,
       })),
     })
     return EXIT_OK
   },
-  summary: 'List tabs in the active workspace',
+  summary: 'List tabs in the active project',
   verb: 'list',
 }

package/src/cli/commands/tab/run.ts

@@ -60,7 +60,7 @@ export const tabRun: CliCommand = {
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
     const appendEnter = ctx.args.flags['no-enter'] !== true
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (
       !daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH) ||
@@ -72,7 +72,7 @@ export const tabRun: CliCommand = {
       )
     }
 
-    const attach = await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    const attach = await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
     if (!attach.tabs.some((t) => t.id === tabId)) {
       throw new Error(`tab not found: ${tabId}`)
     }

package/src/cli/commands/tab/send.ts

@@ -97,7 +97,7 @@ export const tabSend: CliCommand = {
     }
     const payload = buildPromptPayload(text, asKeys)
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
       throw new Error(
@@ -105,7 +105,7 @@ export const tabSend: CliCommand = {
       )
     }
 
-    await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
 
     if (!awaitSubmit) {
       const bytesWritten = await writePromptPayload(daemon, tabId, payload, appendEnter)

package/src/cli/commands/tab/snapshot.ts

@@ -38,7 +38,7 @@ export const tabSnapshot: CliCommand = {
     }
     const renderOptions = { trim: ctx.args.flags['no-trim'] !== true }
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
       throw new Error(
@@ -71,8 +71,8 @@ export const tabSnapshot: CliCommand = {
 
     const attach = await daemon.attach({
       cols: 0,
+      projectId: project.id,
       rows: 0,
-      sessionId: workspace.id,
       thin: true,
     })
     const tab = attach.tabs.find((t) => t.id === tabId)

package/src/cli/commands/tab/tail.ts

@@ -57,7 +57,7 @@ export const tabTail: CliCommand = {
     const followStatus = ctx.args.flags['follow-status'] === true
     const timeoutMs = typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : 0
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
       throw new Error(
@@ -69,7 +69,7 @@ export const tabTail: CliCommand = {
     // Attach before wiring subscribers so replay renders arrive after we
     // print the "attached" marker; that keeps NDJSON output deterministic
     // for downstream consumers.
-    const attach = await daemon.attach({ cols: 0, rows: 0, sessionId: workspace.id, thin: true })
+    const attach = await daemon.attach({ cols: 0, projectId: project.id, rows: 0, thin: true })
 
     // Fail fast on a bad tabId — otherwise tail would sit silent until
     // --timeout, since no matching tabRender/tabExit would ever fire.

package/src/cli/commands/tab/wait.ts

@@ -36,7 +36,7 @@ export const tabWait: CliCommand = {
     const timeoutMs =
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
 
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const daemon = await ctx.getDaemon()
     if (!daemon.hasCapability(IPC_CAPABILITY_THIN_ATTACH)) {
       throw new Error(
@@ -46,8 +46,8 @@ export const tabWait: CliCommand = {
 
     const attach = await daemon.attach({
       cols: 0,
+      projectId: project.id,
       rows: 0,
-      sessionId: workspace.id,
       thin: true,
     })
 

package/src/cli/commands/worker/await.ts

@@ -19,14 +19,14 @@ export const workerAwait: CliCommand = {
   ],
   group: 'worker',
   run: async (ctx) => {
-    const { tab, workspace } = await resolveWorkerTarget(ctx, ctx.args.positionals[0] ?? '')
+    const { project, tab } = await resolveWorkerTarget(ctx, ctx.args.positionals[0] ?? '')
     const outcome = await awaitExistingWorker(
       ctx,
-      workspace,
+      project,
       tab.id,
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
     )
-    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
+    writeJson(workerEnvelope(project, workerView(project, tab), outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: "Await an existing worker's in-flight turn",