@brimveyn/aimux 1.21.0 → 1.22.2

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

@@ -11,7 +11,7 @@ import {
   IPC_CAPABILITY_THIN_ATTACH,
   IPC_CAPABILITY_TURN_LIFECYCLE,
   IPC_CAPABILITY_WORKER_METADATA,
-  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
+  IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS,
 } from '../../../ipc/protocol'
 import {
   getAllAssistantOptions,
@@ -19,10 +19,10 @@ import {
   parseCommand,
 } from '../../../pty/command-registry'
 import {
-  findPrimaryWorktree,
-  WORKSPACE_ENV_VAR,
-  workspaceRepoRoot,
-} from '../../client/workspace-resolver'
+  findPrimaryWorkspace,
+  PROJECT_ENV_VAR,
+  projectRepoRoot,
+} from '../../client/project-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, EXIT_RUNTIME, writeJson } from '../../output'
 import { WORKER_SCHEMA_VERSION } from './shared'
@@ -33,7 +33,7 @@ const REQUIRED_DAEMON_CAPABILITIES = [
   IPC_CAPABILITY_THIN_ATTACH,
   IPC_CAPABILITY_TURN_LIFECYCLE,
   IPC_CAPABILITY_WORKER_METADATA,
-  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
+  IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS,
 ] as const
 
 export const workerDoctor: CliCommand = {
@@ -42,7 +42,7 @@ export const workerDoctor: CliCommand = {
   group: 'worker',
   run: async (ctx) => {
     const daemon = await ctx.getDaemon()
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const { version } = await import('../../../../package.json')
     const { customCommands } = loadConfig()
     const assistants = getAllAssistantOptions(customCommands).map((assistant) => ({
@@ -61,8 +61,8 @@ export const workerDoctor: CliCommand = {
     const missingManagerCapabilities = [MANAGER_CAPABILITY_WORKER_METADATA].filter(
       (capability) => !managerCapabilities.includes(capability)
     )
-    const primaryWorktree = findPrimaryWorktree(workspace)
-    const workspaceOrigin = ctx.getWorkspaceOrigin?.() ?? 'active'
+    const primaryWorkspace = findPrimaryWorkspace(project)
+    const projectOrigin = ctx.getProjectOrigin?.() ?? 'active'
     const availableAssistants = assistants.filter((assistant) => assistant.available)
     const skillPath = fileURLToPath(
       new URL('../../../../skills/aimux-orchestrator/', import.meta.url)
@@ -78,8 +78,8 @@ export const workerDoctor: CliCommand = {
         `restart the terminal manager; it is missing: ${missingManagerCapabilities.join(', ')}`
       )
     }
-    if (primaryWorktree === undefined) {
-      issues.push('workspace has no primary worktree; default isolated worker runs are unavailable')
+    if (primaryWorkspace === undefined) {
+      issues.push('project has no primary workspace; default isolated worker runs are unavailable')
     }
     if (availableAssistants.length === 0) {
       issues.push('no configured assistant executable is available on PATH')
@@ -87,14 +87,14 @@ export const workerDoctor: CliCommand = {
     if (!existsSync(skillPath)) {
       issues.push(`packaged orchestrator skill is missing: ${skillPath}`)
     }
-    // Not an issue — an inferred workspace is the normal interactive case — but
+    // Not an issue — an inferred project is the normal interactive case — but
     // it IS the one resolution mode that can follow the UI to another project
     // between two calls. An orchestrator dispatching a multi-hour fleet wants to
     // see this before it starts, not after it reviews diffs from the wrong repo.
     const warnings: string[] = []
-    if (workspaceOrigin === 'active') {
+    if (projectOrigin === 'active') {
       warnings.push(
-        `workspace "${workspace.name}" was inferred from the most recently opened session and follows the UI; pin it with --workspace or ${WORKSPACE_ENV_VAR}`
+        `project "${project.name}" was inferred from the most recently opened project and follows the UI; pin it with --project or ${PROJECT_ENV_VAR}`
       )
     }
     const ready = issues.length === 0
@@ -113,16 +113,16 @@ export const workerDoctor: CliCommand = {
           missing: missingManagerCapabilities,
           ok: missingManagerCapabilities.length === 0,
         },
-        skill: { ok: existsSync(skillPath), path: skillPath },
-        workspace: {
-          hasPrimaryWorktree: primaryWorktree !== undefined,
-          name: workspace.name,
-          ok: primaryWorktree !== undefined,
-          /** Repo every fresh worker worktree is cut from — confirm before dispatching. */
-          repoRoot: workspaceRepoRoot(workspace),
+        project: {
+          hasPrimaryWorkspace: primaryWorkspace !== undefined,
+          name: project.name,
+          ok: primaryWorkspace !== undefined,
+          /** Repo every fresh worker workspace is cut from — confirm before dispatching. */
+          repoRoot: projectRepoRoot(project),
           /** 'flag' | 'env' | 'active'; only 'active' can follow the UI. */
-          source: workspaceOrigin,
+          source: projectOrigin,
         },
+        skill: { ok: existsSync(skillPath), path: skillPath },
       },
       cliVersion: version,
       daemon: {
@@ -134,20 +134,20 @@ export const workerDoctor: CliCommand = {
         protocolVersion: daemon.getSelectedVersion(),
       },
       issues,
+      project: {
+        id: project.id,
+        name: project.name,
+        projectPath: project.projectPath ?? null,
+        repoRoot: projectRepoRoot(project),
+        source: projectOrigin,
+      },
       ready,
       schemaVersion: WORKER_SCHEMA_VERSION,
       skillPath,
       warnings,
-      workspace: {
-        id: workspace.id,
-        name: workspace.name,
-        projectPath: workspace.projectPath ?? null,
-        repoRoot: workspaceRepoRoot(workspace),
-        source: workspaceOrigin,
-      },
     })
     return ready ? EXIT_OK : EXIT_RUNTIME
   },
-  summary: 'Check worker prerequisites, versions, assistants, and workspace',
+  summary: 'Check worker prerequisites, versions, assistants, and project',
   verb: 'doctor',
 }

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

@@ -1,6 +1,6 @@
 import type { CliCommand } from '../../registry'
 
-import { workspaceIdentity } from '../../client/workspace-resolver'
+import { projectIdentity } from '../../client/project-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 import {
@@ -16,9 +16,9 @@ export const workerList: CliCommand = {
   flags: [
     ...SHARED_FLAGS,
     {
-      description: 'list workers in every catalogued workspace, not just the target one',
+      description: 'list workers in every catalogued project, not just the target one',
       kind: 'boolean',
-      name: 'all-workspaces',
+      name: 'all-projects',
     },
   ],
   group: 'worker',
@@ -27,41 +27,41 @@ export const workerList: CliCommand = {
 
     // `{"workers":[]}` alone is indistinguishable from "every worker died", and
     // the natural recovery from that reading is a destructive re-dispatch. Name
-    // the workspace that was queried so an empty fleet is legible as "not here"
+    // the project that was queried so an empty fleet is legible as "not here"
     // rather than "gone", and offer one call that answers "are they really gone?"
-    if (ctx.args.flags['all-workspaces'] === true) {
+    if (ctx.args.flags['all-projects'] === true) {
       const targets = await listWorkerTargets(ctx)
       writeJson({
         schemaVersion: WORKER_SCHEMA_VERSION,
         workers: targets
           .filter((target) => selector === undefined || target.tab.workerName === selector)
           .map((target) => ({
-            ...workerView(target.workspace, target.tab),
-            workspace: workspaceIdentity(target.workspace),
+            ...workerView(target.project, target.tab),
+            project: projectIdentity(target.project),
           })),
       })
       return EXIT_OK
     }
 
     if (selector !== undefined) {
-      const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
+      const { project, tab } = await resolveWorkerTarget(ctx, selector)
       writeJson({
+        project: projectIdentity(project),
         schemaVersion: WORKER_SCHEMA_VERSION,
-        workers: [workerView(workspace, tab)],
-        workspace: workspaceIdentity(workspace),
+        workers: [workerView(project, tab)],
       })
       return EXIT_OK
     }
 
-    const workspace = ctx.getWorkspace()
-    const tabs = await listNamedWorkerTabs(ctx, workspace)
+    const project = ctx.getProject()
+    const tabs = await listNamedWorkerTabs(ctx, project)
     writeJson({
+      project: projectIdentity(project),
       schemaVersion: WORKER_SCHEMA_VERSION,
-      workers: tabs.map((tab) => workerView(workspace, tab)),
-      workspace: workspaceIdentity(workspace),
+      workers: tabs.map((tab) => workerView(project, tab)),
     })
     return EXIT_OK
   },
-  summary: 'List named workers with liveness and worktree context',
+  summary: 'List named workers with liveness and workspace context',
   verb: 'list',
 }

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

@@ -48,7 +48,7 @@ export const workerPrompt: CliCommand = {
   group: 'worker',
   run: async (ctx) => {
     const selector = ctx.args.positionals[0] ?? ''
-    const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
+    const { project, tab } = await resolveWorkerTarget(ctx, selector)
     const promptFile =
       typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
     const text = await resolvePromptText(
@@ -56,7 +56,7 @@ export const workerPrompt: CliCommand = {
       ctx.args.flags.stdin === true,
       ctx.args.positionals[1]
     )
-    const outcome = await dispatchWorkerPrompt(ctx, workspace, tab.id, text, {
+    const outcome = await dispatchWorkerPrompt(ctx, project, tab.id, text, {
       detach: ctx.args.flags.detach === true,
       replace: ctx.args.flags.replace === true,
       timeoutMs:
@@ -66,7 +66,7 @@ export const workerPrompt: CliCommand = {
           ? ctx.args.flags['uptake-timeout']
           : undefined,
     })
-    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
+    writeJson(workerEnvelope(project, workerView(project, tab), outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: 'Prompt an existing named worker and await its outcome',

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

@@ -19,7 +19,7 @@ export const workerRun: CliCommand = {
     ...SHARED_FLAGS,
     {
       complete: { kind: 'none' },
-      description: 'unique workspace-scoped worker name',
+      description: 'unique project-scoped worker name',
       kind: 'string',
       name: 'name',
     },
@@ -61,25 +61,25 @@ export const workerRun: CliCommand = {
       name: 'uptake-timeout',
     },
     {
-      complete: { kind: 'dynamic', source: 'worktree' },
-      description: 'co-locate in an existing worktree id',
+      complete: { kind: 'dynamic', source: 'workspace' },
+      description: 'co-locate in an existing workspace id',
       kind: 'string',
-      name: 'worktree',
+      name: 'workspace',
     },
     {
-      description: 'run in the workspace active worktree instead of creating one',
+      description: 'run in the project active workspace instead of creating one',
       kind: 'boolean',
-      name: 'no-worktree',
+      name: 'no-workspace',
     },
     {
       complete: { kind: 'dynamic', source: 'git-ref' },
-      description: 'base ref for the fresh worktree (default HEAD)',
+      description: 'base ref for the fresh workspace (default HEAD)',
       kind: 'string',
       name: 'base',
     },
     {
       complete: { kind: 'none' },
-      description: 'branch for the fresh worktree (default aimux/<name>)',
+      description: 'branch for the fresh workspace (default aimux/<name>)',
       kind: 'string',
       name: 'branch',
     },
@@ -90,11 +90,11 @@ export const workerRun: CliCommand = {
     const assistant = typeof ctx.args.flags.assistant === 'string' ? ctx.args.flags.assistant : ''
     validateWorkerName(name)
     if (assistant === '') throw new CliUsageError('--assistant is required')
-    const worktree =
-      typeof ctx.args.flags.worktree === 'string' ? ctx.args.flags.worktree : undefined
-    const noWorktree = ctx.args.flags['no-worktree'] === true
-    if (worktree !== undefined && noWorktree) {
-      throw new CliUsageError('--worktree and --no-worktree are mutually exclusive')
+    const workspace =
+      typeof ctx.args.flags.workspace === 'string' ? ctx.args.flags.workspace : undefined
+    const noWorkspace = ctx.args.flags['no-workspace'] === true
+    if (workspace !== undefined && noWorkspace) {
+      throw new CliUsageError('--workspace and --no-workspace are mutually exclusive')
     }
     const promptFile =
       typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
@@ -103,27 +103,27 @@ export const workerRun: CliCommand = {
       ctx.args.flags.stdin === true,
       ctx.args.positionals[0]
     )
-    // Resolve the target workspace ONCE, up front, and use that record for
-    // every later step. The repo a worktree is cut from comes from this record,
-    // so an orchestrator that omits --workspace at least gets the resolved
+    // Resolve the target project ONCE, up front, and use that record for
+    // every later step. The repo a workspace is cut from comes from this record,
+    // so an orchestrator that omits --project at least gets the resolved
     // identity echoed back in the response instead of having to infer it.
-    const workspace = ctx.getWorkspace()
+    const project = ctx.getProject()
     const result = await createCliTab(ctx, {
       assistantId: assistant,
       base: typeof ctx.args.flags.base === 'string' ? ctx.args.flags.base : undefined,
       branch: typeof ctx.args.flags.branch === 'string' ? ctx.args.flags.branch : undefined,
       effort: typeof ctx.args.flags.effort === 'string' ? ctx.args.flags.effort : undefined,
       model: typeof ctx.args.flags.model === 'string' ? ctx.args.flags.model : undefined,
-      newWorktree: noWorktree || worktree !== undefined ? undefined : name,
+      newWorkspace: noWorkspace || workspace !== undefined ? undefined : name,
       title: name,
       workerName: name,
-      worktreeId: worktree,
+      workspaceId: workspace,
     })
-    const tabs = await (await ctx.getDaemon()).listTabs(workspace.id)
+    const tabs = await (await ctx.getDaemon()).listTabs(project.id)
     const tab = tabs.tabs.find((entry) => entry.id === result.tabId)
     if (!tab) throw new Error(`created worker disappeared: ${result.tabId}`)
-    const worker = workerView(workspace, tab)
-    const outcome = await dispatchWorkerPrompt(ctx, workspace, result.tabId, text, {
+    const worker = workerView(project, tab)
+    const outcome = await dispatchWorkerPrompt(ctx, project, result.tabId, text, {
       // The tab was spawned microseconds ago: its assistant is still booting, so
       // the prompt must not be written until the TUI is reading keystrokes.
       awaitFirstPaint: true,
@@ -135,7 +135,7 @@ export const workerRun: CliCommand = {
           ? ctx.args.flags['uptake-timeout']
           : undefined,
     })
-    writeJson(workerEnvelope(workspace, worker, outcome))
+    writeJson(workerEnvelope(project, worker, outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: 'Create a named worker, dispatch a prompt, and await its outcome',

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

@@ -1,4 +1,4 @@
-import type { SessionRecord, TerminalSnapshot, WorktreeRecord } from '../../../state/types'
+import type { ProjectRecord, TerminalSnapshot, WorkspaceRecord } from '../../../state/types'
 import type { CliContext } from '../../context'
 
 import {
@@ -9,11 +9,7 @@ import {
   IPC_CAPABILITY_WORKER_METADATA,
   type TabSessionSummary,
 } from '../../../ipc/protocol'
-import {
-  listWorkspaces,
-  workspaceIdentity,
-  workspaceRepoRoot,
-} from '../../client/workspace-resolver'
+import { listProjects, projectIdentity, projectRepoRoot } from '../../client/project-resolver'
 import { CliUsageError } from '../../flags'
 import {
   EXIT_OK,
@@ -62,12 +58,12 @@ export interface WorkerView {
   lastLine?: string
   name: string
   path: string | null
-  /** Repository the worker's worktree was cut from — see `workspaceRepoRoot`. */
+  /** Repository the worker's workspace was cut from — see `projectRepoRoot`. */
   repoRoot: string | null
   status: TabSessionSummary['status']
   tabId: string
   title: string
-  worktreeId: string | null
+  workspaceId: string | null
 }
 
 export interface WorkerOutcome {
@@ -85,10 +81,10 @@ export interface WorkerOutcome {
   }
 }
 
-/** A worker plus the workspace it is actually bound to. */
+/** A worker plus the project it is actually bound to. */
 export interface WorkerTarget {
   tab: TabSessionSummary
-  workspace: SessionRecord
+  project: ProjectRecord
 }
 
 export function validateWorkerName(name: string): void {
@@ -99,32 +95,32 @@ export function validateWorkerName(name: string): void {
   }
 }
 
-function worktreeFor(
-  workspace: SessionRecord,
-  worktreeId: string | undefined
-): WorktreeRecord | undefined {
-  if (worktreeId === undefined) return undefined
-  return workspace.worktrees?.find((worktree) => worktree.id === worktreeId)
+function workspaceFor(
+  project: ProjectRecord,
+  workspaceId: string | undefined
+): WorkspaceRecord | undefined {
+  if (workspaceId === undefined) return undefined
+  return project.workspaces?.find((workspace) => workspace.id === workspaceId)
 }
 
-export function workerView(workspace: SessionRecord, tab: TabSessionSummary): WorkerView {
+export function workerView(project: ProjectRecord, tab: TabSessionSummary): WorkerView {
   if (tab.workerName === undefined) {
     throw new Error(`tab is not a named worker: ${tab.id}`)
   }
-  const worktree = worktreeFor(workspace, tab.worktreeId)
+  const workspace = workspaceFor(project, tab.workspaceId)
   return {
     activity: tab.activity,
     assistant: tab.assistant,
-    branch: worktree?.branch ?? null,
+    branch: workspace?.branch ?? null,
     command: tab.command,
     lastLine: tab.lastLine,
     name: tab.workerName,
-    path: worktree?.path ?? null,
-    repoRoot: worktree?.repoRoot ?? workspaceRepoRoot(workspace),
+    path: workspace?.path ?? null,
+    repoRoot: workspace?.repoRoot ?? projectRepoRoot(project),
     status: tab.status,
     tabId: tab.id,
     title: tab.title,
-    worktreeId: tab.worktreeId ?? null,
+    workspaceId: tab.workspaceId ?? null,
   }
 }
 
@@ -143,20 +139,20 @@ async function requireWorkerCapabilities(
 
 export async function listNamedWorkerTabs(
   ctx: CliContext,
-  workspace: SessionRecord = ctx.getWorkspace()
+  project: ProjectRecord = ctx.getProject()
 ): Promise<TabSessionSummary[]> {
   const daemon = await requireWorkerCapabilities(ctx)
-  return (await daemon.listTabs(workspace.id)).tabs.filter((tab) => tab.workerName !== undefined)
+  return (await daemon.listTabs(project.id)).tabs.filter((tab) => tab.workerName !== undefined)
 }
 
-/** Every named worker the daemon knows about, across every catalogued workspace. */
+/** Every named worker the daemon knows about, across every catalogued project. */
 export async function listWorkerTargets(ctx: CliContext): Promise<WorkerTarget[]> {
   const daemon = await requireWorkerCapabilities(ctx)
   const targets: WorkerTarget[] = []
-  for (const workspace of ctx.getWorkspaces?.() ?? listWorkspaces()) {
-    const { tabs } = await daemon.listTabs(workspace.id)
+  for (const project of ctx.getProjects?.() ?? listProjects()) {
+    const { tabs } = await daemon.listTabs(project.id)
     for (const tab of tabs) {
-      if (tab.workerName !== undefined) targets.push({ tab, workspace })
+      if (tab.workerName !== undefined) targets.push({ project, tab })
     }
   }
   return targets
@@ -167,47 +163,45 @@ function matches(tab: TabSessionSummary, selector: string): boolean {
 }
 
 /**
- * Resolve a worker selector to the tab AND the workspace that owns it.
+ * Resolve a worker selector to the tab AND the project that owns it.
  *
- * A worker is addressed for its whole lifetime, but the *active* workspace can
+ * A worker is addressed for its whole lifetime, but the *active* project can
  * change under it (the UI switching projects is enough). Resolving only against
- * the active workspace is what made a live fleet look dead — `worker list`
+ * the active project is what made a live fleet look dead — `worker list`
  * returning `[]` and `worker await` saying "worker not found" while all twelve
- * workers were healthy. So when the workspace was merely inferred, fall back to
+ * workers were healthy. So when the project was merely inferred, fall back to
  * a catalog-wide search and bind to wherever the worker actually lives; when it
- * was pinned (`--workspace` / `AIMUX_WORKSPACE`), keep the boundary but name the
- * workspace that does hold it instead of a bare "not found".
+ * was pinned (`--project` / `AIMUX_PROJECT`), keep the boundary but name the
+ * project that does hold it instead of a bare "not found".
  */
 export async function resolveWorkerTarget(
   ctx: CliContext,
   selector: string
 ): Promise<WorkerTarget> {
-  const workspace = ctx.getWorkspace()
-  const local = (await listNamedWorkerTabs(ctx, workspace)).filter((tab) => matches(tab, selector))
+  const project = ctx.getProject()
+  const local = (await listNamedWorkerTabs(ctx, project)).filter((tab) => matches(tab, selector))
   if (local.length > 1) {
     throw new Error(
-      `worker selector is ambiguous in workspace "${workspace.name}": ${selector} (${local
+      `worker selector is ambiguous in project "${project.name}": ${selector} (${local
         .map((tab) => tab.id)
         .join(', ')})`
     )
   }
   const only = local[0]
-  if (only) return { tab: only, workspace }
+  if (only) return { project, tab: only }
 
   const elsewhere = (await listWorkerTargets(ctx)).filter(
-    (target) => target.workspace.id !== workspace.id && matches(target.tab, selector)
+    (target) => target.project.id !== project.id && matches(target.tab, selector)
   )
-  const pinned = (ctx.getWorkspaceOrigin?.() ?? 'active') !== 'active'
+  const pinned = (ctx.getProjectOrigin?.() ?? 'active') !== 'active'
   if (elsewhere.length === 1 && elsewhere[0] && !pinned) return elsewhere[0]
   if (elsewhere.length > 0) {
-    const where = elsewhere
-      .map((target) => `${target.workspace.name} (${target.tab.id})`)
-      .join(', ')
+    const where = elsewhere.map((target) => `${target.project.name} (${target.tab.id})`).join(', ')
     throw new Error(
-      `worker not found in workspace "${workspace.name}": ${selector} — it lives in ${where}; re-run with --workspace`
+      `worker not found in project "${project.name}": ${selector} — it lives in ${where}; re-run with --project`
     )
   }
-  throw new Error(`worker not found in workspace "${workspace.name}": ${selector}`)
+  throw new Error(`worker not found in project "${project.name}": ${selector}`)
 }
 
 export function normalizeTurnOutcome(outcome: TurnOutcome): WorkerOutcome {
@@ -331,11 +325,11 @@ async function armUptake(
  */
 async function liveUptake(
   daemon: Awaited<ReturnType<CliContext['getDaemon']>>,
-  sessionId: string,
+  projectId: string,
   tabId: string,
   startedAt: number
 ): Promise<UptakeResult | undefined> {
-  const live = (await daemon.listTabs(sessionId)).tabs.find((tab) => tab.id === tabId)
+  const live = (await daemon.listTabs(projectId)).tabs.find((tab) => tab.id === tabId)
   if (live?.activity !== 'working' && live?.activity !== 'waiting-input') return undefined
   return { activity: live.activity, confirmed: true, ms: Date.now() - startedAt }
 }
@@ -357,13 +351,13 @@ export interface DispatchOptions {
 
 export async function dispatchWorkerPrompt(
   ctx: CliContext,
-  workspace: SessionRecord,
+  project: ProjectRecord,
   tabId: string,
   text: string,
   options: DispatchOptions
 ): Promise<WorkerOutcome> {
   const { daemon } = await requireTurnCapabilities(ctx)
-  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 attached = attach.tabs.find((tab) => tab.id === tabId)
   if (!attached) throw new Error(`tab not found: ${tabId}`)
   const payload = buildPromptPayload(text, false)
@@ -397,7 +391,7 @@ export async function dispatchWorkerPrompt(
   let resubmits = 0
 
   while (!result.confirmed && resubmits < MAX_UPTAKE_RESUBMITS) {
-    const live = await liveUptake(daemon, workspace.id, tabId, startedAt)
+    const live = await liveUptake(daemon, project.id, tabId, startedAt)
     if (live) {
       result = live
       break
@@ -413,7 +407,7 @@ export async function dispatchWorkerPrompt(
   // Last look before declaring failure: never report a healthy, working worker
   // as pending just because an edge-triggered event was missed.
   if (!result.confirmed) {
-    result = (await liveUptake(daemon, workspace.id, tabId, startedAt)) ?? result
+    result = (await liveUptake(daemon, project.id, tabId, startedAt)) ?? result
   }
 
   if (!result.confirmed) {
@@ -438,19 +432,19 @@ export async function dispatchWorkerPrompt(
  */
 export async function submitWorkerPrompt(
   ctx: CliContext,
-  workspace: SessionRecord,
+  project: ProjectRecord,
   tabId: string,
   uptakeTimeoutMs: number
 ): Promise<WorkerOutcome> {
   const { daemon } = await requireTurnCapabilities(ctx)
-  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((tab) => tab.id === tabId)) throw new Error(`tab not found: ${tabId}`)
   const startedAt = Date.now()
   const uptake = armUptake(daemon, tabId, uptakeTimeoutMs, startedAt)
   await daemon.expectOk('write', { data: '\r', tabId })
   const result = await uptake
   if (!result.confirmed) {
-    const live = await liveUptake(daemon, workspace.id, tabId, startedAt)
+    const live = await liveUptake(daemon, project.id, tabId, startedAt)
     if (live) {
       return { durationMs: Date.now() - startedAt, status: 'dispatched', uptake: live }
     }
@@ -466,15 +460,15 @@ export async function submitWorkerPrompt(
 
 export async function awaitExistingWorker(
   ctx: CliContext,
-  workspace: SessionRecord,
+  project: ProjectRecord,
   tabId: string,
   timeoutMs: number
 ): Promise<WorkerOutcome> {
   const { daemon } = await requireTurnCapabilities(ctx)
   const attach = await daemon.attach({
     cols: 0,
+    projectId: project.id,
     rows: 0,
-    sessionId: workspace.id,
     thin: true,
   })
   const tab = attach.tabs.find((entry) => entry.id === tabId)
@@ -497,19 +491,19 @@ export async function awaitExistingWorker(
 }
 
 /**
- * Versioned envelope. `workspace` is not decoration: without it a caller cannot
+ * Versioned envelope. `project` is not decoration: without it a caller cannot
  * tell which project a worker belongs to, which is how a whole orchestration
  * can run against the wrong repository unnoticed.
  */
 export function workerEnvelope(
-  workspace: SessionRecord,
+  project: ProjectRecord,
   worker: WorkerView,
   outcome?: WorkerOutcome
 ): Record<string, unknown> {
   return {
+    project: projectIdentity(project),
     schemaVersion: WORKER_SCHEMA_VERSION,
     worker,
-    workspace: workspaceIdentity(workspace),
     ...(outcome === undefined ? {} : { outcome }),
   }
 }