@brimveyn/aimux 1.20.1 → 1.20.3

package/src/auto-rename/title-runner.ts

@@ -1,10 +1,21 @@
 import { buildHeadlessInvocation, type HeadlessInvocation } from '../auto-commit/headless-commands'
+import { clampTitle } from './title-format'
 
 export type TitleSpawnFn = (
   invocation: HeadlessInvocation,
   signal: AbortSignal
 ) => Promise<{ stdout: string; exitCode: number } | null>
 
+/**
+ * `failed` is retryable — a later prompt may well produce a usable title.
+ * `unavailable` is not: the provider has no headless mode or its binary is not
+ * installed, so the coordinator should stop burning attempts and fall back.
+ */
+export type TitleResult =
+  | { status: 'ok'; title: string }
+  | { status: 'failed' }
+  | { status: 'unavailable' }
+
 export function buildTitlePrompt(firstPrompt: string): string {
   return [
     'Create a concise tab title for the user request below.',
@@ -23,24 +34,16 @@ export function sanitizeGeneratedTitle(raw: string): string | null {
   if (first == null || first === '') return null
 
   const unlabelled = first.replace(/^TITLE\s*:\s*/iu, '').replaceAll(/^["'“”‘’]+|["'“”‘’]+$/gu, '')
-  const clean = unlabelled
-    .replaceAll(/\s+/gu, ' ')
-    .replace(/[.!?,;:…]+$/u, '')
-    .trim()
-  const words = clean.split(' ').filter(Boolean)
-  const usesUnspacedScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(clean)
-  if (words.length < 2 && !usesUnspacedScript) return null
+  return clampTitle(unlabelled)
+}
 
-  let title = words.slice(0, 6).join(' ')
-  if (title.length > 48) {
-    title = title
-      .slice(0, 48)
-      .replace(/\s+\S*$/u, '')
-      .trim()
+function executableOnPath(executable: string): boolean {
+  try {
+    return typeof Bun !== 'undefined' && Bun.which(executable) != null
+  } catch {
+    // Never let a lookup failure mask a provider that would have worked.
+    return true
   }
-  return title === '' || (title.split(' ').filter(Boolean).length < 2 && !usesUnspacedScript)
-    ? null
-    : title
 }
 
 export async function generateTabTitle(options: {
@@ -50,21 +53,29 @@ export async function generateTabTitle(options: {
   timeoutMs: number
   signal: AbortSignal
   spawn?: TitleSpawnFn
-}): Promise<string | null> {
+  isExecutableAvailable?: (executable: string) => boolean
+}): Promise<TitleResult> {
   const invocation = buildHeadlessInvocation(
     options.provider,
     buildTitlePrompt(options.firstPrompt),
     options.model
   )
-  if (!invocation) return null
+  if (!invocation) return { status: 'unavailable' }
+
+  // A caller-supplied spawn does not go through PATH, so only probe it for the
+  // real one. Probing lets a missing CLI fail instantly instead of after the
+  // full timeout, once per tab instead of once per attempt.
+  const available = options.isExecutableAvailable ?? (options.spawn ? null : executableOnPath)
+  if (available && !available(invocation.executable)) return { status: 'unavailable' }
 
   const signal = AbortSignal.any([options.signal, AbortSignal.timeout(options.timeoutMs)])
   try {
     const result = await (options.spawn ?? defaultSpawn)(invocation, signal)
-    if (!result || result.exitCode !== 0 || signal.aborted) return null
-    return sanitizeGeneratedTitle(result.stdout)
+    if (!result || result.exitCode !== 0 || signal.aborted) return { status: 'failed' }
+    const title = sanitizeGeneratedTitle(result.stdout)
+    return title == null ? { status: 'failed' } : { status: 'ok', title }
   } catch {
-    return null
+    return { status: 'failed' }
   }
 }
 

package/src/cli/client/workspace-resolver.ts

@@ -1,17 +1,55 @@
-import type { SessionRecord } from '../../state/types'
+import type { SessionRecord, WorktreeRecord } from '../../state/types'
 
 import { findMostRecentSession, loadSessionCatalog } from '../../state/session-catalog'
 
 /**
- * Resolve `--workspace W` to a session record from the catalog. Falls back to
- * the most recently opened session when the flag is absent. Throws when the
- * catalog is empty (no session has ever been created) or when the explicit
- * name/id doesn't match.
+ * Where a command's target workspace came from. An orchestrator needs this to
+ * tell "I asked for pragma-once" from "aimux guessed, and the UI had moved on":
+ * `active` is the only origin that can silently follow the UI to another repo.
+ */
+export type WorkspaceOrigin = 'flag' | 'env' | 'active'
+
+export interface ResolvedWorkspace {
+  origin: WorkspaceOrigin
+  record: SessionRecord
+}
+
+/** Env pin for headless orchestrators — `--workspace` still wins over it. */
+export const WORKSPACE_ENV_VAR = 'AIMUX_WORKSPACE'
+
+/** The workspace's primary (root) worktree, i.e. the repository it is about. */
+export function findPrimaryWorktree(session: SessionRecord): WorktreeRecord | undefined {
+  return session.worktrees?.find((worktree) => worktree.source === 'primary')
+}
+
+/**
+ * The repo every fresh worktree for this workspace is cut from. Surfaced in
+ * every worker envelope so an agent can see *which project* it just acted on
+ * instead of inferring it from a worktree path hash.
+ */
+export function workspaceRepoRoot(session: SessionRecord): string | null {
+  return findPrimaryWorktree(session)?.repoRoot ?? session.projectPath ?? null
+}
+
+/** Stable workspace identity block embedded in command output. */
+export function workspaceIdentity(session: SessionRecord): {
+  id: string
+  name: string
+  repoRoot: string | null
+} {
+  return { id: session.id, name: session.name, repoRoot: workspaceRepoRoot(session) }
+}
+
+/**
+ * Resolve `--workspace W` to a session record from the catalog, reporting where
+ * the choice came from. Precedence: the explicit flag, then `AIMUX_WORKSPACE`,
+ * then the most recently opened session. Throws when the catalog is empty (no
+ * session has ever been created) or when the explicit name/id doesn't match.
  *
  * Matching: exact id wins; otherwise exact name (case-sensitive); otherwise
  * unique case-insensitive name match.
  */
-export function resolveWorkspace(name: string | undefined): SessionRecord {
+export function resolveWorkspaceWithOrigin(name: string | undefined): ResolvedWorkspace {
   const sessions = loadSessionCatalog()
   if (sessions.length === 0) {
     throw new Error(
@@ -19,14 +57,29 @@ export function resolveWorkspace(name: string | undefined): SessionRecord {
     )
   }
 
-  if (name === undefined || name === '') {
+  const flag = name !== undefined && name !== '' ? name : undefined
+  const env = process.env[WORKSPACE_ENV_VAR]
+  const fromEnv = env != null && env !== '' ? env : undefined
+  const selector = flag ?? fromEnv
+  if (selector === undefined) {
     const active = findMostRecentSession(sessions)
     if (!active) {
       throw new Error('no active workspace and the catalog is empty')
     }
-    return active
+    return { origin: 'active', record: active }
+  }
+
+  return {
+    origin: flag !== undefined ? 'flag' : 'env',
+    record: matchWorkspace(sessions, selector),
   }
+}
+
+export function resolveWorkspace(name: string | undefined): SessionRecord {
+  return resolveWorkspaceWithOrigin(name).record
+}
 
+function matchWorkspace(sessions: SessionRecord[], name: string): SessionRecord {
   const byId = sessions.find((session) => session.id === name)
   if (byId) return byId
 

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

@@ -27,7 +27,7 @@ import { awaitTurn, DEFAULT_TIMEOUT_MS, type TurnOutcome, turnOutcomeExitCode }
 const QUESTION_TAIL_LINES = 25
 
 export const tabAwait: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: [
     ...SHARED_FLAGS,
     {

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

@@ -5,7 +5,7 @@ import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
 export const tabClose: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: SHARED_FLAGS,
   group: 'tab',
   run: async (ctx) => {

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

@@ -13,6 +13,7 @@ import {
   IPC_CAPABILITY_WORKER_METADATA,
 } from '../../../ipc/protocol'
 import { createPrefixedId } from '../../../platform/id'
+import { pruneEmptyWorktreeParent } from '../../../platform/worktree-paths'
 import {
   type AssistantOption,
   buildAssistantModelArgs,
@@ -98,6 +99,7 @@ async function rollbackCreatedWorktree(
       repoPath: record.repoRoot,
       targetPath: record.path,
     })
+    await pruneEmptyWorktreeParent(record.path)
     await daemon.expectOk('removeWorktreeRecord', {
       sessionId: workspace.id,
       worktreeId: record.id,
@@ -272,39 +274,61 @@ export const tabCreate: CliCommand = {
   flags: [
     ...SHARED_FLAGS,
     {
+      complete: { kind: 'dynamic', source: 'assistant' },
       description: 'assistant id (claude, codex, opencode, grok, kimi, terminal, ...)',
       kind: 'string',
       name: 'assistant',
     },
-    { description: 'tab title (defaults to assistant label)', kind: 'string', name: 'title' },
-    { description: 'cwd for the spawned PTY', kind: 'string', name: 'cwd' },
     {
+      complete: { kind: 'none' },
+      description: 'tab title (defaults to assistant label)',
+      kind: 'string',
+      name: 'title',
+    },
+    {
+      complete: { kind: 'file' },
+      description: 'cwd for the spawned PTY',
+      kind: 'string',
+      name: 'cwd',
+    },
+    {
+      complete: { kind: 'none' },
       description: 'explicit command (overrides the assistant default)',
       kind: 'string',
       name: 'command',
     },
     {
+      complete: { kind: 'none' },
       description: 'model for the worker (maps to the assistant’s model flag)',
       kind: 'string',
       name: 'model',
     },
     {
+      complete: { kind: 'none' },
       description: 'reasoning-effort level (maps to the assistant’s effort flag)',
       kind: 'string',
       name: 'effort',
     },
     {
+      complete: { kind: 'dynamic', source: 'worktree' },
       description: 'worktree id the tab belongs to (defaults to the workspace’s active worktree)',
       kind: 'string',
       name: 'worktree',
     },
     {
+      complete: { kind: 'none' },
       description: 'create a fresh worktree for this tab (optionally named: --new-worktree=<name>)',
       kind: 'optional-string',
       name: 'new-worktree',
     },
-    { description: 'base ref for --new-worktree (default HEAD)', kind: 'string', name: 'base' },
     {
+      complete: { kind: 'dynamic', source: 'git-ref' },
+      description: 'base ref for --new-worktree (default HEAD)',
+      kind: 'string',
+      name: 'base',
+    },
+    {
+      complete: { kind: 'none' },
       description: 'branch for --new-worktree (default aimux/<name>)',
       kind: 'string',
       name: 'branch',

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

@@ -5,7 +5,7 @@ import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
 
 export const tabFocus: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: SHARED_FLAGS,
   group: 'tab',
   run: async (ctx) => {

package/src/cli/commands/tab/prompt-io.ts

@@ -92,7 +92,12 @@ export async function writePromptPayload(
   payload: PromptPayload,
   appendEnter: boolean
 ): Promise<number> {
-  await daemon.expectOk('write', { data: payload.data, tabId })
+  // Skip a zero-length write: "submit only" (empty payload + --enter) is a
+  // legitimate operation, but a 0-byte write reaches the pty as an empty
+  // ArrayBufferView and surfaces a raw Bun ERR_INVALID_ARG_TYPE to the user.
+  if (payload.data !== '') {
+    await daemon.expectOk('write', { data: payload.data, tabId })
+  }
   let bytesWritten = Buffer.byteLength(payload.data, 'utf8')
   if (appendEnter) {
     // A bracketed paste swallows a same-burst `\r`, so settle first, then

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

@@ -20,10 +20,18 @@ import { awaitTurn, DEFAULT_TIMEOUT_MS, turnOutcomeExitCode } from './await-turn
 import { buildPromptPayload, resolvePromptText, writePromptPayload } from './prompt-io'
 
 export const tabRun: CliCommand = {
-  args: [{ name: 'tabId', required: true }, { name: 'text' }],
+  args: [
+    { complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true },
+    { complete: { kind: 'none' }, name: 'text' },
+  ],
   flags: [
     ...SHARED_FLAGS,
-    { description: 'read the prompt from this file', kind: 'string', name: 'prompt-file' },
+    {
+      complete: { kind: 'file' },
+      description: 'read the prompt from this file',
+      kind: 'string',
+      name: 'prompt-file',
+    },
     { description: 'read the prompt from stdin', kind: 'boolean', name: 'stdin' },
     {
       description: 'overall turn cap in milliseconds (default 900000 = 15 min)',

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

@@ -9,7 +9,10 @@ import { buildPromptPayload, writePromptPayload } from './prompt-io'
 const DEFAULT_AWAIT_TIMEOUT_MS = 15_000
 
 export const tabSend: CliCommand = {
-  args: [{ name: 'tabId', required: true }, { name: 'text' }],
+  args: [
+    { complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true },
+    { complete: { kind: 'none' }, name: 'text' },
+  ],
   flags: [
     ...SHARED_FLAGS,
     { description: 'append \\r so the receiving CLI submits', kind: 'boolean', name: 'enter' },
@@ -24,6 +27,7 @@ export const tabSend: CliCommand = {
       name: 'stdin',
     },
     {
+      complete: { kind: 'file' },
       description: 'read the payload from this file instead of <text>',
       kind: 'string',
       name: 'prompt-file',
@@ -59,12 +63,13 @@ export const tabSend: CliCommand = {
         ? ctx.args.flags['await-timeout']
         : DEFAULT_AWAIT_TIMEOUT_MS
 
-    // Uptake only means something once we actually submit the prompt: the
-    // working transition is the receiving CLI accepting the Enter. Without
-    // --enter there is nothing to confirm, so fail loudly rather than block
-    // forever on a transition that can't come.
-    if (awaitSubmit && !appendEnter) {
-      throw new Error('--await-submit requires --enter')
+    // Uptake only means something once something submits: either the appended
+    // `\r` (--enter) or a chord that carries its own submit (--keys "<CR>",
+    // which is the recovery path for a prompt already sitting in a composer).
+    // Without one of those there is nothing to confirm, so fail loudly rather
+    // than block forever on a transition that can't come.
+    if (awaitSubmit && !appendEnter && !asKeys) {
+      throw new Error('--await-submit requires --enter or --keys (the chord carries the submit)')
     }
 
     // At most one payload source. Unlike `tab run`, zero sources is valid here

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

@@ -9,11 +9,12 @@ import { snapshotTailLines, snapshotToLines } from '../../snapshot-render'
 const RENDER_WAIT_MS = 500
 
 export const tabSnapshot: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: [
     ...SHARED_FLAGS,
     { description: 'return only the last N non-blank lines', kind: 'number', name: 'tail' },
     {
+      complete: { kind: 'values', values: ['json', 'text'] },
       description: 'output format: json (default) or text (raw screen dump)',
       kind: 'string',
       name: 'format',

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

@@ -21,7 +21,7 @@ function toCursor(snapshot: TerminalSnapshot): Cursor {
 }
 
 export const tabTail: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: [
     ...SHARED_FLAGS,
     {

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

@@ -12,10 +12,11 @@ function isTabActivity(value: string): value is TabActivity {
 }
 
 export const tabWait: CliCommand = {
-  args: [{ name: 'tabId', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'tab' }, name: 'tabId', required: true }],
   flags: [
     ...SHARED_FLAGS,
     {
+      complete: { kind: 'values', values: ['idle', 'waiting-input', 'working'] },
       description: 'target activity (idle | working | waiting-input)',
       kind: 'string',
       name: 'status',

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

@@ -5,27 +5,28 @@ import { writeJson } from '../../output'
 import { DEFAULT_TIMEOUT_MS } from '../tab/await-turn'
 import {
   awaitExistingWorker,
-  resolveWorkerTab,
+  resolveWorkerTarget,
   workerEnvelope,
   workerOutcomeExitCode,
   workerView,
 } from './shared'
 
 export const workerAwait: CliCommand = {
-  args: [{ name: 'worker', required: true }],
+  args: [{ complete: { kind: 'dynamic', source: 'worker' }, name: 'worker', required: true }],
   flags: [
     ...SHARED_FLAGS,
     { description: 'overall turn cap in milliseconds', kind: 'number', name: 'timeout' },
   ],
   group: 'worker',
   run: async (ctx) => {
-    const tab = await resolveWorkerTab(ctx, ctx.args.positionals[0] ?? '')
+    const { tab, workspace } = await resolveWorkerTarget(ctx, ctx.args.positionals[0] ?? '')
     const outcome = await awaitExistingWorker(
       ctx,
+      workspace,
       tab.id,
       typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS
     )
-    writeJson(workerEnvelope(workerView(ctx, tab), outcome))
+    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: "Await an existing worker's in-flight turn",

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

@@ -18,6 +18,11 @@ import {
   isCommandAvailable,
   parseCommand,
 } from '../../../pty/command-registry'
+import {
+  findPrimaryWorktree,
+  WORKSPACE_ENV_VAR,
+  workspaceRepoRoot,
+} from '../../client/workspace-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, EXIT_RUNTIME, writeJson } from '../../output'
 import { WORKER_SCHEMA_VERSION } from './shared'
@@ -56,7 +61,8 @@ export const workerDoctor: CliCommand = {
     const missingManagerCapabilities = [MANAGER_CAPABILITY_WORKER_METADATA].filter(
       (capability) => !managerCapabilities.includes(capability)
     )
-    const primaryWorktree = workspace.worktrees?.find((worktree) => worktree.source === 'primary')
+    const primaryWorktree = findPrimaryWorktree(workspace)
+    const workspaceOrigin = ctx.getWorkspaceOrigin?.() ?? 'active'
     const availableAssistants = assistants.filter((assistant) => assistant.available)
     const skillPath = fileURLToPath(
       new URL('../../../../skills/aimux-orchestrator/', import.meta.url)
@@ -81,6 +87,16 @@ 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
+    // 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') {
+      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}`
+      )
+    }
     const ready = issues.length === 0
     writeJson({
       assistants,
@@ -100,7 +116,12 @@ export const workerDoctor: CliCommand = {
         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),
+          /** 'flag' | 'env' | 'active'; only 'active' can follow the UI. */
+          source: workspaceOrigin,
         },
       },
       cliVersion: version,
@@ -116,10 +137,13 @@ export const workerDoctor: CliCommand = {
       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

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

@@ -1,22 +1,64 @@
 import type { CliCommand } from '../../registry'
 
+import { workspaceIdentity } from '../../client/workspace-resolver'
 import { SHARED_FLAGS } from '../../flags'
 import { EXIT_OK, writeJson } from '../../output'
-import { listNamedWorkerTabs, resolveWorkerTab, WORKER_SCHEMA_VERSION, workerView } from './shared'
+import {
+  listNamedWorkerTabs,
+  listWorkerTargets,
+  resolveWorkerTarget,
+  WORKER_SCHEMA_VERSION,
+  workerView,
+} from './shared'
 
 export const workerList: CliCommand = {
-  args: [{ name: 'worker' }],
-  flags: SHARED_FLAGS,
+  args: [{ complete: { kind: 'dynamic', source: 'worker' }, name: 'worker' }],
+  flags: [
+    ...SHARED_FLAGS,
+    {
+      description: 'list workers in every catalogued workspace, not just the target one',
+      kind: 'boolean',
+      name: 'all-workspaces',
+    },
+  ],
   group: 'worker',
   run: async (ctx) => {
     const selector = ctx.args.positionals[0]
-    const tabs =
-      selector === undefined
-        ? await listNamedWorkerTabs(ctx)
-        : [await resolveWorkerTab(ctx, selector)]
+
+    // `{"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"
+    // rather than "gone", and offer one call that answers "are they really gone?"
+    if (ctx.args.flags['all-workspaces'] === 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),
+          })),
+      })
+      return EXIT_OK
+    }
+
+    if (selector !== undefined) {
+      const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
+      writeJson({
+        schemaVersion: WORKER_SCHEMA_VERSION,
+        workers: [workerView(workspace, tab)],
+        workspace: workspaceIdentity(workspace),
+      })
+      return EXIT_OK
+    }
+
+    const workspace = ctx.getWorkspace()
+    const tabs = await listNamedWorkerTabs(ctx, workspace)
     writeJson({
       schemaVersion: WORKER_SCHEMA_VERSION,
-      workers: tabs.map((tab) => workerView(ctx, tab)),
+      workers: tabs.map((tab) => workerView(workspace, tab)),
+      workspace: workspaceIdentity(workspace),
     })
     return EXIT_OK
   },

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

@@ -6,17 +6,25 @@ import { DEFAULT_TIMEOUT_MS } from '../tab/await-turn'
 import { resolvePromptText } from '../tab/prompt-io'
 import {
   dispatchWorkerPrompt,
-  resolveWorkerTab,
+  resolveWorkerTarget,
   workerEnvelope,
   workerOutcomeExitCode,
   workerView,
 } from './shared'
 
 export const workerPrompt: CliCommand = {
-  args: [{ name: 'worker', required: true }, { name: 'text' }],
+  args: [
+    { complete: { kind: 'dynamic', source: 'worker' }, name: 'worker', required: true },
+    { complete: { kind: 'none' }, name: 'text' },
+  ],
   flags: [
     ...SHARED_FLAGS,
-    { description: 'read the prompt from this file', kind: 'string', name: 'prompt-file' },
+    {
+      complete: { kind: 'file' },
+      description: 'read the prompt from this file',
+      kind: 'string',
+      name: 'prompt-file',
+    },
     { description: 'read the prompt from stdin', kind: 'boolean', name: 'stdin' },
     {
       description: 'return after prompt uptake instead of turn completion',
@@ -24,11 +32,23 @@ export const workerPrompt: CliCommand = {
       name: 'detach',
     },
     { description: 'overall turn cap in milliseconds', kind: 'number', name: 'timeout' },
+    {
+      description:
+        'milliseconds to wait for the detached submit→working confirmation (default 15000)',
+      kind: 'number',
+      name: 'uptake-timeout',
+    },
+    {
+      description:
+        'clear the composer (<C-u>) before writing, so text typed by a human in the UI cannot be concatenated onto this prompt',
+      kind: 'boolean',
+      name: 'replace',
+    },
   ],
   group: 'worker',
   run: async (ctx) => {
     const selector = ctx.args.positionals[0] ?? ''
-    const tab = await resolveWorkerTab(ctx, selector)
+    const { tab, workspace } = await resolveWorkerTarget(ctx, selector)
     const promptFile =
       typeof ctx.args.flags['prompt-file'] === 'string' ? ctx.args.flags['prompt-file'] : undefined
     const text = await resolvePromptText(
@@ -36,12 +56,17 @@ export const workerPrompt: CliCommand = {
       ctx.args.flags.stdin === true,
       ctx.args.positionals[1]
     )
-    const outcome = await dispatchWorkerPrompt(ctx, tab.id, text, {
+    const outcome = await dispatchWorkerPrompt(ctx, workspace, tab.id, text, {
       detach: ctx.args.flags.detach === true,
+      replace: ctx.args.flags.replace === true,
       timeoutMs:
         typeof ctx.args.flags.timeout === 'number' ? ctx.args.flags.timeout : DEFAULT_TIMEOUT_MS,
+      uptakeTimeoutMs:
+        typeof ctx.args.flags['uptake-timeout'] === 'number'
+          ? ctx.args.flags['uptake-timeout']
+          : undefined,
     })
-    writeJson(workerEnvelope(workerView(ctx, tab), outcome))
+    writeJson(workerEnvelope(workspace, workerView(workspace, tab), outcome))
     return workerOutcomeExitCode(outcome)
   },
   summary: 'Prompt an existing named worker and await its outcome',