agor-live 0.18.0 → 0.19.1

package/dist/daemon/utils/build-initial-user-message.d.ts

@@ -0,0 +1,47 @@
+import { SessionID, TaskID, ContentBlock, MessageType, Message } from '@agor/core/types';
+
+/**
+ * buildInitialUserMessage
+ *
+ * Constructs the canonical "first message of a task" row written by
+ * both:
+ *
+ *   - `/sessions/:id/prompt` (the textarea / MCP entry point) when
+ *     the `daemon_writes_user_message` kill switch is enabled. Each
+ *     turn opens a new task and the user prompt is its first message.
+ *   - The Claude Code CLI watcher's terminal-direct branch
+ *     (`buildCliEventSink`) when claude's JSONL transcript fires a
+ *     `user_message` event for a turn that didn't come through
+ *     `/prompt`. The watcher mints a task on the fly and writes the
+ *     user row itself.
+ *
+ * Without this helper the two call sites would drift independently —
+ * `content_preview` length, metadata shape, type discriminator, etc.
+ * Keep the row shape here; the caller picks `type` ('user' vs the
+ * 'system' callback variant) and supplies `metadata`.
+ *
+ * Pure function — no DB write, no service call. Caller does
+ * `app.service('messages').create(buildInitialUserMessage(...))`.
+ */
+
+interface BuildInitialUserMessageInput {
+    sessionId: SessionID;
+    /** Task this message opens. Optional only for v1 orphan-fallback paths. */
+    taskId: TaskID | undefined;
+    /** Sequential per-session index — caller owns allocation. */
+    index: number;
+    /** ISO 8601. */
+    timestamp: string;
+    /** Raw prompt content. String for textarea/CLI; array for callbacks. */
+    content: string | ContentBlock[];
+    /**
+     * `'user'` for normal prompts, `'system'` for the Agor-callback
+     * variant. The role is always `'user'` regardless.
+     */
+    type?: MessageType;
+    /** Free-form metadata blob — `source`, `original_id`, callback flags. */
+    metadata?: Message['metadata'];
+}
+declare function buildInitialUserMessage(input: BuildInitialUserMessageInput): Message;
+
+export { type BuildInitialUserMessageInput, buildInitialUserMessage };

package/dist/daemon/utils/build-initial-user-message.js

@@ -0,0 +1,30 @@
+// src/utils/build-initial-user-message.ts
+import { generateId } from "@agor/core/db";
+import { MessageRole } from "@agor/core/types";
+var CONTENT_PREVIEW_MAX_CHARS = 200;
+function buildInitialUserMessage(input) {
+  const preview = typeof input.content === "string" ? input.content.slice(0, CONTENT_PREVIEW_MAX_CHARS) : safeStringify(input.content).slice(0, CONTENT_PREVIEW_MAX_CHARS);
+  return {
+    message_id: generateId(),
+    session_id: input.sessionId,
+    task_id: input.taskId,
+    type: input.type ?? "user",
+    role: MessageRole.USER,
+    index: input.index,
+    timestamp: input.timestamp,
+    content_preview: preview,
+    content: input.content,
+    metadata: input.metadata
+  };
+}
+function safeStringify(value) {
+  if (value == null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+export {
+  buildInitialUserMessage
+};

package/dist/daemon/utils/build-resolved-config-slice.d.ts

@@ -0,0 +1,34 @@
+import { ResolvedConfigSlice } from '@agor/core/config';
+
+/**
+ * Build the daemon-resolved config slice that gets embedded in executor
+ * payloads. See `@agor/core/config` for the schema, and
+ * `context/explorations/daemon-fs-decoupling.md` §1.5 (H1) for why.
+ *
+ * Reads via `loadConfigSync()`, which is stat-validated and cached — calling
+ * this on every spawn is cheap.
+ *
+ * Lives in its own file rather than inside `spawn-executor.ts` so that file
+ * can stay focused on subprocess / template / sudo / env-routing concerns.
+ */
+
+/**
+ * Inject a daemon-resolved config slice into an executor payload if the
+ * caller didn't already provide one.
+ *
+ * Compares `payload.resolvedConfig !== undefined` rather than using
+ * `'resolvedConfig' in payload`. A caller passing
+ * `{ resolvedConfig: undefined }` should still get the daemon-built slice —
+ * `JSON.stringify()` drops `undefined` anyway, so an `in`-based check would
+ * silently ship an empty payload and the executor would fall back to
+ * handler defaults.
+ *
+ * Returns a NEW payload object when injection happens, otherwise the
+ * original reference unchanged.
+ */
+declare function withResolvedConfig<T extends {
+    resolvedConfig?: unknown;
+}>(payload: T): T;
+declare function buildResolvedConfigSlice(): ResolvedConfigSlice;
+
+export { buildResolvedConfigSlice, withResolvedConfig };

package/dist/daemon/utils/build-resolved-config-slice.js

@@ -0,0 +1,37 @@
+// src/utils/build-resolved-config-slice.ts
+import { loadConfigSync } from "@agor/core/config";
+function withResolvedConfig(payload) {
+  if (payload.resolvedConfig !== void 0) {
+    return payload;
+  }
+  return { ...payload, resolvedConfig: buildResolvedConfigSlice() };
+}
+function buildResolvedConfigSlice() {
+  try {
+    const config = loadConfigSync();
+    const slice = {};
+    const permissionTimeoutMs = config.execution?.permission_timeout_ms;
+    if (permissionTimeoutMs !== void 0) {
+      slice.execution = { permission_timeout_ms: permissionTimeoutMs };
+    }
+    const opencodeServerUrl = config.opencode?.serverUrl;
+    if (opencodeServerUrl !== void 0) {
+      slice.opencode = { serverUrl: opencodeServerUrl };
+    }
+    const hostIpAddress = config.daemon?.host_ip_address;
+    if (hostIpAddress !== void 0) {
+      slice.daemon = { host_ip_address: hostIpAddress };
+    }
+    return slice;
+  } catch (error) {
+    console.warn(
+      "[Executor] Failed to resolve config slice; handlers will fall back to defaults:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return {};
+  }
+}
+export {
+  buildResolvedConfigSlice,
+  withResolvedConfig
+};

package/dist/daemon/utils/git-impersonation.d.ts

@@ -13,20 +13,53 @@ import { UserID, Worktree } from '@agor/core/types';
  * simple`) no supplemental groups are ever created, so wrapping in sudo is
  * pure overhead AND breaks for users who never configured passwordless
  * sudoers (#1140). Return undefined in that case so callers spawn directly.
+ *
+ * The gate lives HERE on purpose: every caller that resolves impersonation
+ * needs the same check, and dropping it at a call site is exactly how the
+ * sister bug (#1143, `git.worktree.remove`) regressed after #1141 added
+ * inline `rbacEnabled ? ... : undefined` boilerplate at only two of three
+ * caller paths. Callers can spawn directly with the result; no extra gating
+ * required.
  */
 
+/**
+ * Resolve the configured daemon user for `sudo -u` group-refresh wrapping,
+ * or `undefined` when no wrap is needed.
+ *
+ * This is the core primitive: pure config lookup, no user/db state. Used
+ * both by git-execute spawn paths (via `resolveGitImpersonationForUser`)
+ * and by in-process shell capture (`git-shell-capture.ts`). Keeping a
+ * single source of truth prevents the drift that caused #1143 — the same
+ * stale gate copy-pasted across files.
+ *
+ * Dynamic config import is intentional: `loadConfigSync` reads from disk
+ * and we don't want to pay that cost at module-load time.
+ *
+ * Note: existence-validation of the returned daemon user (e.g. via
+ * `validateResolvedUnixUser`) is the responsibility of strict/insulated
+ * impersonation paths, which know the active mode. This primitive only
+ * answers "do we need a wrap, and if so, as whom?" — it does not vouch
+ * for the resolved user.
+ */
+declare function resolveDaemonUserForGroupRefresh(): Promise<string | undefined>;
 /**
  * Resolve Unix user for git operations.
  *
  * Returns the daemon user when group refresh via `sudo -u` is needed
- * (RBAC enabled or non-simple unix_user_mode). Returns `undefined` when
- * no supplemental groups exist, signalling callers to skip sudo entirely.
+ * (RBAC enabled or non-simple unix_user_mode — see
+ * `isUnixGroupRefreshNeeded`). Returns `undefined` in the open-access
+ * default so callers spawn directly without sudo wrap (#1140).
  *
- * @param db - Database instance (unused, kept for API compatibility)
- * @param userId - User ID (unused, kept for API compatibility)
+ * @param db - Database instance (unused today, kept on the signature for
+ *             the planned per-user resolution refactor)
+ * @param userId - User ID, optional. Reserved for per-user impersonation in
+ *                 strict mode. Optional today because the resolver is the
+ *                 sole gate; callers without an authenticated user (service
+ *                 accounts, etc.) can still call us — we'll correctly fall
+ *                 through to the daemon-user / undefined branches.
  * @returns Daemon username when sudo wrap is needed, otherwise undefined
  */
-declare function resolveGitImpersonationForUser(_db: Database, _userId: UserID): Promise<string | undefined>;
+declare function resolveGitImpersonationForUser(_db: Database, _userId: UserID | undefined): Promise<string | undefined>;
 /**
  * Resolve Unix user for git operations on a worktree.
  *
@@ -34,4 +67,4 @@ declare function resolveGitImpersonationForUser(_db: Database, _userId: UserID):
  */
 declare function resolveGitImpersonationForWorktree(db: Database, worktree: Worktree): Promise<string | undefined>;
 
-export { resolveGitImpersonationForUser, resolveGitImpersonationForWorktree };
+export { resolveDaemonUserForGroupRefresh, resolveGitImpersonationForUser, resolveGitImpersonationForWorktree };

package/dist/daemon/utils/git-impersonation.js

@@ -1,20 +1,19 @@
 // src/utils/git-impersonation.ts
-import { validateResolvedUnixUser } from "@agor/core/unix";
-async function resolveGitImpersonationForUser(_db, _userId) {
+async function resolveDaemonUserForGroupRefresh() {
   const { getDaemonUser, isUnixGroupRefreshNeeded } = await import("@agor/core/config");
   if (!isUnixGroupRefreshNeeded()) {
     return void 0;
   }
-  const daemonUser = getDaemonUser();
-  if (daemonUser) {
-    validateResolvedUnixUser("simple", daemonUser);
-  }
-  return daemonUser;
+  return getDaemonUser();
+}
+async function resolveGitImpersonationForUser(_db, _userId) {
+  return resolveDaemonUserForGroupRefresh();
 }
 async function resolveGitImpersonationForWorktree(db, worktree) {
   return resolveGitImpersonationForUser(db, worktree.created_by);
 }
 export {
+  resolveDaemonUserForGroupRefresh,
   resolveGitImpersonationForUser,
   resolveGitImpersonationForWorktree
 };

package/dist/daemon/utils/git-shell-capture.d.ts

@@ -11,7 +11,9 @@
  * access default (no RBAC, simple mode) no such groups exist, so we run the
  * git command directly — this avoids requiring sudoers config (#1140).
  *
- * @see git-impersonation.ts for the same pattern used in git clone/worktree operations
+ * Gating uses the shared `resolveDaemonUserForGroupRefresh` primitive from
+ * `git-impersonation.ts` so there is one source of truth (#1143 hoisted
+ * the gate into that primitive).
  */
 /**
  * Capture git SHA and branch ref via shell commands

package/dist/daemon/utils/git-shell-capture.js

@@ -1,18 +1,18 @@
 // src/utils/git-shell-capture.ts
-import { runAsUser, validateResolvedUnixUser } from "@agor/core/unix";
-async function resolveValidatedDaemonUser() {
+import { runAsUser } from "@agor/core/unix";
+
+// src/utils/git-impersonation.ts
+async function resolveDaemonUserForGroupRefresh() {
   const { getDaemonUser, isUnixGroupRefreshNeeded } = await import("@agor/core/config");
   if (!isUnixGroupRefreshNeeded()) {
     return void 0;
   }
-  const daemonUser = getDaemonUser();
-  if (daemonUser) {
-    validateResolvedUnixUser("simple", daemonUser);
-  }
-  return daemonUser;
+  return getDaemonUser();
 }
+
+// src/utils/git-shell-capture.ts
 async function captureGitStateViaShell(worktreePath) {
-  const daemonUser = await resolveValidatedDaemonUser();
+  const daemonUser = await resolveDaemonUserForGroupRefresh();
   const runOpts = { asUser: daemonUser, timeout: 1e4 };
   let sha = "unknown";
   let ref = "unknown";

package/dist/daemon/utils/mcp-probe-templates.js

@@ -33,7 +33,7 @@ function resolveProbeServerTemplates(serverConfig, userEnv) {
     ];
     for (const field of oauthTemplatedFields) {
       const original = serverConfig.auth[field];
-      if (original && original.includes("{{") && !result.server.auth?.[field]) {
+      if (original?.includes("{{") && !result.server.auth?.[field]) {
         unresolvedAuth.push(`auth.${field}`);
       }
     }

package/dist/daemon/utils/query-params.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Feathers query-param normalizers.
+ *
+ * Feathers delivers query params as strings; these helpers coerce them to
+ * the expected type and fall back to a sensible default when the input is
+ * missing, non-finite, or out of range. (They *do not* throw — invalid
+ * input is treated as "use the default", which matches how the
+ * sessions/worktrees services already handled this before the helper
+ * was lifted.)
+ */
+/**
+ * Parse the `last_message_truncation_length` query param.
+ *
+ * Used by `services/sessions.ts` and `services/worktrees.ts` to cap the
+ * length of the embedded last-message payload returned with each row.
+ * Bounds: [50, 10000]; default: 500.
+ */
+declare function parseLastMessageTruncationLength(value: unknown): number;
+
+export { parseLastMessageTruncationLength };

package/dist/daemon/utils/query-params.js

@@ -0,0 +1,17 @@
+// src/utils/query-params.ts
+function parseLastMessageTruncationLength(value) {
+  const DEFAULT = 500;
+  const MIN = 50;
+  const MAX = 1e4;
+  if (value === void 0 || value === null) {
+    return DEFAULT;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed < MIN || parsed > MAX) {
+    return DEFAULT;
+  }
+  return Math.floor(parsed);
+}
+export {
+  parseLastMessageTruncationLength
+};

package/dist/daemon/utils/session-state-hooks.js

@@ -1,5 +1,5 @@
 // src/utils/session-state-hooks.ts
-import { SerializedSessionRepository } from "@agor/core/db";
+import { SerializedSessionRepository, shortId } from "@agor/core/db";
 
 // src/utils/session-state.ts
 import { createHash } from "crypto";
@@ -112,7 +112,7 @@ async function pullIfNeeded(ctx) {
     const age = Date.now() - latest.created_at;
     if (age > STALE_PROCESSING_THRESHOLD_MS) {
       console.log(
-        `[session-state] Cleaning stale 'processing' row ${latest.id.substring(0, 8)} (age: ${Math.round(age / 1e3)}s)`
+        `[session-state] Cleaning stale 'processing' row ${shortId(latest.id)} (age: ${Math.round(age / 1e3)}s)`
       );
       await repo.deleteById(latest.id);
       latest = await repo.findLatestDone(ctx.sessionId);
@@ -135,12 +135,12 @@ async function pullIfNeeded(ctx) {
   }
   if (!latest.payload) {
     console.warn(
-      `[session-state] 'done' row ${latest.id.substring(0, 8)} has no payload, skipping restore`
+      `[session-state] 'done' row ${shortId(latest.id)} has no payload, skipping restore`
     );
     return;
   }
   console.log(
-    `[session-state] Restoring session file from DB (row ${latest.id.substring(0, 8)}, turn ${latest.turn_index})`
+    `[session-state] Restoring session file from DB (row ${shortId(latest.id)}, turn ${latest.turn_index})`
   );
   await restoreFile(filePath, latest.payload);
 }

package/dist/daemon/utils/session-tasks.d.ts

@@ -0,0 +1,43 @@
+import { Application } from '@agor/core/feathers';
+import { SessionID, Params, Task } from '@agor/core/types';
+
+/**
+ * Helpers for finding "active" tasks for a session — RUNNING /
+ * AWAITING_PERMISSION / STOPPING — sorted by recency.
+ *
+ * Background: `TasksService.find()` short-circuits on `session_id: string`
+ * (see `services/tasks.ts:65-110`) and returns ALL session tasks in
+ * `created_at` ASC, ignoring any `status` filter or `$sort` passed in the
+ * same query. So callers can't write `{ session_id, status: RUNNING }`
+ * and trust the result. We instead fetch the full session task list once
+ * and filter/sort in process.
+ *
+ * Without this helper, multiple sites (widget MCP tool, stop route,
+ * potentially more) end up with parallel hand-rolled workarounds that
+ * drift. Keep this as the single source.
+ */
+
+/** Statuses considered "active" — an executor may still be doing work. */
+declare const ACTIVE_TASK_STATUSES: ReadonlySet<string>;
+/**
+ * All tasks for the session, returned in recency-DESC order (most recently
+ * started/created first). Useful when callers want a fallback path.
+ */
+declare function findTasksForSession(app: Application, sessionId: SessionID, params?: Params): Promise<Task[]>;
+/**
+ * The session's active tasks (RUNNING / AWAITING_PERMISSION / STOPPING),
+ * recency-DESC. Empty when nothing is active.
+ */
+declare function findActiveTasksForSession(app: Application, sessionId: SessionID, params?: Params): Promise<Task[]>;
+/**
+ * The single most-recent active task — preferred when callers want "the
+ * task that is driving this session right now." Falls back to the most-
+ * recent task of any status when nothing is active, so widget messages /
+ * system messages always land somewhere visible to the transcript renderer.
+ *
+ * Returns `undefined` when the session has no tasks at all (brand-new
+ * session).
+ */
+declare function findHostTaskForSession(app: Application, sessionId: SessionID, params?: Params): Promise<Task | undefined>;
+
+export { ACTIVE_TASK_STATUSES, findActiveTasksForSession, findHostTaskForSession, findTasksForSession };

package/dist/daemon/utils/session-tasks.js

@@ -0,0 +1,39 @@
+// src/utils/session-tasks.ts
+import { TaskStatus } from "@agor/core/types";
+var ACTIVE_TASK_STATUSES = /* @__PURE__ */ new Set([
+  TaskStatus.RUNNING,
+  TaskStatus.AWAITING_PERMISSION,
+  TaskStatus.STOPPING
+]);
+function recencyKey(t) {
+  return new Date(t.started_at || t.created_at).getTime();
+}
+async function findTasksForSession(app, sessionId, params) {
+  const result = await app.service("tasks").find({
+    ...params ?? {},
+    // Merge defensively: spread params first, then force session_id so a
+    // caller-supplied params.query can never silently overwrite the filter.
+    query: {
+      ...params?.query,
+      session_id: sessionId,
+      $limit: params?.query?.$limit ?? 1e3
+    }
+  });
+  const tasks = Array.isArray(result) ? result : result.data;
+  return [...tasks].sort((a, b) => recencyKey(b) - recencyKey(a));
+}
+async function findActiveTasksForSession(app, sessionId, params) {
+  const all = await findTasksForSession(app, sessionId, params);
+  return all.filter((t) => ACTIVE_TASK_STATUSES.has(t.status));
+}
+async function findHostTaskForSession(app, sessionId, params) {
+  const all = await findTasksForSession(app, sessionId, params);
+  if (all.length === 0) return void 0;
+  return all.find((t) => ACTIVE_TASK_STATUSES.has(t.status)) ?? all[0];
+}
+export {
+  ACTIVE_TASK_STATUSES,
+  findActiveTasksForSession,
+  findHostTaskForSession,
+  findTasksForSession
+};

package/dist/daemon/utils/spawn-executor.d.ts

@@ -1,3 +1,6 @@
+import { ChildProcess } from 'node:child_process';
+import { AgorExecutionSettings } from '@agor/core/config';
+
 /**
  * Executor Spawning Utility
  *
@@ -20,68 +23,36 @@
  * 0600 env-file owned by the target user so their values never appear in
  * argv / /proc/<pid>/cmdline.
  */
-/**
- * Configure the daemon URL for executor payloads.
- * Call this once at daemon startup.
- *
- * @param url - The URL executors should use to reach the daemon
- *              (e.g., "http://agor-daemon.agor.svc.cluster.local:3030" for k8s)
- */
+
+/** Set the daemon URL for executor payloads. Call once at daemon startup. */
 declare function configureDaemonUrl(url: string): void;
-/**
- * Template variables for executor command template substitution.
- * These are substituted into the executor_command_template at spawn time.
- */
+/** Set default executor template + impersonation user from config. Call once at daemon startup. */
+declare function configureExecutor(config?: ExecutorConfig | null): void;
 interface ExecutorTemplateVariables {
-    /** Unique task identifier (for pod/container naming) */
     task_id?: string;
-    /** Executor command (prompt, git.clone, etc.) */
     command?: string;
-    /** Target Unix username */
     unix_user?: string;
-    /** Target Unix UID (for runAsUser in k8s) */
     unix_user_uid?: number;
-    /** Target Unix GID (for fsGroup in k8s) */
     unix_user_gid?: number;
-    /** Session ID (if available) */
     session_id?: string;
-    /** Worktree ID (if available) */
     worktree_id?: string;
 }
-/**
- * Options for spawning executor
- */
 interface SpawnExecutorOptions {
-    /** Working directory for executor process */
     cwd?: string;
-    /** Environment variables for executor process */
     env?: Record<string, string>;
-    /** Log prefix for console output */
     logPrefix?: string;
-    /**
-     * Unix user to run executor as (impersonation)
-     * When set, spawns via `sudo -n -u $asUser bash -c '...'` so the executor
-     * gets fresh group memberships for the target user. Secret env vars are
-     * routed through a 0600 env-file owned by `asUser` so their values stay
-     * out of argv / /proc/<pid>/cmdline.
-     */
-    asUser?: string;
-    /**
-     * Executor command template for remote/containerized execution.
-     * When provided, uses template substitution instead of local subprocess.
-     * Takes precedence over local spawning.
-     */
-    executorCommandTemplate?: string;
-    /**
-     * Template variables for substitution in executor_command_template.
-     * Used when executorCommandTemplate is provided.
-     */
+    /** When set, spawns via `sudo -n -u $asUser`. Secrets go through a 0600 env-file. */
+    asUser?: string | null;
+    /** When set, uses template substitution instead of local subprocess. */
+    executorCommandTemplate?: string | null;
     templateVariables?: ExecutorTemplateVariables;
-    /**
-     * Callback when executor process exits.
-     * Used to clean up resources when executor terminates.
-     */
     onExit?: (code: number | null) => void;
+    /** Fired after spawn, before stdin is written. Works for both local and templated paths. */
+    onSpawn?: (child: ChildProcess) => void;
+    /** Caller-assembled env; bypasses internal curation. Ignored by templated path. */
+    preparedEnv?: Record<string, string>;
+    /** Pre-written 0600 env file; bypasses prepareImpersonationEnv(). Only with asUser. */
+    preparedEnvFilePath?: string;
 }
 /**
  * Substitute template variables in the executor command template.
@@ -94,19 +65,7 @@ interface SpawnExecutorOptions {
  * @returns The template with variables substituted
  */
 declare function substituteTemplateVariables(template: string, variables: ExecutorTemplateVariables): string;
-/**
- * Generate a unique task ID for executor pod/container naming.
- * Uses a short random string that's safe for k8s resource names.
- */
 declare function generateTaskId(): string;
-/**
- * Find the executor binary path
- *
- * Searches multiple possible locations for development and production:
- * - Bundled in agor-live package
- * - Development bin script
- * - Built dist directory
- */
 declare function findExecutorPath(): string;
 /**
  * Spawn executor process with JSON payload via stdin (fire-and-forget)
@@ -126,17 +85,6 @@ declare function findExecutorPath(): string;
  * @param options - Spawn options
  */
 declare function spawnExecutor(payload: Record<string, unknown>, options?: SpawnExecutorOptions): void;
-/**
- * Get daemon URL for executor communication.
- *
- * Priority:
- * 1. Module-level configured URL (set via configureDaemonUrl at startup)
- * 2. Environment variable PORT with localhost
- * 3. Default localhost:3030
- *
- * In containerized (k8s) mode, configureDaemonUrl() should be called at startup
- * with the internal service URL (e.g., http://agor-daemon.agor.svc.cluster.local:3030)
- */
 declare function getDaemonUrl(): string;
 /**
  * Create a short-lived service token for executor authentication
@@ -170,50 +118,9 @@ declare function generateSessionToken(app: {
  * Configuration for executor spawning.
  * Loaded from ~/.agor/config.yaml execution section.
  */
-interface ExecutorConfig {
-    /** Executor command template for containerized execution */
-    executor_command_template?: string;
-    /** Unix user to run executors as */
-    executor_unix_user?: string;
-}
-/**
- * Create a configured spawn function with execution settings baked in.
- *
- * This factory creates a spawn function that automatically includes
- * the executor_command_template from config. Use this when you have
- * access to config at initialization time.
- *
- * @example
- * ```typescript
- * const config = await loadConfig();
- * const spawn = createConfiguredSpawner(config.execution);
- *
- * // Now spawn automatically uses template if configured
- * spawn({ command: 'prompt', ... }, { logPrefix: '[Task]' });
- * ```
- */
+type ExecutorConfig = Pick<AgorExecutionSettings, 'executor_command_template' | 'executor_unix_user'>;
+/** DI-based factory that bakes execution config into a spawner, independent of module-level defaults. */
 declare function createConfiguredSpawner(executionConfig?: ExecutorConfig): (payload: Record<string, unknown>, options?: Omit<SpawnExecutorOptions, "executorCommandTemplate">) => void;
-/**
- * @deprecated Use spawnExecutor instead. This alias exists for backward compatibility.
- */
 declare const spawnExecutorFireAndForget: typeof spawnExecutor;
-/**
- * @deprecated SpawnExecutorResult is no longer used since we don't wait for results.
- * Kept for backward compatibility during migration.
- */
-interface SpawnExecutorResult {
-    success: boolean;
-    data?: Record<string, unknown>;
-    error?: {
-        code: string;
-        message: string;
-        details?: Record<string, unknown>;
-    };
-}
-/**
- * @deprecated FireAndForgetOptions is now just SpawnExecutorOptions.
- * Kept for backward compatibility during migration.
- */
-type FireAndForgetOptions = SpawnExecutorOptions;
 
-export { type ExecutorConfig, type ExecutorTemplateVariables, type FireAndForgetOptions, type SpawnExecutorOptions, type SpawnExecutorResult, configureDaemonUrl, createConfiguredSpawner, createServiceToken, findExecutorPath, generateSessionToken, generateTaskId, getDaemonUrl, spawnExecutor, spawnExecutorFireAndForget, substituteTemplateVariables };
+export { type ExecutorConfig, type ExecutorTemplateVariables, type SpawnExecutorOptions, configureDaemonUrl, configureExecutor, createConfiguredSpawner, createServiceToken, findExecutorPath, generateSessionToken, generateTaskId, getDaemonUrl, spawnExecutor, spawnExecutorFireAndForget, substituteTemplateVariables };