@zgeoff/atc 2.33.0 → 2.35.0

package/src/daemon/materialize-workspace.ts

@@ -32,6 +32,11 @@ interface MaterializeRequest {
   // Whether the target is the daemon's own host, where a directory outside
   // any git work tree runs in place instead of being materialized.
   readonly inPlace: boolean;
+
+  // Whether the daemon picked the directory, so one that exists or that
+  // another workspace holds moves the claim to the next attempt's
+  // directory instead of refusing the spawn.
+  readonly autoDir?: boolean;
 }
 
 // The host a workspace lands on, and the directory there it is built in.
@@ -48,8 +53,9 @@ interface MaterializeDeps {
   readonly log: (line: string) => void;
 
   // Readies the host on the target the workspace lands on and resolves to
-  // it, once the source has resolved.
-  readonly readyHost: () => Promise<Landing>;
+  // it, once the source has resolved, with the directory of an attempt: the
+  // first is the request's directory, and attempt n appends `-n` to it.
+  readonly readyHost: (attempt: number) => Promise<Landing>;
 
   // Removes the directory this call claimed after a failure, and resolves
   // to whether it did; one it leaves holds what another session needs, or
@@ -254,12 +260,13 @@ async function runMaterialization(
   const repoURL = secret === null ? pinned.repoURL : toRedacted(pinned.repoURL, secret);
   const ref = secret === null || pinned.ref === null ? pinned.ref : toRedacted(pinned.ref, secret);
 
-  const landing = await deps.readyHost();
-
-  updateProgress({ landing });
+  const landing = await claimLanding(request, deps, updateProgress);
 
-  await claimTargetDir(request, deps, landing, updateProgress);
-  await recordPhase(request, deps, updateProgress, 'cloning', { repoURL, ref });
+  await recordPhase(request, deps, updateProgress, 'cloning', {
+    repoURL,
+    ref,
+    ...(request.autoDir === true ? { dir: landing.dir } : {}),
+  });
 
   const clone = await createCleanClone(pinned, join(staging, 'clone'), transports);
 
@@ -401,6 +408,45 @@ async function requireNoURLCredentials(url: string, cwd: string): Promise<void>
   }
 }
 
+// How many directories a spawn whose directory the daemon picked tries
+// before it refuses.
+const AUTO_DIR_ATTEMPTS = 100;
+
+/**
+ * Readies the host and claims the directory the workspace lands in. A
+ * directory the daemon picked moves to the next attempt while the one
+ * before exists or another workspace holds it, so repeated and concurrent
+ * spawns of one repository land side by side; a directory the caller gave
+ * is claimed once.
+ */
+async function claimLanding(
+  request: MaterializeRequest,
+  deps: MaterializeDeps,
+  updateProgress: ProgressTracker,
+): Promise<Landing> {
+  const attempts = request.autoDir === true ? AUTO_DIR_ATTEMPTS : 1;
+
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      const landing = await deps.readyHost(attempt);
+
+      updateProgress({ landing });
+
+      await claimTargetDir(request, deps, landing, updateProgress);
+
+      return landing;
+    } catch (error) {
+      const held =
+        error instanceof DaemonError &&
+        (error.code === 'workspace_exists' || error.code === 'workspace_overlap');
+
+      if (!held || attempt >= attempts) {
+        throw error;
+      }
+    }
+  }
+}
+
 /**
  * Creates the target directory as the claim on it: `mkdir` without `-p`
  * fails when the directory exists, so a materialization never unpacks over
@@ -412,6 +458,9 @@ async function claimTargetDir(
   landing: Landing,
   updateProgress: ProgressTracker,
 ): Promise<void> {
+  // A directory the daemon picked is reported as it landed.
+  const shown = request.autoDir === true ? landing.dir : request.dir;
+
   const parent = await deps.requireProvider('run').runCommand({
     argv: ['mkdir', '-p', '--', dirname(landing.dir)],
     cwd: '/',
@@ -421,8 +470,8 @@ async function claimTargetDir(
   if (parent.exitCode !== 0) {
     throw new DaemonError(
       'transfer_failed',
-      `cannot create ${dirname(request.dir)} on target '${request.target}': ${parent.stderr.trim()}`,
-      { phase: 'resolving', dir: request.dir },
+      `cannot create ${dirname(shown)} on target '${request.target}': ${parent.stderr.trim()}`,
+      { phase: 'resolving', dir: shown },
     );
   }
 
@@ -430,23 +479,46 @@ async function claimTargetDir(
     .requireProvider('run')
     .runCommand({ argv: ['mkdir', '--', landing.dir], cwd: '/', host: landing.host });
 
+  // A directory that is not there failed for another reason, such as a
+  // parent the command cannot write, which no other attempt would fix.
+  if (claim.exitCode !== 0 && !(await isTargetPathPresent(deps, landing))) {
+    throw new DaemonError(
+      'transfer_failed',
+      `cannot create ${shown} on target '${request.target}': ${claim.stderr.trim()}`,
+      { phase: 'resolving', dir: shown },
+    );
+  }
+
   if (claim.exitCode !== 0) {
     throw new DaemonError(
       'workspace_exists',
-      `${request.dir} already exists on target '${request.target}'; a workspace is materialized only into a directory that does not exist`,
-      { phase: 'resolving', dir: request.dir },
+      `${shown} already exists on target '${request.target}'; a workspace is materialized only into a directory that does not exist`,
+      { phase: 'resolving', dir: shown },
     );
   }
 
   updateProgress({ claimed: true });
 }
 
+// Whether anything, a dangling symlink included, stands at the landing
+// directory's path on its host.
+async function isTargetPathPresent(deps: MaterializeDeps, landing: Landing): Promise<boolean> {
+  const probe = await deps.requireProvider('run').runCommand({
+    argv: ['sh', '-c', '[ -e "$1" ] || [ -L "$1" ]', 'sh', landing.dir],
+    cwd: '/',
+    host: landing.host,
+  });
+
+  return probe.exitCode === 0;
+}
+
 async function recordPhase(
   request: MaterializeRequest,
   deps: MaterializeDeps,
   updateProgress: ProgressTracker,
   phase: MaterializationPhase,
   fields: Readonly<{
+    dir?: string;
     repoURL?: string;
     sha?: string;
     ref?: string | null;

package/src/daemon/restore-fleet.ts

@@ -16,6 +16,12 @@ export interface RestoreFleetParams {
   // it has booted before moving on regardless; zero waits on the signal
   // alone.
   readonly capMs: number;
+
+  // Whether a session spawned without its own choice gets one message to
+  // carry on a turn the previous daemon's stop cut off, and how that
+  // message is sent once the session's terminal is adopted.
+  readonly resumeInterruptedTurns: boolean;
+  readonly sendResumeMessage: (s: Session) => Promise<void>;
 }
 
 /**
@@ -23,7 +29,9 @@ export interface RestoreFleetParams {
  * the rest by recency, registers every one as a terminal-less session so
  * the whole fleet lists at once, then adopts terminals one at a time,
  * waiting for each session to report it has booted before starting the
- * next.
+ * next. A session that was mid-turn when the previous daemon stopped, and
+ * that resumes interrupted turns, gets one message to carry on once its
+ * terminal is adopted.
  */
 export async function restoreFleet(params: RestoreFleetParams): Promise<number> {
   const mgr = params.mgr;
@@ -32,6 +40,7 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   const cols = params.cols;
   const rows = params.rows;
   const capMs = params.capMs;
+  const sendResumeMessage = params.sendResumeMessage;
 
   const hasLiveSession = (entry: FleetEntry) =>
     mgr.sessions.some(
@@ -83,11 +92,33 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
     .filter((r) => r.revive || r.session.state !== 'exited')
     .map((r) => r.session);
 
+  // Only a session this restore registers comes from the previous daemon's
+  // fleet; a listed one this daemon already ran is revived by hand. The
+  // trail is read before any terminal is adopted, since a revived agent's
+  // own events move it on.
+  const interrupted = await collectInterruptedTurns(
+    mgr,
+    store,
+    registered.filter((r) => !r.revive && r.session.state !== 'exited').map((r) => r.session),
+    params.resumeInterruptedTurns,
+  );
+
   // A session whose target refuses to start a terminal stays listed without
-  // one, and the restore moves on to the next.
+  // one, and the restore moves on to the next. A resume message that fails
+  // to send is logged, and the session runs on without it.
   const adoptQueued = async (s: Session): Promise<boolean> => {
     const adopted = await tryAdoptTerminal(mgr, s.id, cols, rows);
 
+    if (adopted !== null && interrupted.has(s.id)) {
+      try {
+        await sendResumeMessage(s);
+      } catch (error) {
+        mgr.log(
+          `atc could not send session ${s.id} its resume message (${error instanceof Error ? error.message : String(error)})`,
+        );
+      }
+    }
+
     return adopted !== null;
   };
 
@@ -174,6 +205,39 @@ export async function restoreFleet(params: RestoreFleetParams): Promise<number>
   return registered.length;
 }
 
+// The sessions whose last turn event in the trail is a submitted prompt:
+// the previous daemon stopped while their turn ran. A session's own choice
+// beats the config, and an agent that takes no atc messages has no path for
+// the resume message. Only a harness on the daemon's own machine ends with
+// the daemon; one on a host with a lifecycle of its own runs on, so its
+// turn was never cut off and a revive attaches to it as it stands.
+async function collectInterruptedTurns(
+  mgr: SessionManager,
+  store: StateStore,
+  sessions: readonly Session[],
+  configured: boolean,
+): Promise<ReadonlySet<SessionID>> {
+  const interrupted = new Set<SessionID>();
+
+  for (const s of sessions) {
+    if (
+      !(s.resumeInterruptedTurns ?? configured) ||
+      s.attachment !== 'local' ||
+      mgr.findAdapter(s.agent)?.takesMessages !== true
+    ) {
+      continue;
+    }
+
+    const kind = await store.findLatestTurnKind(s.id, s.agentSessionID);
+
+    if (kind === 'prompt-submitted') {
+      interrupted.add(s.id);
+    }
+  }
+
+  return interrupted;
+}
+
 // A stored entry matches a listed session by its atc session id, or by its
 // agent session id when a listed session resumed the same agent session.
 function isSameSession(s: Session, entry: FleetEntry): boolean {

package/src/daemon/sessions.ts

@@ -3,6 +3,7 @@ import { posix } from 'node:path';
 import type {
   AgentAdapter,
   GuestPaths,
+  GuestSpawnPlan,
   SpawnOptions,
   SpawnOverrides,
   SpawnPlan,
@@ -183,6 +184,10 @@ export interface Session {
   // The epoch of the session's latest harness start or attach, which the
   // daemon's bridge to that harness is bound to; 0 before the first.
   bridgeEpoch: number;
+
+  // Whether a fleet restore sends the session one message to carry on a
+  // turn a daemon restart cut off; absent follows the daemon's config.
+  resumeInterruptedTurns?: boolean;
 }
 
 // A session's ready workspace and the variables its harnesses go without.
@@ -194,14 +199,18 @@ interface MaterializedSpawn {
 // Builds a spawn's workspace on a target bound to an identity, calling
 // readyHost for the host it lands on once its source resolves and asking
 // canRemoveClaim before a failure removes the directory it claimed, or
-// resolves to null for a directory that runs as it stands.
+// resolves to null for a directory that runs as it stands. readyHost takes
+// the attempt the directory is for: the first is the spawn's directory, and
+// attempt n is that directory with `-n` appended.
 type SpawnMaterializer = (
   host: SpawnHostAccess,
   targetIdentity: string,
 ) => Promise<MaterializedSpawn | null>;
 
 interface SpawnHostAccess {
-  readonly readyHost: () => Promise<{ readonly host: SessionID; readonly dir: string }>;
+  readonly readyHost: (
+    attempt: number,
+  ) => Promise<{ readonly host: SessionID; readonly dir: string }>;
   readonly removeClaim: (dir: string) => Promise<boolean>;
 }
 
@@ -210,7 +219,7 @@ interface SpawnHostAccess {
 interface WorkspaceReservation {
   readonly hostKey: SessionID;
   readonly target: string;
-  readonly dir: string;
+  dir: string;
   resolved: string | null;
 
   // A workspace spawn builds its directory and may remove it on a failure;
@@ -565,6 +574,9 @@ export class SessionManager {
       attachment: this.hasHostLifecycle(target) ? 'detached' : 'local',
       hostKey: entry.hostKey ?? entry.sessionID,
       bridgeEpoch: 0,
+      ...(entry.resumeInterruptedTurns === undefined
+        ? {}
+        : { resumeInterruptedTurns: entry.resumeInterruptedTurns }),
     };
 
     this.sessions.push(session);
@@ -905,6 +917,7 @@ export class SessionManager {
     target = 'local',
     materialize: SpawnMaterializer | null = null,
     requireInReach: () => void = () => {},
+    autoDir = false,
   ): Promise<Session> {
     const adapter = this.findAdapter(agent);
 
@@ -967,9 +980,14 @@ export class SessionManager {
       throw refusal;
     }
 
+    // A directory the daemon picked is checked on the host once per
+    // attempt, so a held one moves the spawn to the next attempt instead of
+    // refusing it.
     if (hostKey !== id) {
       if (materialize === null) {
         this.claimPlainDir(id, hostKey, target, cwd);
+      } else if (autoDir) {
+        this.reservations.set(id, { hostKey, target, dir: cwd, resolved: null, kind: 'workspace' });
       } else {
         this.claimWorkspace(id, hostKey, target, cwd);
       }
@@ -1041,6 +1059,9 @@ export class SessionManager {
       );
     });
 
+    // A spawn whose directory the daemon picked runs in the one it claimed,
+    // as the host resolves it.
+    const dir = autoDir && prepared.root !== null ? prepared.root : cwd;
     const setup = prepared.setup;
     const materialized = prepared.materialized;
     const readied: SpawnReadied = { attemptID: setup.attemptID, root: prepared.root };
@@ -1059,7 +1080,7 @@ export class SessionManager {
         host: hostKey,
         bin: plan.bin,
         args: plan.args,
-        cwd,
+        cwd: dir,
         env: { ...plan.env, ATC_SESSION_ID: id, ATC_SOCKET: socketPath },
         withheldEnv: materialized?.withheldEnv ?? [],
         cols,
@@ -1084,8 +1105,8 @@ export class SessionManager {
 
     const session: Session = {
       id,
-      name,
-      cwd,
+      name: namedBy === 'auto' && dir !== cwd ? posix.basename(dir) : name,
+      cwd: dir,
       kind: 'pty',
       pty,
       state: 'running',
@@ -1095,7 +1116,7 @@ export class SessionManager {
       agent,
       pinned: false,
       lastAttachedAt: Date.now(),
-      repoRoot,
+      repoRoot: dir === cwd ? repoRoot : dir,
       namedBy,
       createdAt: Date.now(),
       parent,
@@ -1112,6 +1133,9 @@ export class SessionManager {
       suspended: false,
       hostKey,
       bridgeEpoch: binding.epoch,
+      ...(overrides.resumeInterruptedTurns === undefined
+        ? {}
+        : { resumeInterruptedTurns: overrides.resumeInterruptedTurns }),
     };
 
     this.attachHarness(session, pty, this.hasHostLifecycle(target));
@@ -1306,6 +1330,7 @@ export class SessionManager {
     if (reservation !== undefined) {
       this.requireSeparateWorkspace(id, hostKey, target, dir, [dir, physical], listed.dirs);
 
+      reservation.dir = dir;
       reservation.resolved = physical;
     }
 
@@ -1535,6 +1560,28 @@ export class SessionManager {
     return existing === '/' ? rest || '/' : `${existing}${rest}`;
   }
 
+  // The home directory of the user commands run as on a host, with every
+  // symlink in it resolved.
+  private async resolveHostHome(provider: ExecutionProvider, hostKey: SessionID): Promise<string> {
+    const result = await provider.runCommand({
+      argv: ['sh', '-c', 'cd && pwd -P'],
+      cwd: '/',
+      host: hostKey,
+    });
+
+    const home = result.stdout.replace(/\n$/u, '');
+
+    if (result.exitCode !== 0 || !posix.isAbsolute(home)) {
+      throw new DaemonError(
+        'host_unavailable',
+        `the host of session ${hostKey} cannot resolve its home directory: ${result.stderr.trim()}`,
+        { phase: 'resolving' },
+      );
+    }
+
+    return home;
+  }
+
   // Materializes a spawn's workspace, readying its host once the source
   // resolves, or after the workspace for a directory that runs as it
   // stands, and returns the directory it created, null for one that runs
@@ -1559,15 +1606,26 @@ export class SessionManager {
       root: null,
     };
 
+    const hostHome: { dir: string | null } = { dir: null };
+
     try {
       const materialized = await materialize(
         {
-          readyHost: async () => {
-            readied.setup = await setupHost();
+          readyHost: async (attempt) => {
+            readied.setup ??= await setupHost();
+
+            // A directory the daemon picked on a remote target is relative
+            // to the home there, which only the readied host can resolve.
+            hostHome.dir ??= posix.isAbsolute(dir)
+              ? ''
+              : await this.resolveHostHome(provider, hostKey);
+
+            const base = posix.isAbsolute(dir) ? dir : posix.join(hostHome.dir, dir);
+            const candidate = attempt === 1 ? base : `${base}-${attempt}`;
 
             const landing = this.hasHostLifecycle(target)
-              ? await this.claimHostDir(provider, id, hostKey, target, dir)
-              : await this.resolveHostDir(provider, null, dir);
+              ? await this.claimHostDir(provider, id, hostKey, target, candidate)
+              : await this.resolveHostDir(provider, null, candidate);
 
             readied.root = landing;
 
@@ -2035,7 +2093,9 @@ export class SessionManager {
     hostKey: SessionID,
     target: string,
     dir: string,
-    planned: Readonly<Record<string, string>>,
+
+    // oxlint-disable-next-line prefer-readonly-parameter-types -- file bytes have no readonly form
+    planned: GuestSpawnPlan['files'],
   ): Promise<void> {
     await provider.prepareHost({
       host: hostKey,
@@ -2058,7 +2118,11 @@ export class SessionManager {
       }
     }
 
-    const files = Object.entries(planned).map(([path, content]) => ({ path, content }));
+    const files = Object.entries(planned).map(([path, file]) =>
+      typeof file === 'string' || file instanceof Uint8Array
+        ? { path, content: file }
+        : { path, content: file.content, mode: file.mode },
+    );
 
     if (files.length > 0) {
       await provider.transferArchive(buildTarArchive(files), dir, hostKey);
@@ -2848,6 +2912,9 @@ export class SessionManager {
         targetIdentity: s.targetIdentity,
         ...(s.desired === 'run' ? {} : { desired: s.desired }),
         ...(s.hostKey === s.id ? {} : { hostKey: s.hostKey }),
+        ...(s.resumeInterruptedTurns === undefined
+          ? {}
+          : { resumeInterruptedTurns: s.resumeInterruptedTurns }),
       });
     }
 

package/src/mcp/mcp-tools.ts

@@ -44,7 +44,9 @@ const DIRS_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
 const SPAWN_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
   z.strictObject({
     daemon: DAEMON_FIELD,
-    cwd: SPAWN_SCHEMA.shape.cwd.describe('Absolute path of the working directory'),
+    cwd: SPAWN_SCHEMA.shape.cwd.describe(
+      "Absolute path of the working directory. Required, except with a git workspace: omit it there and atc picks a new directory under the target user's home, ~/.local/share/atc/workspaces/<repo>-<ref>-<short sha> unless the config sets another root, adding -2, -3, and so on when that directory exists. The session's cwd in the result holds the path it landed in.",
+    ),
     name: SPAWN_SCHEMA.shape.name.describe('Session name; defaults to the directory basename'),
     prompt: SPAWN_SCHEMA.shape.prompt.describe('First message for the session'),
     agent: SPAWN_SCHEMA.shape.agent.describe(SPAWN_AGENT_DESCRIPTION),
@@ -58,11 +60,14 @@ const SPAWN_INPUT: Readonly<Record<string, unknown>> = z.toJSONSchema(
       'Execution target for the new session, one of the target ids in atc_agents_list. Omit it to run on the default target (spawnDefaults.target). An unknown or unavailable target is refused; atc never runs the session on another target instead.',
     ),
     workspace: SPAWN_SCHEMA.shape.workspace.describe(
-      "Where the session's working directory comes from. Omit it to run the session in cwd as it stands. With it, atc materializes a clean checkout into cwd on the target, which must not exist yet: {kind:'path', path, allowDirty?} checks out the pushed HEAD of a git checkout on the atc host, leaving its uncommitted and untracked changes behind with a warning, or refusing them when allowDirty is 'refuse'; {kind:'git', url, ref or sha, credentialRef?} checks out a branch, tag, or full commit of a repository, with credentialRef {kind:'env', name} naming the atc daemon's environment variable that holds its token. A directory outside git runs in place only on a target on the atc host itself (provider local-pty), with cwd equal to its path. Submodules and Git LFS are refused, and so is a URL that carries a credential.",
+      "Where the session's working directory comes from. Omit it to run the session in cwd as it stands. With it, atc materializes a clean checkout into cwd on the target, which must not exist yet, or for a git source without cwd into a directory atc picks: {kind:'path', path, allowDirty?} checks out the pushed HEAD of a git checkout on the atc host, leaving its uncommitted and untracked changes behind with a warning, or refusing them when allowDirty is 'refuse'; {kind:'git', url, ref or sha, credentialRef?} checks out a branch, tag, or full commit of a repository, with credentialRef {kind:'env', name} naming the atc daemon's environment variable that holds its token. A directory outside git runs in place only on a target on the atc host itself (provider local-pty), with cwd equal to its path. Submodules and Git LFS are refused, and so is a URL that carries a credential.",
     ),
     trustClonedWorkspace: SPAWN_SCHEMA.shape.trustClonedWorkspace.describe(
       "Trust the exact verified clone for this launch. An explicit true or false overrides the configured target trustClonedWorkspace default; omitting both keeps trust off. Requires a workspace source and either stock Claude on the local target, which adds trust for the clone root alone to the user's Claude config, or, on an imp target, a brokered Claude gateway or stock Claude signed in through the broker, each with isolated guest config; other launches are refused. Accepts repository configuration and helpers without changing tool permission mode. Existing guest config is preserved.",
     ),
+    resumeInterruptedTurns: SPAWN_SCHEMA.shape.resumeInterruptedTurns.describe(
+      "Whether atc sends the session one message to carry on when a daemon restart cuts off its turn. The message goes out when the fleet is restored, only to a session whose last recorded event was a submitted prompt, and only to an agent that takes atc messages. Omit it to follow the daemon's resumeInterruptedTurns config, which is off by default.",
+    ),
     detached: z
       .boolean()
       .optional()
@@ -418,6 +423,7 @@ export const MCP_TOOLS: readonly MCPToolDefinition[] = [
         target: 'spawn.target',
         workspace: 'spawn.workspace',
         trustClonedWorkspace: 'spawn.workspace.trust',
+        resumeInterruptedTurns: 'spawn.resumeInterruptedTurns',
       },
     },
   },

package/src/mcp/require-daemon-features.ts

@@ -20,11 +20,13 @@ const FEATURE_USES: Readonly<Record<DaemonFeature, string>> = {
   'request.principal': 'the target limits of a remote MCP client',
   'spawn.workspace': "atc_session_spawn's workspace",
   'spawn.workspace.trust': "atc_session_spawn's trustClonedWorkspace",
+  'spawn.workspace.autoDir': "atc_session_spawn's git workspace without a cwd",
   sources: 'sources.list and sources.interpret',
   'git.probe': 'git.probe',
   'transport.tcp': 'a TCP connection to the daemon',
   'idempotency.replayOnly': 'a resend that only replays a held idempotency key',
   'session.auth': 'session.auth.revoke and session.auth.rebind',
+  'spawn.resumeInterruptedTurns': "atc_session_spawn's resumeInterruptedTurns",
 };
 
 /**

package/src/mcp/run-tool.ts

@@ -46,7 +46,7 @@ export function runTool(
 
       const params = {
         ...(typeof args['daemon'] === 'string' ? { daemon: args['daemon'] } : {}),
-        cwd: args['cwd'],
+        ...(args['cwd'] === undefined ? {} : { cwd: args['cwd'] }),
         ...(typeof args['name'] === 'string' ? { name: args['name'] } : {}),
         ...(typeof args['prompt'] === 'string' ? { prompt: args['prompt'] } : {}),
         ...(rawAgent === undefined ? {} : { agent: rawAgent }),
@@ -58,6 +58,9 @@ export function runTool(
         ...(args['trustClonedWorkspace'] === undefined
           ? {}
           : { trustClonedWorkspace: args['trustClonedWorkspace'] }),
+        ...(args['resumeInterruptedTurns'] === undefined
+          ? {}
+          : { resumeInterruptedTurns: args['resumeInterruptedTurns'] }),
         cols: 100,
         rows: 30,
       };
@@ -78,12 +81,24 @@ export function runTool(
       const trustFeatures: readonly DaemonFeature[] =
         args['trustClonedWorkspace'] === undefined ? [] : ['spawn.workspace.trust'];
 
+      const resumeFeatures: readonly DaemonFeature[] =
+        args['resumeInterruptedTurns'] === undefined ? [] : ['spawn.resumeInterruptedTurns'];
+
+      // Only a daemon that picks a git workspace's directory takes one
+      // without a cwd.
+      const autoDirFeatures: readonly DaemonFeature[] =
+        args['cwd'] === undefined && args['workspace'] !== undefined
+          ? ['spawn.workspace.autoDir']
+          : [];
+
       const required = [
         ...optionFeatures,
         ...keyFeatures,
         ...targetFeatures,
         ...workspaceFeatures,
         ...trustFeatures,
+        ...resumeFeatures,
+        ...autoDirFeatures,
       ];
 
       const ok =

package/src/protocol/daemon-features.ts

@@ -50,6 +50,11 @@ export const DAEMON_FEATURES = [
   // `session.spawn` takes an explicit trust decision for a cloned imp workspace.
   'spawn.workspace.trust',
 
+  // `session.spawn` with a git workspace takes no `cwd`, and the daemon
+  // picks a directory under the target user's home that no other
+  // workspace holds.
+  'spawn.workspace.autoDir',
+
   // `session.forget` exists, and a kill of a session asleep on a target that
   // can destroy its host answers `confirmation_required`.
   'session.forget',
@@ -80,6 +85,9 @@ export const DAEMON_FEATURES = [
   // `session.auth.revoke` and `session.auth.rebind` exist, open to the
   // daemon's owner only.
   'session.auth',
+
+  // `session.spawn` takes `resumeInterruptedTurns`.
+  'spawn.resumeInterruptedTurns',
 ] as const;
 
 export type DaemonFeature = (typeof DAEMON_FEATURES)[number];

package/src/protocol/request-param-schemas.ts

@@ -151,7 +151,13 @@ export const REQUEST_PARAM_SCHEMAS = {
     rows: buildTerminalSize(24),
   }),
   'session.spawn': z.object({
-    cwd: z.string({ error: 'session.spawn requires a cwd' }).min(1, 'session.spawn requires a cwd'),
+    // The working directory on the target. A spawn with a git workspace may
+    // leave it out, and the daemon then picks a directory under the target
+    // user's home; every other spawn requires it.
+    cwd: z
+      .string({ error: 'session.spawn requires a cwd' })
+      .min(1, 'session.spawn requires a cwd')
+      .optional(),
     name: buildDefaultedString(''),
     prompt: buildDefaultedString(''),
     cols: buildTerminalSize(80),
@@ -190,6 +196,12 @@ export const REQUEST_PARAM_SCHEMAS = {
       .boolean({ error: 'session.spawn trustClonedWorkspace must be a boolean' })
       .optional(),
 
+    // Whether a fleet restore after a daemon restart sends the session one
+    // message to carry on an interrupted turn; absent follows the config.
+    resumeInterruptedTurns: z
+      .boolean({ error: 'session.spawn resumeInterruptedTurns must be a boolean' })
+      .optional(),
+
     // The session the new one is a sub-session of; absent or empty spawns a
     // top-level session.
     parent: z.preprocess(