@hyperdrive.bot/paseo-server 0.3.42 → 0.3.44

package/dist/server/server/agent/agent-manager.d.ts

@@ -322,6 +322,12 @@ export declare class AgentManager {
         cwd: string;
         workspaceId: string;
         labels?: Record<string, string>;
+        /**
+         * Config carried over from a previous agent record for the same provider
+         * session. Without it an import falls back to daemon defaults, which can
+         * demote a session to a smaller-context model and force a compaction.
+         */
+        config?: Partial<AgentSessionConfig>;
     }): Promise<ManagedAgent>;
     /**
      * Hot-swap a running agent's provider to a compatible alternative

package/dist/server/server/agent/agent-manager.js

@@ -614,6 +614,7 @@ export class AgentManager {
             throw new Error(`Provider '${input.provider}' does not support importing sessions`);
         }
         const { storedConfig, launchConfig } = await this.prepareSessionConfig({
+            ...input.config,
             provider: input.provider,
             cwd: input.cwd,
         }, resolvedAgentId);
@@ -2827,7 +2828,12 @@ export class AgentManager {
             const activeBackgroundTaskCount = this.getActiveBackgroundTaskCount(agent);
             if (activeBackgroundTaskCount > 0) {
                 agent.suppressedAttentionCount = (agent.suppressedAttentionCount ?? 0) + 1;
-                this.logger.debug({
+                // info, not debug: this is the ONLY production signal that the
+                // suppression fired. The daemon logs at level 30 and emits zero debug
+                // lines, so at debug this was unobservable — and an absent log then
+                // looked identical to a working feature. Verify with:
+                //   journalctl -u paseo.service | grep "Suppressed finished-attention"
+                this.logger.info({
                     agentId: agent.id,
                     activeBackgroundTaskCount,
                     suppressedAttentionCount: agent.suppressedAttentionCount,

package/dist/server/server/agent/import-sessions.d.ts

@@ -2,7 +2,7 @@ import type { z } from "zod";
 import type { Logger } from "pino";
 import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 import type { AgentManager, ManagedAgent } from "./agent-manager.js";
-import type { AgentStorage } from "./agent-storage.js";
+import type { AgentStorage, StoredAgentRecord } from "./agent-storage.js";
 import type { AgentProvider } from "./agent-sdk-types.js";
 import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@hyperdrive.bot/paseo-protocol/messages";
 type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
@@ -43,5 +43,10 @@ export declare function normalizeImportAgentRequest(msg: ImportAgentRequestMessa
 };
 export declare function listImportableProviderSessions(input: ListImportableProviderSessionsInput): Promise<ListImportableProviderSessionsResult>;
 export declare function importProviderSession(input: ImportProviderSessionInput): Promise<ImportProviderSessionResult>;
+export declare function inheritedImportConfig(record: StoredAgentRecord | undefined): {
+    model?: string;
+    thinkingOptionId?: string;
+    modeId?: string;
+} | undefined;
 export {};
 //# sourceMappingURL=import-sessions.d.ts.map

package/dist/server/server/agent/import-sessions.js

@@ -72,13 +72,18 @@ export async function importProviderSession(input) {
         throw new Error("Import requires cwd from the selected provider session");
     }
     const handle = buildImportPersistenceHandle({ provider, providerHandleId, cwd });
-    await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
+    const priorRecord = await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
+    const inheritedConfig = inheritedImportConfig(priorRecord);
+    if (inheritedConfig) {
+        input.logger?.info?.({ providerHandleId, ...inheritedConfig }, "Import inheriting config from the session's previous agent record");
+    }
     const snapshot = await input.agentManager.importProviderSession({
         provider,
         providerHandleId,
         cwd,
         workspaceId: input.workspaceId,
         labels,
+        ...(inheritedConfig ? { config: inheritedConfig } : {}),
     });
     await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
     return {
@@ -92,9 +97,29 @@ async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
         (record.persistence.sessionId === handle.sessionId ||
             record.persistence.nativeHandle === handle.nativeHandle));
     if (!matched) {
-        return;
+        return undefined;
     }
     await unarchiveAgentState(agentStorage, agentManager, matched.id);
+    return matched;
+}
+// An import that lands on a session paseo has seen before must not silently
+// downgrade it. The prior record already carries the model, thinking option and
+// permission mode the session was running under; without this the imported agent
+// falls back to daemon defaults, which has demoted a 1M-context session to the
+// 200k model and auto-compacted its transcript on the first prompt.
+export function inheritedImportConfig(record) {
+    if (!record) {
+        return undefined;
+    }
+    const modeId = record.lastModeId ?? record.config?.modeId ?? undefined;
+    const inherited = {
+        ...(record.config?.model ? { model: record.config.model } : {}),
+        ...(record.config?.thinkingOptionId
+            ? { thinkingOptionId: record.config.thinkingOptionId }
+            : {}),
+        ...(modeId ? { modeId } : {}),
+    };
+    return Object.keys(inherited).length > 0 ? inherited : undefined;
 }
 function parseRecentProviderSessionsSince(since) {
     if (!since) {

package/dist/server/server/agent/mcp-server.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WorkflowNotFoundError } from "../workflow/workflow-manager.js";
-import { WorkflowSnapshotSchema, WorkflowStatusSchema, WorkflowTaskGraphSchema, SessionDigestSchema, } from "../messages.js";
+import { WorkflowAgentPresetSchema, WorkflowSnapshotSchema, WorkflowStatusSchema, WorkflowTaskGraphSchema, SessionDigestSchema, } from "../messages.js";
 import { AgentStatusEnum } from "./mcp-shared.js";
 import { expandUserPath } from "../path-utils.js";
 import { ensureValidJson } from "../json-utils.js";
@@ -28,6 +28,10 @@ const workflowStartArgsSchema = z.object({
         .record(z.string(), z.string())
         .optional()
         .describe("Optional labels copied onto every spawned child alongside the workflow id"),
+    agentPresets: z
+        .record(z.string(), WorkflowAgentPresetSchema)
+        .optional()
+        .describe("Optional map of agent name to partial session config; a task's agentType selects one"),
 });
 const workflowIdArgsSchema = z.object({
     workflowId: z.string().describe("Workflow id returned by workflow_start"),
@@ -238,6 +242,7 @@ export async function createAgentMcpServer(options) {
                 baseConfig,
                 ...(args.title ? { title: args.title } : {}),
                 ...(args.labels ? { labels: args.labels } : {}),
+                ...(args.agentPresets ? { agentPresets: args.agentPresets } : {}),
                 ...(callerAgentId ? { parentAgentId: callerAgentId } : {}),
             });
             const started = await workflowManager.startWorkflow(workflow.id);

package/dist/server/server/agent/providers/claude/agent.d.ts

@@ -79,6 +79,22 @@ export declare class ClaudeAgentClient implements AgentClient {
     }>;
     private assertConfig;
 }
+/**
+ * Tool names whose tool_result can ANNOUNCE background work that outlives the turn.
+ *
+ * This gate is the reason the tracker sees anything at all. It was previously
+ * `toolName !== "Bash"`, which made the monitor and cron start-patterns in
+ * `background-task-tracker.ts` unreachable: a `Monitor` tool_result returned
+ * here before `noteToolResultText` was ever called, so a monitor-only session
+ * reported zero background tasks, bucketed as "done", and kept lighting the
+ * unread chip on every tick.
+ *
+ * ⚠️ The parser having a pattern is NOT enough — the tool name must be in this
+ * set too. Any new kind of background work needs BOTH, and an integration test
+ * that drives `handleToolResult` (not the parser directly), or the same hole
+ * reopens silently. See `background-work-kinds.ts`.
+ */
+export declare const BACKGROUND_WORK_TOOL_NAMES: Set<string>;
 export declare class ClaudeAgentSession implements AgentSession {
     readonly provider: "claude";
     readonly capabilities: AgentCapabilityFlags;

package/dist/server/server/agent/providers/claude/agent.js

@@ -1514,6 +1514,22 @@ class ClaudeContextUsageState {
         };
     }
 }
+/**
+ * Tool names whose tool_result can ANNOUNCE background work that outlives the turn.
+ *
+ * This gate is the reason the tracker sees anything at all. It was previously
+ * `toolName !== "Bash"`, which made the monitor and cron start-patterns in
+ * `background-task-tracker.ts` unreachable: a `Monitor` tool_result returned
+ * here before `noteToolResultText` was ever called, so a monitor-only session
+ * reported zero background tasks, bucketed as "done", and kept lighting the
+ * unread chip on every tick.
+ *
+ * ⚠️ The parser having a pattern is NOT enough — the tool name must be in this
+ * set too. Any new kind of background work needs BOTH, and an integration test
+ * that drives `handleToolResult` (not the parser directly), or the same hole
+ * reopens silently. See `background-work-kinds.ts`.
+ */
+export const BACKGROUND_WORK_TOOL_NAMES = new Set(["Bash", "Monitor", "CronCreate", "CronDelete"]);
 export class ClaudeAgentSession {
     /**
      * Register a hook event handler for an agent. Stub in Epic 1 — Epic 3 wires
@@ -4122,7 +4138,7 @@ export class ClaudeAgentSession {
      * Both go into the record so the UI can show what is actually running.
      */
     trackBackgroundShellStart(block, toolName, entry) {
-        if (toolName !== "Bash" || block.is_error) {
+        if (!BACKGROUND_WORK_TOOL_NAMES.has(toolName) || block.is_error) {
             return;
         }
         const resultText = typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? "");
@@ -4136,7 +4152,10 @@ export class ClaudeAgentSession {
             startedAt: resolveBackgroundShellStartedAt(extractBackgroundOutputFile(resultText)),
         });
         if (started.length > 0) {
-            this.logger.debug({ taskIds: started, command }, "Tracking Claude background shell(s)");
+            // info, not debug: the daemon runs at level 30 and emits no debug lines,
+            // so a debug log here is unobservable in production — which is exactly
+            // how a silently-unreachable tracker went unnoticed.
+            this.logger.info({ taskIds: started, toolName, command }, "Tracking background work");
         }
     }
     /**

package/dist/server/server/agent/providers/claude/background-work-kinds.d.ts

@@ -21,6 +21,17 @@
  * fails. Add an entry claiming `tracked: true` without a start pattern that
  * actually extracts its id and `background-work-kinds.test.ts` fails.
  *
+ * ⚠️ A PATTERN IS NOT ENOUGH — THE TOOL NAME MUST BE GATED IN TOO
+ *
+ * `trackBackgroundShellStart` in `providers/claude/agent.ts` only forwards a
+ * tool_result to the parser when its tool name is in `BACKGROUND_WORK_TOOL_NAMES`.
+ * The first version of this file shipped monitor and cron patterns while that
+ * gate still read `toolName !== "Bash"`, so both were dead code in production
+ * and every test passed because the tests called the parser directly. A kind is
+ * only really tracked when it has: a start pattern, a retirement path, an entry
+ * here, AND its tool name in that set — proven by an integration test that goes
+ * through `handleToolResult`.
+ *
  * SAMPLES ARE CAPTURES, NOT TRANSCRIPTIONS
  *
  * Every `sample` below was pasted verbatim out of a live session's tool_result
@@ -43,6 +54,12 @@ interface TrackedKind {
     retiredBy: string;
     /** Which module owns the tracking. */
     trackedBy: string;
+    /**
+     * The tool name this kind's result arrives under. MUST be present in
+     * `BACKGROUND_WORK_TOOL_NAMES` (providers/claude/agent.ts) or the parser is
+     * never reached, however correct its pattern is.
+     */
+    toolName: string;
 }
 interface SilencedKind {
     tracked: false;
@@ -63,6 +80,7 @@ export declare const BACKGROUND_WORK_KINDS: {
         readonly expectedId: "beuhoixae";
         readonly retiredBy: "<task-notification> with a terminal <status>";
         readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "Bash";
     };
     readonly monitor: {
         readonly tracked: true;
@@ -71,6 +89,7 @@ export declare const BACKGROUND_WORK_KINDS: {
         readonly expectedId: "b6dxcqe9y";
         readonly retiredBy: "<task-notification> with a terminal <status>";
         readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "Monitor";
     };
     readonly cron: {
         readonly tracked: true;
@@ -79,6 +98,7 @@ export declare const BACKGROUND_WORK_KINDS: {
         readonly expectedId: "b8df03d3";
         readonly retiredBy: "\"Cancelled job <id>.\" in a later tool_result";
         readonly trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText";
+        readonly toolName: "CronCreate";
     };
     readonly scheduled_wakeup: {
         readonly tracked: false;

package/dist/server/server/agent/providers/claude/background-work-kinds.js

@@ -21,6 +21,17 @@
  * fails. Add an entry claiming `tracked: true` without a start pattern that
  * actually extracts its id and `background-work-kinds.test.ts` fails.
  *
+ * ⚠️ A PATTERN IS NOT ENOUGH — THE TOOL NAME MUST BE GATED IN TOO
+ *
+ * `trackBackgroundShellStart` in `providers/claude/agent.ts` only forwards a
+ * tool_result to the parser when its tool name is in `BACKGROUND_WORK_TOOL_NAMES`.
+ * The first version of this file shipped monitor and cron patterns while that
+ * gate still read `toolName !== "Bash"`, so both were dead code in production
+ * and every test passed because the tests called the parser directly. A kind is
+ * only really tracked when it has: a start pattern, a retirement path, an entry
+ * here, AND its tool name in that set — proven by an integration test that goes
+ * through `handleToolResult`.
+ *
  * SAMPLES ARE CAPTURES, NOT TRANSCRIPTIONS
  *
  * Every `sample` below was pasted verbatim out of a live session's tool_result
@@ -37,6 +48,7 @@ export const BACKGROUND_WORK_KINDS = {
         expectedId: "beuhoixae",
         retiredBy: "<task-notification> with a terminal <status>",
         trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "Bash",
     },
     monitor: {
         tracked: true,
@@ -48,6 +60,7 @@ export const BACKGROUND_WORK_KINDS = {
         // Only its START was ever invisible.
         retiredBy: "<task-notification> with a terminal <status>",
         trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "Monitor",
     },
     cron: {
         tracked: true,
@@ -58,6 +71,7 @@ export const BACKGROUND_WORK_KINDS = {
         // tool_result is its only retirement signal — note the glued-on period.
         retiredBy: '"Cancelled job <id>." in a later tool_result',
         trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "CronCreate",
     },
     scheduled_wakeup: {
         tracked: false,

package/dist/server/server/bootstrap.js

@@ -669,6 +669,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     const workflowManager = new WorkflowManager({
         agentManager,
         storage: workflowStorage,
+        logger,
     });
     // Story 2.1 — read-only HTTP status + SSE phase-transition routes. Gated on the
     // same WORKFLOWS_FEATURE_ENABLED constant as the server_info handshake flag.

package/dist/server/server/session.js

@@ -1202,6 +1202,7 @@ export class Session {
                 baseConfig,
                 ...(msg.title ? { title: msg.title } : {}),
                 ...(msg.labels ? { labels: msg.labels } : {}),
+                ...(msg.agentPresets ? { agentPresets: msg.agentPresets } : {}),
             });
             const started = await manager.startWorkflow(workflow.id);
             this.emit({

package/dist/server/server/workflow/workflow-agent-resolution.d.ts

@@ -0,0 +1,82 @@
+import type { WorkflowAgentPreset } from "@hyperdrive.bot/paseo-protocol/messages";
+import type { AgentSessionConfig } from "../agent/agent-sdk-types.js";
+import type { TaskGraph, TaskNode } from "./workflow-manager.js";
+/**
+ * workflow-agent-resolution — Epic 2, Story 2.1.
+ *
+ * Per-step agent selection. Before this module every child of a workflow was spawned
+ * with the one graph-level `baseConfig`, so `TaskNode.agentType` was a declared field
+ * with no reader: delegation to a different agent per step was simply not supported.
+ * This module is that reader.
+ *
+ * Why it is PURE and lives outside `workflow-manager.ts` (the `workflow-progress.ts`
+ * precedent):
+ * - **Unit-testable with no harness.** Precedence is a function of three plain objects;
+ *   proving it should not require an `AgentManager`, a temp dir or a spawned child.
+ * - **The manager stays an orchestrator, not a calculator.** One helper serves BOTH
+ *   spawn call sites (`startWorkflow`'s readiness loop and `continueWorkflow`), so the
+ *   precedence rule exists exactly once.
+ * - **No runtime cycle.** Every import above is type-only and therefore erased, so the
+ *   manager can import this module as a VALUE. `WorkflowUnknownAgentError` is declared
+ *   here (the leaf) and re-exported from the manager, exactly as `WorkflowCycleError`
+ *   is declared in `workflow-progress.ts` and re-exported.
+ *
+ * Why the merge copies only DEFINED keys rather than spreading:
+ * `{ ...base, ...preset, ...override }` lets an explicit `undefined` in a higher tier
+ * ERASE a defined lower-tier value — `{ model: undefined }` on a task would blank the
+ * workflow's model instead of leaving it alone. A tier states what it overrides; a key
+ * it does not set must be invisible.
+ *
+ * Why `cwd` is forced back to `baseConfig.cwd` as the final statement:
+ * the working directory is workflow-owned. A step relocating its own child would break
+ * the containment every other surface assumes. There are two independent guards, on
+ * purpose: `WorkflowAgentPresetSchema` rejects `cwd` at parse time (so it can never
+ * arrive over the wire), and this assignment wins over any hand-built object literal
+ * that bypassed the schema.
+ *
+ * Determinism rules, mirroring `workflow-progress.ts`: synchronous, no I/O, no
+ * `Date.now()` / `new Date()`, no snapshot read, no module-level mutable state.
+ */
+/** Thrown when a task's `agentType` names an agent absent from the workflow's presets. */
+export declare class WorkflowUnknownAgentError extends Error {
+    readonly workflowId: string | undefined;
+    readonly taskId: string;
+    readonly agentName: string;
+    readonly knownAgents: string[];
+    constructor(workflowId: string | undefined, taskId: string, agentName: string, knownAgents: string[]);
+}
+/**
+ * Create-time validation: reject a graph whose any task names an agent nobody defined.
+ *
+ * Reports the FIRST offender in `graph.tasks` array order, so the error is stable for
+ * a given graph rather than dependent on object-key iteration. The message names the
+ * task id, the unknown name and the known names, because both launch boundaries
+ * (`session.ts` RPC, `mcp-server.ts` tool) forward `error.message` verbatim to the
+ * operator and that string is the whole diagnosis.
+ *
+ * Own-key lookup, never a bare `in`: a preset named `toString` or `constructor` must
+ * not be satisfied by `Object.prototype`.
+ */
+export declare function assertKnownAgents(args: {
+    graph: TaskGraph;
+    agentPresets: Record<string, WorkflowAgentPreset>;
+    workflowId?: string;
+}): void;
+/**
+ * Resolve the `AgentSessionConfig` one task's child is spawned with.
+ *
+ * Precedence, lowest to highest: `baseConfig`, then `agentPresets[node.agentType]`,
+ * then `node.agentConfig`. Only keys whose value is `!== undefined` are copied from a
+ * higher tier, so a preset that sets only `model` leaves `baseConfig.provider` intact.
+ *
+ * TOTAL by design: an `agentType` naming a missing preset returns `{ ...baseConfig }`
+ * rather than throwing. That path is unreachable after `assertKnownAgents` runs at
+ * create time, and a helper that threw on it would convert a validation gap into a
+ * mid-graph spawn crash.
+ */
+export declare function resolveTaskConfig(args: {
+    node: TaskNode;
+    baseConfig: AgentSessionConfig;
+    agentPresets: Record<string, WorkflowAgentPreset>;
+}): AgentSessionConfig;
+//# sourceMappingURL=workflow-agent-resolution.d.ts.map

package/dist/server/server/workflow/workflow-agent-resolution.js

@@ -0,0 +1,105 @@
+/**
+ * workflow-agent-resolution — Epic 2, Story 2.1.
+ *
+ * Per-step agent selection. Before this module every child of a workflow was spawned
+ * with the one graph-level `baseConfig`, so `TaskNode.agentType` was a declared field
+ * with no reader: delegation to a different agent per step was simply not supported.
+ * This module is that reader.
+ *
+ * Why it is PURE and lives outside `workflow-manager.ts` (the `workflow-progress.ts`
+ * precedent):
+ * - **Unit-testable with no harness.** Precedence is a function of three plain objects;
+ *   proving it should not require an `AgentManager`, a temp dir or a spawned child.
+ * - **The manager stays an orchestrator, not a calculator.** One helper serves BOTH
+ *   spawn call sites (`startWorkflow`'s readiness loop and `continueWorkflow`), so the
+ *   precedence rule exists exactly once.
+ * - **No runtime cycle.** Every import above is type-only and therefore erased, so the
+ *   manager can import this module as a VALUE. `WorkflowUnknownAgentError` is declared
+ *   here (the leaf) and re-exported from the manager, exactly as `WorkflowCycleError`
+ *   is declared in `workflow-progress.ts` and re-exported.
+ *
+ * Why the merge copies only DEFINED keys rather than spreading:
+ * `{ ...base, ...preset, ...override }` lets an explicit `undefined` in a higher tier
+ * ERASE a defined lower-tier value — `{ model: undefined }` on a task would blank the
+ * workflow's model instead of leaving it alone. A tier states what it overrides; a key
+ * it does not set must be invisible.
+ *
+ * Why `cwd` is forced back to `baseConfig.cwd` as the final statement:
+ * the working directory is workflow-owned. A step relocating its own child would break
+ * the containment every other surface assumes. There are two independent guards, on
+ * purpose: `WorkflowAgentPresetSchema` rejects `cwd` at parse time (so it can never
+ * arrive over the wire), and this assignment wins over any hand-built object literal
+ * that bypassed the schema.
+ *
+ * Determinism rules, mirroring `workflow-progress.ts`: synchronous, no I/O, no
+ * `Date.now()` / `new Date()`, no snapshot read, no module-level mutable state.
+ */
+/** Thrown when a task's `agentType` names an agent absent from the workflow's presets. */
+export class WorkflowUnknownAgentError extends Error {
+    constructor(workflowId, taskId, agentName, knownAgents) {
+        super(`Task ${taskId} names unknown agent '${agentName}'. Known agents: ${knownAgents.length > 0 ? [...knownAgents].sort().join(", ") : "none"}.`);
+        this.workflowId = workflowId;
+        this.taskId = taskId;
+        this.agentName = agentName;
+        this.knownAgents = knownAgents;
+        this.name = "WorkflowUnknownAgentError";
+    }
+}
+/**
+ * Create-time validation: reject a graph whose any task names an agent nobody defined.
+ *
+ * Reports the FIRST offender in `graph.tasks` array order, so the error is stable for
+ * a given graph rather than dependent on object-key iteration. The message names the
+ * task id, the unknown name and the known names, because both launch boundaries
+ * (`session.ts` RPC, `mcp-server.ts` tool) forward `error.message` verbatim to the
+ * operator and that string is the whole diagnosis.
+ *
+ * Own-key lookup, never a bare `in`: a preset named `toString` or `constructor` must
+ * not be satisfied by `Object.prototype`.
+ */
+export function assertKnownAgents(args) {
+    for (const task of args.graph.tasks) {
+        const agentName = task.agentType;
+        if (!agentName) {
+            continue;
+        }
+        if (!Object.prototype.hasOwnProperty.call(args.agentPresets, agentName)) {
+            throw new WorkflowUnknownAgentError(args.workflowId, task.id, agentName, Object.keys(args.agentPresets));
+        }
+    }
+}
+/**
+ * Resolve the `AgentSessionConfig` one task's child is spawned with.
+ *
+ * Precedence, lowest to highest: `baseConfig`, then `agentPresets[node.agentType]`,
+ * then `node.agentConfig`. Only keys whose value is `!== undefined` are copied from a
+ * higher tier, so a preset that sets only `model` leaves `baseConfig.provider` intact.
+ *
+ * TOTAL by design: an `agentType` naming a missing preset returns `{ ...baseConfig }`
+ * rather than throwing. That path is unreachable after `assertKnownAgents` runs at
+ * create time, and a helper that threw on it would convert a validation gap into a
+ * mid-graph spawn crash.
+ */
+export function resolveTaskConfig(args) {
+    const resolved = { ...args.baseConfig };
+    // Keyed write surface for the tier copy below. `AgentSessionConfig` has no index
+    // signature, so a per-key assignment needs this widening; the preset schema is a
+    // closed subset of that interface, so every key copied is a real config key.
+    const target = resolved;
+    const preset = args.node.agentType ? args.agentPresets[args.node.agentType] : undefined;
+    for (const tier of [preset, args.node.agentConfig]) {
+        if (!tier) {
+            continue;
+        }
+        for (const [key, value] of Object.entries(tier)) {
+            if (value !== undefined) {
+                target[key] = value;
+            }
+        }
+    }
+    // `cwd` is workflow-owned and never overridable. Two independent guards: the schema
+    // rejects `cwd` at parse time, and this assignment wins over any hand-built object.
+    resolved.cwd = args.baseConfig.cwd;
+    return resolved;
+}
+//# sourceMappingURL=workflow-agent-resolution.js.map