@brimveyn/aimux 1.20.4 → 1.22.0

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 }),
   }
 }

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

@@ -3,10 +3,10 @@ import type { CliCommand } from '../../registry'
 import { isGitWorktreeDirty, removeGitWorktree } from '../../../git/worktree'
 import {
   IPC_CAPABILITY_THIN_ATTACH,
-  IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS,
+  IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS,
 } from '../../../ipc/protocol'
 import { pruneEmptyWorktreeParent } from '../../../platform/worktree-paths'
-import { workspaceIdentity } from '../../client/workspace-resolver'
+import { projectIdentity } from '../../client/project-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, EXIT_RUNTIME, writeJson } from '../../output'
 import { resolveWorkerTarget, WORKER_SCHEMA_VERSION, workerView } from './shared'
@@ -16,45 +16,45 @@ export const workerStop: CliCommand = {
   flags: [
     ...SHARED_FLAGS,
     {
-      description: 'remove its aimux-created worktree after closing the tab',
+      description: 'remove its aimux-created workspace after closing the tab',
       kind: 'boolean',
-      name: 'cleanup-worktree',
+      name: 'cleanup-workspace',
     },
-    { description: 'force removal of a dirty worktree', kind: 'boolean', name: 'force' },
+    { description: 'force removal of a dirty workspace', kind: 'boolean', name: 'force' },
   ],
   group: 'worker',
   run: async (ctx) => {
-    const { tab, workspace } = await resolveWorkerTarget(ctx, ctx.args.positionals[0] ?? '')
-    const worker = workerView(workspace, tab)
+    const { project, tab } = await resolveWorkerTarget(ctx, ctx.args.positionals[0] ?? '')
+    const worker = workerView(project, tab)
     const daemon = await ctx.getDaemon()
-    const cleanup = ctx.args.flags['cleanup-worktree'] === true
+    const cleanup = ctx.args.flags['cleanup-workspace'] === true
     const record =
-      tab.worktreeId === undefined
+      tab.workspaceId === undefined
         ? undefined
-        : workspace.worktrees?.find((worktree) => worktree.id === tab.worktreeId)
+        : project.workspaces?.find((workspace) => workspace.id === tab.workspaceId)
 
     if (cleanup) {
-      if (record === undefined) throw new Error('worker has no registered worktree to clean up')
+      if (record === undefined) throw new Error('worker has no registered workspace to clean up')
       if (record.source !== 'aimux-temp' || !record.createdByAimux) {
-        throw new Error('refusing to clean up a primary or externally managed worktree')
+        throw new Error('refusing to clean up a primary or externally managed workspace')
       }
-      const siblings = (await daemon.listTabs(workspace.id)).tabs.filter(
-        (entry) => entry.id !== tab.id && entry.worktreeId === record.id
+      const siblings = (await daemon.listTabs(project.id)).tabs.filter(
+        (entry) => entry.id !== tab.id && entry.workspaceId === record.id
       )
       if (siblings.length > 0) {
         throw new Error(
-          `refusing to clean up shared worktree; live tabs: ${siblings.map((entry) => entry.id).join(', ')}`
+          `refusing to clean up shared workspace; live tabs: ${siblings.map((entry) => entry.id).join(', ')}`
         )
       }
-      if (!daemon.hasCapability(IPC_CAPABILITY_WORKTREE_LIFECYCLE_EVENTS)) {
-        throw new Error('daemon predates safe worktree cleanup — restart aimux')
+      if (!daemon.hasCapability(IPC_CAPABILITY_WORKSPACE_LIFECYCLE_EVENTS)) {
+        throw new Error('daemon predates safe workspace cleanup — restart aimux')
       }
       if (ctx.args.flags.force !== true && (await isGitWorktreeDirty(record.path))) {
-        throw new Error('refusing to clean up a dirty worktree without --force')
+        throw new Error('refusing to clean up a dirty workspace without --force')
       }
     }
 
-    // `closeTab` is session-scoped on the daemon, so it fails with "No session
+    // `closeTab` is project-scoped on the daemon, so it fails with "No project
     // attached" unless this connection has attached first. Every other worker
     // verb thin-attaches; this one did not, which made teardown the one step of
     // the documented lifecycle a headless orchestrator could not complete.
@@ -63,10 +63,10 @@ export const workerStop: 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 })
 
     // Teardown is two independent effects. Report them independently: a failed
-    // tab close must not strand a merged worktree on disk with no way to remove
+    // tab close must not strand a merged workspace on disk with no way to remove
     // it through aimux (the alternative — a bare `git worktree remove` — desyncs
     // the catalog from disk).
     let closeError: string | undefined
@@ -77,7 +77,7 @@ export const workerStop: CliCommand = {
       if (!cleanup) throw error
     }
 
-    let worktreeRemoved = false
+    let workspaceRemoved = false
     if (cleanup && record !== undefined) {
       await removeGitWorktree({
         force: ctx.args.flags.force === true,
@@ -86,9 +86,9 @@ export const workerStop: CliCommand = {
       })
       await pruneEmptyWorktreeParent(record.path)
       try {
-        await daemon.expectOk('removeWorktreeRecord', {
-          sessionId: workspace.id,
-          worktreeId: record.id,
+        await daemon.expectOk('removeWorkspaceRecord', {
+          projectId: project.id,
+          workspaceId: record.id,
         })
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error)
@@ -96,18 +96,18 @@ export const workerStop: CliCommand = {
           `worker stopped and git worktree removed, but catalog reconciliation failed: ${message}`
         )
       }
-      worktreeRemoved = true
+      workspaceRemoved = true
     }
     writeJson({
       closed: closeError === undefined,
       ...(closeError === undefined ? {} : { closeError }),
+      project: projectIdentity(project),
       schemaVersion: WORKER_SCHEMA_VERSION,
       worker,
-      workspace: workspaceIdentity(workspace),
-      worktreeRemoved,
+      workspaceRemoved,
     })
     return closeError === undefined ? EXIT_OK : EXIT_RUNTIME
   },
-  summary: 'Stop a named worker and optionally clean up its worktree',
+  summary: 'Stop a named worker and optionally clean up its workspace',
   verb: 'stop',
 }

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

@@ -23,16 +23,16 @@ export const workerSubmit: 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 submitWorkerPrompt(
       ctx,
-      workspace,
+      project,
       tab.id,
       typeof ctx.args.flags['uptake-timeout'] === 'number'
         ? ctx.args.flags['uptake-timeout']
         : DETACH_UPTAKE_TIMEOUT_MS
     )
-    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
+    writeJson(workerEnvelope(project, workerView(project, tab), outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: 'Submit a prompt already sitting in a worker composer and confirm uptake',