@hearsay-tools/squawk 0.0.0-stage → 0.17.0-dev.5682

package/dist/workflows/run/launch-read-resolver.js

@@ -0,0 +1,658 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isImageAttachmentName } from '../../contract/index.js';
+import { delegationStateSchema } from '../../contract/index.js';
+import { readAgentModelProvider } from '../../agent-config/models.js';
+import { loadConfig, readDisabledSkillsReposSync } from '../../config.js';
+import { buildChildEnv } from '../../core/agent-env.js';
+import { AGENT_MODELS_LOCKED_ERROR, agentModelsLocked } from '../../core/agent-model-policy.js';
+import { ModelIdentityError, formatModelIdentity, normalizeModelForBackend } from '../../core/model-identity.js';
+import { RUNNER_FACTS } from '../../core/runner-facts.js';
+import { parseDelegationEffort } from '../../delegation/effort.js';
+import { boundWorkerAccountEnv, captureWorkerAccount, continuationDefStep, ownedWorkflow, workerIdentity, workerStepIdentity, WorkerIdentityError } from '../../delegation/execution-identity.js';
+import { DelegationPolicyError } from '../../delegation/policy.js';
+import { makeRunTitle } from '../../runs/run-title.js';
+import { discoverSkills, filterDisabledTeamSkills, filterDisabledTeamSources, readDisabledTeamSkills } from '../../skills.js';
+import { getTeamSkillsCached } from '../../skills-remote.js';
+import { readProjectUiState, readProjectUiStateSync } from '../../ui-state.js';
+import { DEFAULT_AGENT_ACCOUNT_ID } from '../../workspace/agent-accounts.js';
+import { resolveProfileEnvForRoot } from '../../workspace/agent-profiles.js';
+import { resolveAttachmentPath } from '../attachment-path.js';
+import { loadWorkflows } from '../load.js';
+import { contentBlocksOf, mediaTypeFor } from '../pasted-content.js';
+import { executionAccount } from '../execution-account.js';
+import { accountHeldFor, queuedRecoveryInput, queuedStartAt } from '../run-scheduling.js';
+import { QUICK_TASK_WORKFLOW, chainStepNote, stepKind, stepToolGrant } from '../types.js';
+import { agentInputOutcomeText } from './input-batch.js';
+import { applyTemplate, resolveExtraSystemPrompt } from './prompts.js';
+// This view adds no promise continuation before the caller's original post-config gate.
+function readLaunchConfig(repoRoot, home) {
+    return loadConfig(repoRoot, home);
+}
+async function configuredModelProvider(backend, repoRoot) {
+    return readAgentModelProvider(backend, repoRoot).catch(() => undefined);
+}
+/** The model-identity gate shared by fresh steps and Continue. */
+async function resolveLaunchModel(backend, model, cwd) {
+    return normalizeModelForBackend(backend, model, { configuredProvider: await configuredModelProvider(backend, cwd) });
+}
+/**
+ * The model a Continue runs with, or the model identity error's message.
+ * Apply the SAME canonical-identity gate the first spawn applies.
+ * A follow-up may switch both runner and model, so without this the record keeps
+ * asserting the identity the run STARTED with while a different model serves the turn —
+ * the exact defect that PR existed to remove — and the raw record string reaches the CLI
+ * in the un-normalised wire form the first step already converted away (`anthropic/opus`
+ * instead of `opus`). Fail loud here too rather than let the backend pick a default.
+ */
+async function continuationModel(store, repoRoot, runId, state, record, toolsStep, stepIdentity, backend, home) {
+    // The owning step's authored `model` wins over the run-level pin, exactly as the first
+    // spawn resolved `step.model ?? input.model`: a catalog worker keeps the
+    // parent's inherited model at run level, so reading only the record silently switched a
+    // step authored for another model on Continue.
+    try {
+        const normalized = await resolveLaunchModel(backend, agentModelsLocked(repoRoot, process.env, home) ? undefined : stepIdentity ? stepIdentity.model : toolsStep?.model ?? record?.model, state.liveSession.cwd);
+        store.updateRun(runId, {
+            modelIdentity: normalized ? formatModelIdentity(normalized.identity) : undefined,
+        });
+        return { backendModel: normalized?.backendModel };
+    }
+    catch (err) {
+        if (!(err instanceof ModelIdentityError))
+            throw err;
+        return err.message;
+    }
+}
+/** The effort a Continue runs at, or the message of the error that refuses it: an owned worker's
+ *  pinned effort, else the continued step's authored one, else the run's; unset when the project
+ *  locks agent models. */
+function continuationEffort(repoRoot, record, toolsStep, stepIdentity, home) {
+    try {
+        const modelsLocked = agentModelsLocked(repoRoot, process.env, home);
+        const authoredStepEffort = toolsStep?.effort !== undefined;
+        if (modelsLocked && toolsStep?.effort?.trim())
+            throw new Error(AGENT_MODELS_LOCKED_ERROR);
+        const stepEffort = parseDelegationEffort(toolsStep?.effort);
+        return {
+            effort: modelsLocked
+                ? undefined
+                : stepIdentity ? stepIdentity.effort : authoredStepEffort ? stepEffort : record?.effort,
+        };
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}
+/** The Continue's runner, and whether it resumes into a thread that already holds the skill
+ *  playbook. A resumed session keeps the transport its owning step recorded. The Cursor runner
+ *  refuses a resume not recorded on print, untagged ones included (hearsay-tools/cezarion#1267). */
+function continuationRunner(backend, sessionId, owningStep, factory) {
+    const sessionTransport = sessionId !== undefined ? owningStep?.sessionTransport : undefined;
+    const runner = factory(backend, sessionTransport ? { sessionTransport } : {});
+    return { runner, skipSkillOnResume: sessionId !== undefined && runner.systemPromptOnResume === 'in-thread' };
+}
+/**
+ * Canonical provider/model identity — the normalised `provider/model`
+ * the task ran with, persisted for cost attribution / reproducible replay
+ * beside the free-text `model`. Best-effort here (a per-step `runner`/`model`
+ * can still override it); the authoritative fail-loud gate is at spawn.
+ */
+async function taskModelIdentity(repoRoot, taskBackend, source, home) {
+    const input = sourceInput(source);
+    try {
+        const normalized = await resolveLaunchModel(taskBackend, agentModelsLocked(repoRoot, process.env, home) ? undefined : input.model, repoRoot);
+        return normalized ? formatModelIdentity(normalized.identity) : undefined;
+    }
+    catch {
+        // An unresolvable task-level model surfaces loudly at the step; the
+        // metadata echo stays absent rather than guessing.
+        return undefined;
+    }
+}
+/**
+ * The model and effort a fresh step runs with. Normalise the selected model to canonical
+ * `provider/model` and back to the backend's own wire form via the ONE shared mapper.
+ * Fail-loud: an unresolvable model (e.g. a bare id on opencode) returns the step error
+ * instead of letting the backend silently substitute its default.
+ */
+async function stepModel(store, repoRoot, runId, state, step, source, stepBackend, stepIdentity, home) {
+    const input = sourceInput(source);
+    try {
+        const modelsLocked = agentModelsLocked(repoRoot, process.env, home);
+        if (modelsLocked && step.effort?.trim())
+            return AGENT_MODELS_LOCKED_ERROR;
+        const effectiveEffort = stepEffort(store, runId, step, input, stepIdentity, modelsLocked);
+        const normalized = await resolveLaunchModel(stepBackend, modelsLocked ? undefined : stepIdentity ? stepIdentity.model : step.model ?? input.model, state.liveSession.cwd);
+        // Persist the identity of what ACTUALLY runs. The run-start echo
+        // (line ~993) is best-effort from `taskBackend`/`input.model`; a per-step `runner`/`model`
+        // override makes it assert a model that never ran. Re-write it here, from the resolved
+        // step identity, so the record — the product of this PR — is always one that ran.
+        store.updateRun(runId, {
+            modelIdentity: normalized ? formatModelIdentity(normalized.identity) : undefined,
+        });
+        return { backendModel: normalized?.backendModel, effectiveEffort };
+    }
+    catch (err) {
+        if (err instanceof ModelIdentityError || err instanceof DelegationPolicyError)
+            return err.message;
+        throw err;
+    }
+}
+/** The effort a fresh step runs at: an owned worker's pinned effort, else the step's authored one,
+ *  else the run's; unset when the project locks agent models. An invalid authored effort throws
+ *  `DelegationPolicyError`. */
+function stepEffort(store, runId, step, input, stepIdentity, modelsLocked) {
+    const authoredStepEffort = step.effort !== undefined;
+    const stepEffort = parseDelegationEffort(step.effort);
+    return modelsLocked
+        ? undefined
+        : stepIdentity ? stepIdentity.effort : authoredStepEffort ? stepEffort : store.getRun(runId)?.effort ?? input.effort;
+}
+// The method name also preserves P1's catalog-reader guard. Registry storage stays in RunSkills.
+const skillSourceReads = {
+    enabledSkills(state, repoRoot, disabled) {
+        const sources = filterDisabledTeamSources(state.skills.catalog ?? [], readDisabledSkillsReposSync(repoRoot));
+        return filterDisabledTeamSkills(sources, disabled);
+    },
+};
+export const atTaskHead = { executionPayload, queuedPayload, resumedPayload, acceptedWorkflowFields, recordedRunner, defaultRunner, runnerless, heldFor, accountFor, workerStep, executionInput, executionWorkflow, requeueJob, baseBranch, worktreeSetup: continuationWorktreeSetup, jobInput, jobWorkflow, resumedJob, storedWorkflow, interruptedIndex, interruptedDefinition, heldAccount, worktree: inputWorktree, workflowName, images: acceptedImages, task: acceptedTask, skillHint: acceptedSkillHint, ownedJob, verifyIdentity: verifyWorkerIdentity, autonomous: inputAutonomous, reviveWorkflow, queuedResumeSession, recoveryInput: queuedRecoveryInput, registry: discoverRunSkills, acceptedRunFields, acceptInput, modelIdentity: taskModelIdentity, config: readLaunchConfig, runner: taskRunner, systemPrompt: taskSystemPrompt, hydrateQueuedInput, attachments: readPersistedAttachments };
+export const atStepOpen = { afterStepPayload, sessionPayload, sessionWaitPayload, retryIndex, workflowLength, workflowStep, workflowSlice, workflowChainNote, runner: stepRunner, prompt: stepPrompt, skill: stepSkill, toolGrant: continuationToolGrant, enabledSkills: skillSourceReads.enabledSkills, disabledSkills: readDisabledTeamSkills, projectUiState: readProjectUiState, projectUiStateSync: readProjectUiStateSync, teamSkills, filterSkills: filterDisabledTeamSkills, contextVariables, model: stepModel, effort: stepEffort, openingInputs, agentEnvForStep, workerStep };
+export const atLiveInput = { disabledSkills: readDisabledTeamSkills, projectUiState: readProjectUiState, projectUiStateSync: readProjectUiStateSync, teamSkills, filterSkills: filterDisabledTeamSkills, queuedMessages: queuedMessageSource, taskAttachmentUrls, enabledSkills: skillSourceReads.enabledSkills };
+export const atContinue = { resumedStep, storedWorkflow, workflowStep, workflowLength, agentEnvForStep, workerStep, registry: discoverRunSkills, enabledSkills: skillSourceReads.enabledSkills, disabledSkills: readDisabledTeamSkills, projectUiState: readProjectUiState, projectUiStateSync: readProjectUiStateSync, teamSkills, filterSkills: filterDisabledTeamSkills, isPrintTransport: printSessionTransport, skill: continuedSkill, checkpoint: continuedCheckpoint, prompt: continuedPrompt, rejoinLine: rejoinContinuationLine, verifyIdentity: verifyWorkerIdentity, waitingBeforeFinalWorkflowStep, waitingWorkflowStepIndex, continuationNextStep, ciWorkflowResumeStepIndex, resumableSessionId, continuedSessionId, isSyntheticContinuation, owningStep: continuationOwningStep, definitionStep: continuationDefStep, toolGrant: continuationToolGrant, extraSystemPrompt: continuedSystemPrompt, recordedProfile: continuedProfileId, definitionId: continuationStepId, model: continuationModel, effort: continuationEffort, runner: continuationRunner, hydrateQueuedContinuation, config: readLaunchConfig, worktreeSetup: continuationWorktreeSetup, opening: continuationOpening, openingImages: continuationImages };
+function hydrateQueuedInput(context, readAttachments, runId, input) {
+    const run = context.store.getRun(runId);
+    if (!run)
+        return input;
+    const stack = run.queuedMessages ?? [];
+    const task = foldQueuedTask(run.task, stack);
+    // Keep the original in-memory blocks for a live process (including the
+    // best-effort case where persistence failed). Recovery has no such copy,
+    // so rebuild it from the durable task-image URLs.
+    const images = input.images?.length
+        ? input.images
+        : readAttachments(runId, run.taskImages ?? [], 'task').blocks;
+    const stackedImages = readAttachments(runId, stack.flatMap((m) => m.images ?? []), 'queued').blocks;
+    return {
+        ...input,
+        task,
+        ...(images.length ? { images } : { images: undefined }),
+        ...(stackedImages.length ? { stackedImages } : { stackedImages: undefined }),
+    };
+}
+function hydrateQueuedContinuation(context, readAttachments, runId, continuation) {
+    const run = context.store.getRun(runId);
+    if (!run) {
+        return { ...continuation, persistedImages: [], persistedAttachments: [] };
+    }
+    const stack = run.queuedMessages ?? [];
+    const amendedTask = foldQueuedTask(run.task, stack);
+    const openingPrompt = run.continuationMessage?.text ?? continuation.prompt;
+    const prompt = queuedContinuationPrompt(openingPrompt, amendedTask);
+    const persisted = readAttachments(runId, stack.flatMap((message) => message.images ?? []), 'queued');
+    return {
+        ...continuation,
+        prompt,
+        persistedImages: persisted.blocks,
+        persistedAttachments: persisted.attachments,
+    };
+}
+function readPersistedAttachments(context, runId, urls, kind) {
+    const blocks = [];
+    const attachments = [];
+    for (const url of urls) {
+        const name = url.split('/').pop();
+        if (!name || name.includes('..') || name.includes('/') || name.includes('\\'))
+            continue;
+        const path = resolveAttachmentPath(context.dataDir, runId, name);
+        try {
+            if (!path)
+                throw new Error('missing or unsafe attachment');
+            if (isImageAttachmentName(name)) {
+                const data = readFileSync(path);
+                blocks.push({
+                    type: 'image',
+                    source: { type: 'base64', media_type: mediaTypeFor(name), data: data.toString('base64') },
+                });
+            }
+            else if (!existsSync(path)) {
+                throw new Error('missing');
+            }
+            attachments.push({ name, url, path });
+        }
+        catch {
+            // Degrade, never fail the boot (AGENTS.md): the user deleted `.ai/cezar/`
+            // or the file is unreadable — start with the text and say which attachment went.
+            context.store.appendEvent(runId, {
+                type: 'note',
+                message: `${kind} attachment ${name} could not be read — starting without it`,
+            });
+        }
+    }
+    return { blocks, attachments };
+}
+function foldQueuedTask(task, stack) {
+    return [task, ...stack.map(message => message.text)]
+        .map(part => part.trim()).filter(part => part.length > 0).join('\n\n');
+}
+function queuedContinuationPrompt(openingPrompt, amendedTask) {
+    return amendedTask ? `${openingPrompt}\n\nCurrent task and queued updates:\n\n${amendedTask}` : openingPrompt;
+}
+/** A Continue's opening message: the checkpoint's agent input with its outcome, its images and
+ *  attachments, and the `user-message` event that shows it. */
+function continuationOpening(store, host, runId, stepId, state, record, input) {
+    const checkpoint = record?.continuationMessage;
+    state.inputState.selectOpeningInput(checkpoint?.agentInputId);
+    const openingInput = record?.agentInputs?.find(input => input.id === checkpoint?.agentInputId);
+    // Hydration has already included later human updates and task edits. Append
+    // the current obligation outcome without replacing that composed prompt.
+    // A parent's answer to a routed question is shown as its conversation reply, not
+    // as a human message, and its own reply outcome is not news to the worker.
+    const answerSource = openingInput ? host.answerSource(runId, openingInput) : undefined;
+    let prompt = input.prompt;
+    if (openingInput && !answerSource)
+        prompt += agentInputOutcomeText(openingInput, store.getRun(openingInput.parentRunId));
+    const { openingImages, attachments } = continuationImages(host, runId, stepId, checkpoint, input);
+    if (checkpoint?.origin !== 'lifecycle' && !answerSource)
+        store.appendEvent(runId, {
+            type: 'user-message',
+            stepId,
+            text: prompt,
+            imageCount: openingImages.filter((b) => b.type === 'image').length,
+            ...(attachments.length ? { images: attachments.map((saved) => saved.url) } : {}),
+        });
+    return { prompt, checkpoint, ...(answerSource ? { answerSource } : {}), openingImages, attachments };
+}
+/** A Continue's opening images and attachments. */
+function continuationImages(host, runId, stepId, checkpoint, input) {
+    // Attachments pasted into the follow-up composer, on the same terms as a live-session
+    // message: persisted to the run's own attachment store so the thread renders the
+    // bubble's images rather than a bare count, and handed to the agent as absolute paths
+    // appended to the prompt (so it can operate on them — and because codex/opencode drop image
+    // blocks before they reach the model). An image ALSO rides along as a base64 block so the
+    // model can view it; a file has nothing to view and travels as its path alone.
+    const saved = host.readPersistedAttachments(runId, checkpoint?.id === stepId ? checkpoint.images ?? [] : [], 'continuation');
+    const openingImages = [...(input.images.length ? contentBlocksOf(input.images) : saved.blocks), ...input.persistedImages];
+    const attachments = [...saved.attachments, ...input.persistedAttachments];
+    return { openingImages, attachments };
+}
+/**
+ * The task's attachments for the first agent step's opening message, and its image blocks.
+ * Both are empty once an agent step of this workflow has run.
+ */
+function openingInputs(store, dataDir, execution) {
+    const { runId, workflow } = execution;
+    const input = inputValue(execution.input);
+    // `startRun` already persisted the task's attachments so a queued bubble can render them
+    //. Reuse those files for the agent-facing path note instead of minting
+    // duplicate pasted files when execution finally begins.
+    //
+    // The STACK's attachments are listed here too: they were persisted when they were
+    // enqueued, and their paths are the only thing an agent ever gets for a non-image one — a
+    // note that covered the initial prompt alone would hand it a task about a file it was never
+    // told the path of.
+    const startRecord = store.getRun(runId);
+    const openingAlreadyDelivered = workflow.steps.some(definition => stepKind(definition) === 'agent' &&
+        (startRecord?.steps.find(step => step.id === definition.id)?.iterations ?? 0) > 0);
+    const attachments = openingAlreadyDelivered ? [] : [
+        ...(startRecord?.taskImages ?? []),
+        ...(startRecord?.queuedMessages ?? []).flatMap((m) => m.images ?? []),
+    ]
+        .map((url) => {
+        const name = url.split('/').pop();
+        if (!name || name.includes('..') || name.includes('/') || name.includes('\\'))
+            return null;
+        const path = resolveAttachmentPath(dataDir, runId, name);
+        if (!path) {
+            store.appendEvent(runId, {
+                type: 'note',
+                message: `task attachment ${name} could not be read — starting without it`,
+            });
+            return null;
+        }
+        return { name, url, path };
+    })
+        .filter((saved) => saved !== null);
+    // Task screenshots go with the FIRST agent step's opening message only —
+    // later steps and retry loops run in fresh sessions without them. Stacked
+    // attachments ride along too, but are NOT re-persisted above: they
+    // already live on disk, and adding them to `taskImages` would both duplicate
+    // the files and make the task bubble claim the stack's images as its own.
+    // File blocks are dropped here — a session only ever sees viewable blocks. An empty
+    // result stays `undefined` rather than `[]`, so a task carrying only files hands the runner
+    // seam exactly the shape a task carrying nothing always did.
+    const blocks = openingAlreadyDelivered
+        ? []
+        : contentBlocksOf([...(input.images ?? []), ...(input.stackedImages ?? [])]);
+    return { attachments, images: blocks.length ? blocks : undefined };
+}
+async function agentEnvForStep({ store, repoRoot, home }, host, runId, backend, options = {}) {
+    // An owned worker binds the account its identity pinned for THIS step; a legacy identity
+    // answers every step with its single run-level account, so the one-provider rule still holds there.
+    const step = host.workerStep(runId, options.stepId);
+    if (step) {
+        if (backend !== step.account.provider)
+            throw new WorkerIdentityError('Accepted worker provider identity cannot change');
+        const env = host.agentEnv(runId);
+        return { env: { ...env, ...boundWorkerAccountEnv(step.account, buildChildEnv({ backend, extraEnv: env })) },
+            profileId: step.account.profileId, accountBinding: step.account };
+    }
+    const run = store.getRun(runId);
+    const profileId = options.recordedProfileId
+        ?? (backend === (run?.runner ?? 'claude') ? run?.agentProfile : undefined);
+    const resolved = await resolveProfileEnvForRoot(repoRoot, backend, profileId, process.env, home);
+    const env = { ...host.agentEnv(runId), ...resolved.env };
+    return {
+        env,
+        profileId: resolved.profile.id,
+        accountBinding: captureWorkerAccount(resolved.profile, buildChildEnv({ backend, extraEnv: env })),
+    };
+}
+function workerStep({ store, repoRoot, home }, runId, stepId) {
+    const identity = workerIdentity(store, repoRoot, runId, stepId, home);
+    if (!identity)
+        return undefined;
+    return stepId === undefined
+        ? { account: identity.account, grants: identity.grants, ...(identity.model === undefined ? {} : { model: identity.model }), ...(identity.effort === undefined ? {} : { effort: identity.effort }) }
+        : workerStepIdentity(identity, stepId);
+}
+/** Non-launch readers receive only the setting their operation consumes. */
+export function narrowTitleConfig(repoRoot, home) { return loadConfig(repoRoot, home); }
+export function narrowReviewConfig(repoRoot, home) { return loadConfig(repoRoot, home); }
+function continuationWorktreeSetup(handle) {
+    return configValue(handle).worktreeSetup;
+}
+/** Opaque handles capture source references. Binding performs no source-field reads. */
+class InputToken {
+    #identity = true;
+    constructor() { void this.#identity; Object.freeze(this); }
+}
+const launchInputs = new WeakMap();
+export function bindLaunchSource(input) {
+    const handle = new InputToken();
+    launchInputs.set(handle, input);
+    return handle;
+}
+function inputValue(handle) {
+    const input = launchInputs.get(handle);
+    if (!input)
+        throw new TypeError('Invalid launch source handle');
+    return input;
+}
+function configValue(handle) {
+    return handle;
+}
+function taskRunner(source, config) {
+    return inputValue(source).runner ?? configValue(config).defaultRunner;
+}
+function taskSystemPrompt(store, runId, source, config) {
+    return store.getRun(runId)?.delegation?.role === 'worker'
+        ? inputValue(source).systemPrompt
+        : resolveExtraSystemPrompt(inputValue(source).systemPrompt, configValue(config).systemPrompt);
+}
+function acceptedRunFields(input, workflow, effectiveInput, clientRequest) {
+    return {
+        title: makeRunTitle(input.task, workflow),
+        workflow: workflow.name,
+        task: input.task,
+        systemPrompt: input.systemPrompt,
+        model: effectiveInput.model,
+        effort: effectiveInput.effort,
+        runner: input.runner,
+        // The composer's per-task account (spec 2026-07-29-agent-profiles). Persisted at creation
+        // so a queued run picks it up at dequeue and every later resume reads the same answer.
+        agentProfile: input.agentProfile,
+        // Persist autonomy on the record so the terminal review gate
+        // (`settleSuccess`) can honor it — mid-run
+        // auto-nudge reads `input.autonomous` (`execute`), but the record is the
+        // only source those after-the-fact consumers have.
+        autonomous: input.autonomous === true,
+        archiveWhenDone: input.archiveWhenDone,
+        autoMergePr: input.autoMergePr,
+        // Stored explicitly, so a later change of the default never widens an existing task.
+        allowWorkers: input.allowWorkers !== false,
+        allowMessaging: input.allowMessaging !== false,
+        notify: input.notify === true,
+        // Persist the explicit opt-out so queued-run restart recovery and the
+        // session Git routes can distinguish it from a removed isolated worktree.
+        worktree: input.worktree === false ? false : undefined,
+        clientRequestId: clientRequest?.id,
+        clientRequestHash: clientRequest?.hash,
+        automation: input.automation,
+        automationTrigger: input.automationTrigger,
+        steps: workflow.steps.map((s) => ({ id: s.id, name: s.name ?? s.id, kind: stepKind(s) })),
+    };
+}
+function acceptInput(repoRoot, input, home) {
+    return agentModelsLocked(repoRoot, process.env, home) ? { ...input, model: undefined, effort: undefined } : input;
+}
+function discoverRunSkills(repoRoot, builtin, home) {
+    return discoverSkills(repoRoot, { builtin }, home);
+}
+function teamSkills(repoRoot, home) {
+    return filterDisabledTeamSources(getTeamSkillsCached(repoRoot, home), readDisabledSkillsReposSync(repoRoot));
+}
+function continuationOwningStep(record, sessionId) {
+    return sessionId === undefined ? undefined : record?.steps.find(candidate => candidate.sessionId === sessionId);
+}
+function continuationToolGrant(identity, definition, backend) {
+    return stepToolGrant(identity?.grants, definition, backend);
+}
+function continuedSystemPrompt(record) { return record?.systemPrompt; }
+function continuedProfileId(owningStep) { return owningStep?.profileId; }
+function continuationStepId(toolsStep) { return toolsStep?.id; }
+function contextVariables(run) {
+    return { task: run.task, 'workflow.name': run.workflow };
+}
+async function reviveWorkflow(context, host, run) {
+    // "Looks sane" is the STORE's job now: it parses `workflowDef` against the definition schema
+    // and `.catch`es a def that no longer fits to `undefined`, so anything present here already
+    // has the `steps` array the old inline `Array.isArray` check was asking for.
+    const def = run.workflowDef;
+    if (def)
+        return def;
+    const { workflows } = await loadWorkflows(context.repoRoot);
+    return workflows.find((w) => w.name === run.workflow) ?? null;
+}
+function queuedResumeSession(context, host, run, sessionStep) {
+    // An accepted worker's continuation extends the step owning the resumed session, so its
+    // runner and account come from that step's pinned identity, never the run-level
+    // first-step fields — those would re-queue a claude review's Continue as a codex turn with
+    // no session to resume. Broken identity evidence is left for the launch to report.
+    let resumeIdentity;
+    try {
+        resumeIdentity = host.workerStep(run.id, continuationDefStep(context.store, run, sessionStep.sessionId)?.id);
+    }
+    catch (error) {
+        if (!(error instanceof WorkerIdentityError))
+            throw error;
+    }
+    const backend = resumeIdentity?.account.provider ?? run.runner ?? 'claude';
+    const sessionBackend = sessionStep.backend ?? backend;
+    const sessionAccount = sessionStep.profileId ?? DEFAULT_AGENT_ACCOUNT_ID;
+    const agentProfile = resumeIdentity?.account.profileId ?? run.agentProfile;
+    const sameAccount = agentProfile === undefined || agentProfile === sessionAccount;
+    const recoveredSessionId = sessionBackend === backend && sameAccount
+        ? host.resumableSessionId(run.id, sessionStep) : undefined;
+    return { backend, sessionBackend, sameAccount, recoveredSessionId };
+}
+/** A synthetic continuation can settle only the resumed agent turn. If the
+ * original workflow still has steps after the waiting one, that would skip
+ * those steps rather than resume the workflow engine. */
+function waitingBeforeFinalWorkflowStep(run, isSyntheticContinuation, waitingWorkflowStepIndex) {
+    const steps = run.workflowDef?.steps ?? run.steps.filter(step => !isSyntheticContinuation(run, step));
+    if (!steps.length || !run.currentStepId)
+        return true;
+    const currentStep = run.steps.find(step => step.id === run.currentStepId);
+    if (currentStep && isSyntheticContinuation(run, currentStep)) {
+        const waiting = waitingWorkflowStepIndex(run);
+        return waiting >= 0 && waiting < steps.length - 1;
+    }
+    const current = steps.findIndex((step) => step.id === run.currentStepId);
+    return current < 0 || current < steps.length - 1;
+}
+/** Locate the original workflow step whose closed session a synthetic Continue is resuming. */
+function waitingWorkflowStepIndex(run, isSyntheticContinuation, ciWorkflowResumeStepIndex) {
+    const steps = run.workflowDef?.steps ?? run.steps.filter(step => !isSyntheticContinuation(run, step));
+    if (!steps.length)
+        return -1;
+    // CI recovery can resume a failed attempt. Its cursor must survive both the
+    // synthetic continuation replacing currentStepId and wait delivery retiring the wait.
+    const ciSource = ciWorkflowResumeStepIndex(run);
+    if (ciSource >= 0)
+        return ciSource;
+    const interrupted = steps.findIndex((step) => {
+        const persisted = run.steps.find((candidate) => candidate.id === step.id);
+        return stepKind(step) === 'agent' && persisted?.status === 'failed' && persisted.error === 'interrupted — cezar process exited during the run';
+    });
+    if (interrupted >= 0)
+        return interrupted;
+    for (let index = steps.length - 1; index >= 0; index--) {
+        const persisted = run.steps.find((step) => step.id === steps[index].id);
+        // Startup recovery records an interrupted live step as failed before it
+        // constructs the synthetic continuation. Later workflow steps are still
+        // pending, so that failed step remains the continuation's source.
+        if (persisted?.status === 'waiting' || persisted?.status === 'running')
+            return index;
+    }
+    return -1;
+}
+function continuationNextStep(store, runId, waitingWorkflowStepIndex) {
+    const run = store.getRun(runId);
+    const index = run?.workflowDef ? waitingWorkflowStepIndex(run) : -1;
+    return index >= 0 ? run.workflowDef.steps[index + 1] : undefined;
+}
+function ciWorkflowResumeStepIndex(run) {
+    if (!run.workflowResumeStepId)
+        return -1;
+    return run.workflowDef?.steps.findIndex(step => step.id === run.workflowResumeStepId &&
+        stepKind(step) === 'agent' && run.steps.find(persisted => persisted.id === step.id)?.status === 'failed') ?? -1;
+}
+/**
+ * The saved session id a Continue can resume, or undefined when it opens a fresh session. A
+ * `launch` runner opened its session under the saved id. A `native` runner replaces Cezar's launch
+ * UUID only with its `session` event (hearsay-tools/cezarion#583, hearsay-tools/cezarion#2991), so
+ * its saved id resumes when a recorded `session` event names it, or when the event history does
+ * not show the launch of the step that first holds the id. Older or salvaged run data can keep a
+ * step without its history; that id keeps its conversation, and a runner that never knew it
+ * refuses the resume. A shown launch with no matching `session` event ended before the runner
+ * reported its id. A `cursor-print` id always needs its print `session` event.
+ */
+function resumableSessionId(store, runId, sessionStep) {
+    const sessionId = sessionStep?.sessionId;
+    if (!sessionId)
+        return undefined;
+    const run = store.getRun(runId);
+    if (RUNNER_FACTS[sessionStep.backend ?? run?.runner ?? 'claude'].sessionIdSource === 'launch')
+        return sessionId;
+    const events = store.readEvents(runId);
+    if (sessionStep.sessionTransport === 'cursor-print')
+        return printSessionConfirmed(run, events, sessionStep) ? sessionId : undefined;
+    if (events.some(event => event.type === 'session' && event.sessionId === sessionId))
+        return sessionId;
+    const owner = run?.steps.find(step => step.sessionId === sessionId) ?? sessionStep;
+    return events.some(event => event.type === 'step-start' && event.stepId === owner.id) ? undefined : sessionId;
+}
+/** A Continue records the existing id before the resumed process emits its own session event.
+ *  After a crash, its original owning step still holds the print-session proof; later steps
+ *  cannot establish that proof. */
+function printSessionConfirmed(run, events, sessionStep) {
+    const sessionStepIndex = run?.steps.findIndex((step) => step.id === sessionStep.id) ?? -1;
+    const printEvidenceSteps = new Set(run?.steps.slice(0, sessionStepIndex + 1)
+        .filter((step) => step.sessionId === sessionStep.sessionId && step.sessionTransport === 'cursor-print')
+        .map((step) => step.id));
+    return events.some((event) => event.type === 'session' && event.sessionId === sessionStep.sessionId &&
+        event.stepId !== undefined && printEvidenceSteps.has(event.stepId) && event.sessionTransport === 'cursor-print');
+}
+/** The recorded session a Continue continues: the one it resumes, else the run's latest recorded
+ *  session from before this Continue's own step. Its owning step names the skill, grants, model,
+ *  effort and worker identity the Continue runs with, also when the Continue opens a fresh session
+ *  (hearsay-tools/cezarion#2991). Undefined when no earlier step recorded a session. */
+function continuedSessionId(record, continuationStepId, resumeSessionId) {
+    return resumeSessionId ?? [...record?.steps ?? []].reverse().find(step => step.id !== continuationStepId && step.sessionId)?.sessionId;
+}
+function isSyntheticContinuation(run, step) {
+    if (step.synthetic === 'continuation')
+        return true;
+    // Legacy records predate explicit provenance. Only an accepted continuation's
+    // durable message links its generated step; an ID prefix alone is never identity.
+    return (run.continuationMessage?.id === step.id ||
+        (!!run.workflowDef && !run.workflowDef.steps.some(candidate => candidate.id === step.id) &&
+            step.kind === 'agent' && step.name === 'Continue')) && /^continue-\d+$/.test(step.id);
+}
+function verifyWorkerIdentity(store, repoRoot, runId, home) {
+    workerIdentity(store, repoRoot, runId, undefined, home);
+}
+function inputAutonomous(input) { return input.autonomous === true; }
+function ownedJob(context, host, run) {
+    const delegation = delegationStateSchema.safeParse(run.delegation);
+    if (host.historyDeletionPending(run.id) || run.status !== 'queued' || !delegation.success || delegation.data.role !== 'worker' ||
+        delegation.data.workspace.ownerRunId !== run.id || delegation.data.destroy) {
+        throw new DelegationPolicyError('incompatible_state', 'Run is not an executable owned creation');
+    }
+    // Accepted permissions are private immutable evidence. Only explicit internal
+    // primitive records retain the public-definition compatibility path.
+    const grants = workerIdentity(context.store, context.repoRoot, run.id, undefined, context.home)?.grants
+        ?? run.workflowDef?.steps.find(step => step.id === QUICK_TASK_WORKFLOW.steps[0].id);
+    return {
+        workflow: ownedWorkflow(run, context.store.readWorkerIdentity(run.id)) ?? { ...QUICK_TASK_WORKFLOW, steps: [{ ...QUICK_TASK_WORKFLOW.steps[0],
+                    ...(grants?.allowedTools === undefined ? {} : { allowedTools: [...grants.allowedTools] }),
+                    ...(grants?.bashAllowlist === undefined ? {} : { bashAllowlist: [...grants.bashAllowlist] }), }] },
+        input: { ...queuedRecoveryInput(run), worktree: true },
+    };
+}
+function acceptedImages(input) { return input.images; }
+function acceptedTask(input) { return input.task; }
+function acceptedSkillHint(workflow) {
+    return workflow.steps.find(candidate => stepKind(candidate) === 'agent' && candidate.skill)?.skill?.trim();
+}
+function stepRunner(step, taskBackend) { return step.runner ?? taskBackend; }
+function stepPrompt(step, source) { return applyTemplate(step.prompt ?? '{{task}}', sourceInput(source).task); }
+function stepSkill(step) { return step.skill; }
+export function namingTask(run) { return run.task; }
+export function namingSkillHint(workflow) {
+    return workflow?.steps.find(candidate => stepKind(candidate) === 'agent' && candidate.skill)?.skill?.trim();
+}
+function queuedMessageSource(run) { return run?.queuedMessages; }
+function taskAttachmentUrls(run) { return run?.taskImages; }
+function continuedSkill(step) { return step?.skill; }
+function continuedCheckpoint(run) { return run?.continuationMessage; }
+function continuedPrompt(run, fallback) { return run.continuationMessage?.text ?? fallback; }
+function rejoinContinuationLine(held) { return { ...held, lineJoinedAt: Date.now() }; }
+function printSessionTransport(sessionStep) { return sessionStep.sessionTransport === 'cursor-print'; }
+function inputWorktree(source) { return sourceInput(source).worktree; }
+function executionPayload(runId, workflow, fields) { return { runId, workflow, ...fields }; }
+function queuedPayload(workflow, input) { return { workflow, input }; }
+function resumedPayload(workflow, startAt, input) { return { workflow, startAt, input }; }
+function afterStepPayload(index, step, nextStep, fields) { return { index, step, nextStep, ...fields }; }
+function sessionPayload(step, fields) { return { step, ...fields }; }
+function sessionWaitPayload(stepId, nextStep, fields) { return { stepId, nextStep, ...fields }; }
+function acceptedWorkflowFields(workflow) { return { workflowDef: workflow }; }
+function workflowName(workflow) { return workflow.name; }
+function workflowLength(workflow) { return workflow.steps.length; }
+function workflowStep(workflow, index) { return workflow.steps[index]; }
+function workflowSlice(workflow, start, end) { return workflow.steps.slice(start, end); }
+function workflowChainNote(workflow, index) { return chainStepNote(workflow.steps, index); }
+function jobInput(job) { return job.input; }
+function jobWorkflow(job) { return job.workflow; }
+function resumedJob(run, job) { return { ...job, startAt: queuedStartAt(run, job.workflow) }; }
+function storedWorkflow(run) { return run.workflowDef; }
+function interruptedIndex(run, stepId) { return run.workflowDef?.steps.findIndex(step => step.id === stepId) ?? -1; }
+function interruptedDefinition(run, index) { return index >= 0 ? run.workflowDef?.steps[index] : undefined; }
+function heldAccount(run, runner, readHolds) {
+    const selected = { ...run, runner };
+    return accountHeldFor(selected, readHolds(), runner);
+}
+function resumedStep(run, waitingIndex) {
+    return run.workflowDef?.steps[waitingIndex()];
+}
+function executionInput(execution) { return execution.input; }
+function executionWorkflow(execution) { return execution.workflow; }
+function baseBranch(handle) { return configValue(handle).baseBranch; }
+function retryIndex(workflow, step) { return workflow.steps.findIndex(candidate => candidate.id === step.onFail?.retry); }
+function requeueJob(workflow, source, startAt) { return { workflow, input: sourceInput(source), startAt }; }
+function sourceInput(source) { return source instanceof InputToken ? inputValue(source) : source; }
+function recordedRunner(run) { return run.runner; }
+function defaultRunner(config) { return configValue(config).defaultRunner; }
+function runnerless(store, id) { return store.getRun(id)?.runner === undefined; }
+function heldFor(...args) { return accountHeldFor(...args); }
+function accountFor(...args) { return executionAccount(...args); }
+//# sourceMappingURL=launch-read-resolver.js.map