@zgeoff/atc 2.33.0 → 2.35.0

package/src/{client → shared}/build-workspace-destination.ts

@@ -1,5 +1,6 @@
 interface DestinationParts {
-  // The root the checkout lands under, absolute on its target.
+  // The root the checkout lands under: absolute on its target, or relative
+  // to the target user's home, where an empty root is the home itself.
   readonly root: string;
 
   // The repository URL the checkout comes from, as the daemon resolved it.
@@ -7,15 +8,18 @@ interface DestinationParts {
 
   // The branch or tag the commit was chosen by, or null for a bare commit.
   readonly ref: string | null;
-  readonly sha: string;
+
+  // The commit checked out, or null when only the ref picks it.
+  readonly sha: string | null;
 }
 
 /**
  * The default directory a git workspace lands in: `<repo>-<ref>-<short
- * sha>` under the root, with the ref left out for a bare commit. The repo
- * is the URL's last path segment without `.git`, and each part keeps only
- * `[A-Za-z0-9._-]`, with `/` turned into `-`, so the name is one path
- * segment on any target.
+ * sha>` under the root, with the ref left out for a bare commit and the
+ * short sha for a ref alone. The repo is the URL's last path segment
+ * without `.git`, and each part keeps only `[A-Za-z0-9._-]`, with `/`
+ * turned into `-`, so the name is one path segment on any target; a name
+ * with nothing left is `workspace`.
  */
 export function buildWorkspaceDestination(parts: DestinationParts): string {
   const repo =
@@ -25,12 +29,19 @@ export function buildWorkspaceDestination(parts: DestinationParts): string {
       .at(-1)
       ?.replace(/\.git$/u, '') ?? '';
 
-  const name = [repo, ...(parts.ref === null ? [] : [parts.ref]), parts.sha.slice(0, 7)]
+  const name = [
+    repo,
+    ...(parts.ref === null ? [] : [parts.ref]),
+    ...(parts.sha === null ? [] : [parts.sha.slice(0, 7)]),
+  ]
     .map((part) => toSafeSegment(part))
     .filter((part) => part !== '')
     .join('-');
 
-  return `${parts.root.replace(/\/+$/u, '')}/${name}`;
+  const segment = name === '' ? 'workspace' : name;
+  const root = parts.root.replace(/\/+$/u, '');
+
+  return parts.root === '' ? segment : `${root}/${segment}`;
 }
 
 function toSafeSegment(part: string): string {

package/src/shared/config.ts

@@ -1,6 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { z } from 'zod';
+import { buildOptionalBoolean } from './build-optional-boolean';
 import { buildOptionalString } from './build-optional-string';
 import { buildOptionalStringArray } from './build-optional-string-array';
 import { collectAuthProfiles } from './collect-auth-profiles';
@@ -65,6 +66,11 @@ export interface Config {
 
   // The workspace config problems, one line each.
   workspaceErrors: readonly string[];
+
+  // Whether a fleet restore after a daemon restart sends a session that
+  // was mid-turn one message to carry on; a spawn can override it per
+  // session.
+  resumeInterruptedTurns: boolean;
 }
 
 /**
@@ -109,6 +115,7 @@ const DEFAULTS: Config = {
   principals: null,
   principalErrors: [],
   workspaceErrors: [],
+  resumeInterruptedTurns: false,
 };
 
 const configDir = join(resolveHomeDir(), '.config', 'atc');
@@ -148,6 +155,7 @@ const CONFIG_SCHEMA = z.object({
   targets: z.unknown().optional(),
   defaultTarget: z.unknown().optional(),
   principals: z.unknown().optional(),
+  resumeInterruptedTurns: buildOptionalBoolean(),
 });
 
 /**
@@ -336,6 +344,7 @@ export function parseConfig(raw: unknown, file: string = configFile): Config {
     principals: principals.principals,
     principalErrors: principals.errors,
     workspaceErrors: workspaces.errors,
+    resumeInterruptedTurns: parsed.data.resumeInterruptedTurns ?? DEFAULTS.resumeInterruptedTurns,
   };
 }
 

package/src/statusline.ts

@@ -1,13 +1,14 @@
 import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { resolveAgentHome } from './agents/resolve-agent-home';
 import { sendBridgeRequest } from './protocol/send-bridge-request';
 import { statusFile } from './shared/config';
 import { isRecord, sendReport } from './shared/report';
 
 /**
  * Runs as the statusLine command injected into wrangled sessions. Chains the
- * user's own statusline (from ~/.claude/settings.json), appends the atc fleet
+ * user's own statusline (from settings.json in the Claude config folder,
+ * `$CLAUDE_CONFIG_DIR` or ~/.claude), appends the atc fleet
  * segment, and heartbeats the session id back to the atc socket, with the
  * agent id the command gave it. Always exits 0 so it never breaks the
  * session it renders for.
@@ -37,7 +38,7 @@ export async function runStatusline(agent: string): Promise<void> {
   let chained = '';
 
   try {
-    const settingsPath = join(homedir(), '.claude', 'settings.json');
+    const settingsPath = join(resolveAgentHome('CLAUDE_CONFIG_DIR', '.claude'), 'settings.json');
     const rawSettings = readFileSync(settingsPath, 'utf8');
     const settings: unknown = JSON.parse(rawSettings);
     const statusLine = isRecord(settings) ? settings['statusLine'] : undefined;

package/src/store/fleet-entry.ts

@@ -67,6 +67,11 @@ export interface FleetEntry {
   // parent's when the two share one host. A row without one runs on a host
   // of its own.
   readonly hostKey?: SessionID;
+
+  // Whether a fleet restore after a daemon restart sends the session one
+  // message to carry on a turn the restart cut off; a row without one
+  // follows the daemon's config.
+  readonly resumeInterruptedTurns?: boolean;
 }
 
 export interface FleetStore {

package/src/store/run-migrations.ts

@@ -34,6 +34,10 @@ interface FleetTable {
   // its parent's when the two share one host. Null for a row from before
   // hosts were recorded, which runs on its own.
   host_key: string | null;
+
+  // Whether a restore sends the session one message to carry on an
+  // interrupted turn: 1 or 0 as the spawn chose, null to follow the config.
+  resume_interrupted_turns: number | null;
 }
 
 interface EventsTable {
@@ -549,6 +553,14 @@ const MIGRATIONS: Record<string, Migration> = {
         .execute();
     },
   },
+  '026_add_fleet_resume_interrupted_turns': {
+    async up(db: Kysely<StateStoreSchema>) {
+      await db.schema
+        .alterTable('fleet')
+        .addColumn('resume_interrupted_turns', 'integer')
+        .execute();
+    },
+  },
 };
 
 const PROVIDER: MigrationProvider = {

package/src/store/state-store.ts

@@ -38,6 +38,7 @@ import type {
 
 // Spelled as the partial index's predicate so SQLite can match them.
 const TRAIL_FILTER = sql<boolean>`kind IS NOT NULL AND kind != 'heartbeat'`;
+const TURN_KINDS = ['prompt-submitted', 'turn-done', 'needs-input', 'ended'];
 
 /**
  * Some sessions' slice of the event trail: rows under their atc ids, plus
@@ -210,6 +211,7 @@ export class StateStore {
         'workspace.withheld_env',
         'fleet.desired',
         'fleet.host_key',
+        'fleet.resume_interrupted_turns',
       ])
       .execute();
 
@@ -239,6 +241,9 @@ export class StateStore {
         ...buildWithheldEnvField(row.withheld_env),
         ...(row.desired === 'sleep' || row.desired === 'stop' ? { desired: row.desired } : {}),
         ...(row.host_key === null ? {} : { hostKey: toSessionID(row.host_key) }),
+        ...(row.resume_interrupted_turns === null
+          ? {}
+          : { resumeInterruptedTurns: row.resume_interrupted_turns !== 0 }),
       });
     }
 
@@ -346,6 +351,10 @@ export class StateStore {
             target_identity: entry.targetIdentity ?? null,
             desired: entry.desired ?? null,
             host_key: entry.hostKey ?? null,
+            resume_interrupted_turns:
+              entry.resumeInterruptedTurns === undefined
+                ? null
+                : Number(entry.resumeInterruptedTurns),
           })
           .execute();
 
@@ -539,6 +548,31 @@ export class StateStore {
     return row?.ts === null || row?.ts === undefined ? null : Date.parse(row.ts);
   }
 
+  // The kind of the session's latest event that moves a turn: a prompt
+  // submitted, a turn done, a request for input, or the session's end.
+  // Null when the trail holds none. Matches the session by either id, as
+  // the activity read does.
+  async findLatestTurnKind(
+    atcID: SessionID,
+    agentSessionID: AgentSessionID | undefined,
+  ): Promise<string | null> {
+    const row = await this.db
+      .selectFrom('events')
+      .select('kind')
+      .where('kind', 'in', TURN_KINDS)
+      .where((eb) =>
+        eb.or([
+          eb('atc_id', '=', atcID),
+          ...(agentSessionID === undefined ? [] : [eb('session_id', '=', agentSessionID)]),
+        ]),
+      )
+      .orderBy('id', 'desc')
+      .limit(1)
+      .executeTakeFirst();
+
+    return row?.kind ?? null;
+  }
+
   async recordSpawnDir(cwd: string, grant: SpawnTarget): Promise<void> {
     await this.db
       .insertInto('spawn_history')
@@ -939,6 +973,7 @@ export class StateStore {
       .updateTable('workspace_materialization')
       .set({
         phase: fields.phase,
+        ...(fields.dir === undefined ? {} : { dir: fields.dir }),
         ...(fields.repoURL === undefined ? {} : { repo_url: fields.repoURL }),
         ...(fields.sha === undefined ? {} : { sha: fields.sha }),
         ...(fields.ref === undefined ? {} : { ref: fields.ref }),

package/src/store/workspace-materialization.ts

@@ -50,6 +50,10 @@ export interface WorkspaceMaterialization {
 // The fields a materialization rewrites as it moves through its phases.
 export interface MaterializationUpdate {
   readonly phase: MaterializationPhase;
+
+  // The directory the workspace landed in, once a directory the daemon
+  // picked is claimed.
+  readonly dir?: string;
   readonly repoURL?: string;
   readonly sha?: string;
   readonly ref?: string | null;