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

package/dist/workflows/run/launch-context.js

@@ -0,0 +1,119 @@
+import { productEnvEntries } from '../../core/product-env.js';
+import { atStepOpen, atContinue } from './launch-read-resolver.js';
+import { provisionArtifactDirectory } from '../../artifacts/lifecycle.js';
+import { handoffPath, refreshHandoffRecords } from '../../handoff.js';
+import { agentTmpEnv } from '../../runs/agent-tmpdir.js';
+import { resolveCapabilities } from '../../server/capabilities.js';
+import { automationCliCommand, automationsPrompt } from '../../automations/prompts.js';
+import { createAutomationSkill } from '../../automations/builtin-skill.js';
+import { registryEntry } from '../../runs/webhook.js';
+import { agentWebhooksPrompt, webhookCliCommand } from '../../webhooks/prompt.js';
+import { agentWebhooks } from '../../workspace/webhooks.js';
+import { buildSessionContext, formatSessionContextReport } from '../../session-context.js';
+import { leadingSlashSkillName } from './prompts.js';
+/** Env for the rolling handoff and artifacts.
+ *
+ *  `TMPDIR`/`TEMP`/`TMP` (#785) point at this run's own scratch directory
+ *  instead of the machine-wide one every agent used to share. Created and
+ *  write-probed here, on the last common path before a spawn, so an unusable
+ *  temp directory throws `AgentTempDirError` at the caller rather than
+ *  turning into empty command output inside a running agent. */
+export function agentEnv({ dataDir }, cockpit, runId, rebrand) {
+    return {
+        ...productEnvEntries('ARTIFACTS_DIR', provisionArtifactDirectory(dataDir, runId), rebrand),
+        ...productEnvEntries('HANDOFF_FILE', handoffPath(dataDir, runId), rebrand),
+        ...productEnvEntries('TASK_ID', runId, rebrand),
+        // Shadow a path inherited from an older parent process.
+        ...productEnvEntries('TODOS_FILE', '', rebrand),
+        ...agentTmpEnv(dataDir, runId),
+        ...(cockpit ? { ...productEnvEntries('COCKPIT_URL', cockpit.origin, rebrand), ...productEnvEntries('PROJECT_ID', cockpit.projectId, rebrand) } : {}),
+    };
+}
+export function agentEnvForStep(...args) {
+    const reads = args[4]?.phase === 'continue' ? atContinue : atStepOpen;
+    return reads.agentEnvForStep(...args);
+}
+/** Automations on AND a cockpit attached: the one predicate behind the prompt part and the built-in skill. */
+export function automationsReachable(cockpit) {
+    return !!cockpit && resolveCapabilities().automations;
+}
+/** The built-in skills this manager may offer now; empty unless automations are reachable. */
+export function builtinSkills(cockpit) {
+    return automationsReachable(cockpit) ? [createAutomationSkill(automationCliCommand())] : [];
+}
+/** The automations part of every session's system prompt, or nothing. */
+export function automationsPart(cockpit) {
+    return automationsReachable(cockpit) ? automationsPrompt(automationCliCommand()) : undefined;
+}
+/** The "Project webhooks" part (#1576): the webhooks this project exposes to agents, read from
+ *  the registry when a session starts. Needs a cockpit to send through; nothing exposed, or an
+ *  unreadable registry, adds nothing. */
+export async function agentWebhooksPart({ repoRoot, home }, cockpit) {
+    if (!cockpit)
+        return undefined;
+    const entry = await registryEntry(cockpit.projectId, repoRoot, home).catch(() => undefined);
+    return agentWebhooksPrompt(webhookCliCommand(), agentWebhooks(entry));
+}
+/**
+ * One launch's session-start context (hearsay-tools/cezarion#1584): the run's own handoff,
+ * then the project's `context.yaml` rules for this recipient, read now and rendered once.
+ * Every launch reports its outcome as one lifecycle line. Both launch sites — a fresh step
+ * and `runContinuation` — come here; a live message never does. The prefix goes into the
+ * opening message only, never the system prompt a worker inherits (#778).
+ */
+export function sessionContextFor({ store, repoRoot, dataDir }, runId, state, stepId, openingPrompt) {
+    const run = store.getRun(runId);
+    const role = run?.delegation?.role === 'worker' ? 'worker' : 'parent';
+    const handoff = handoffPath(dataDir, runId);
+    refreshHandoffRecords(store, dataDir, runId);
+    // A backend's own slash command only works at character zero (#676); a prefix would turn
+    // it into plain text, so such a launch gets no context and keeps the read instruction.
+    const context = leadingSlashSkillName(openingPrompt)
+        ? { prefix: '', handoffInjected: false, reports: [{ id: 'session-context', status: 'skipped', sources: [], reason: 'the opening message is a slash command, which must stay at its start' }] }
+        : buildSessionContext({
+            projectRoot: repoRoot,
+            cwd: state.liveSession.cwd,
+            role,
+            handoffPath: handoff,
+            variables: {
+                ...(run ? atStepOpen.contextVariables(run) : {}),
+                'run.id': runId,
+                role,
+                'step.id': stepId,
+                'project.root': repoRoot,
+                'worktree.root': state.liveSession.cwd,
+                'handoff.path': handoff,
+            },
+        });
+    store.appendEvent(runId, { type: 'lifecycle', message: formatSessionContextReport(context.reports) });
+    return context;
+}
+/** The pinned identity one agent step of an owned worker runs under; undefined for ordinary and internal runs. */
+export const workerStep = atStepOpen.workerStep;
+export function setCockpitAddress(host, address) {
+    host.setCockpit(address ? { ...address } : undefined);
+}
+export function cockpitAddress(cockpit) {
+    return cockpit ? { ...cockpit } : undefined;
+}
+export function setDelegationProvisioner(host, provisioner) {
+    host.setProvisioner(provisioner);
+    return () => {
+        if (host.delegationProvisioner() === provisioner)
+            host.setProvisioner(undefined);
+        for (const state of host.active.values()) {
+            state.liveSession.revokeDelegation?.();
+            state.liveSession.clearDelegationRevoker();
+        }
+    };
+}
+export function provisionSession(host, runId, state) {
+    state.liveSession.revokeDelegation?.();
+    state.liveSession.clearDelegationRevoker();
+    if (host.historyDeletionPending(runId))
+        return;
+    const session = host.delegationProvisioner()?.(runId);
+    state.liveSession.installDelegationRevoker(session?.revoke);
+    return session;
+}
+//# sourceMappingURL=launch-context.js.map

package/dist/workflows/run/launch-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch-context.js","sourceRoot":"","sources":["../../../src/workflows/run/launch-context.ts"],"names":[],"mappings":"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"}

package/dist/workflows/run/launch-read-resolver.d.ts

@@ -0,0 +1,510 @@
+/** Owns launch source selection. Call each narrow operation at its original phase boundary. */
+import type { Home } from '../../home/home.ts';
+import { type CezConfig } from '../../config.ts';
+import type { AgentRunner, ContentBlock, RunnerFactory, RunnerId } from '../../core/agent-runner.ts';
+import { continuationDefStep, type WorkerAccountBinding, type WorkerStepIdentity } from '../../delegation/execution-identity.ts';
+import type { QueuedMessage, RunRecord, RunStore, StepState } from '../../runs/store.ts';
+import { filterDisabledTeamSkills, readDisabledTeamSkills, type Skill } from '../../skills.ts';
+import { readProjectUiState, readProjectUiStateSync } from '../../ui-state.ts';
+import type { ActiveRun } from '../active-run.ts';
+import { type PastedContent, type PersistedAttachment } from '../pasted-content.ts';
+import { executionAccount } from '../execution-account.ts';
+import { accountHeldFor, queuedRecoveryInput } from '../run-scheduling.ts';
+import { type WorkflowDef, type WorkflowStepDef } from '../types.ts';
+import type { LaunchContextHost } from './launch-context.ts';
+import type { OpeningHost } from './opening.ts';
+import type { PendingJob } from './run-line.ts';
+import type { QueuedRevivalHost } from './queued-revival.ts';
+import type { ContinuationOpening, Execution, PendingContinuation, RunModuleContext, StartRunInput, StepModel } from './types.ts';
+declare function readLaunchConfig(repoRoot: string, home: Home): Promise<LaunchConfig>;
+type LaunchContext = Pick<RunModuleContext, 'store' | 'repoRoot' | 'dataDir' | 'home'>;
+/**
+ * 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.
+ */
+declare function continuationModel(store: RunStore, repoRoot: string, runId: string, state: ActiveRun, record: RunRecord | undefined, toolsStep: WorkflowStepDef | undefined, stepIdentity: WorkerStepIdentity | undefined, backend: RunnerId, home: Home): Promise<{
+    backendModel: string | undefined;
+} | string>;
+/** 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. */
+declare function continuationEffort(repoRoot: string, record: RunRecord | undefined, toolsStep: WorkflowStepDef | undefined, stepIdentity: WorkerStepIdentity | undefined, home: Home): {
+    effort: string | undefined;
+} | string;
+/** 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). */
+declare function continuationRunner(backend: RunnerId, sessionId: string | undefined, owningStep: RunRecord['steps'][number] | undefined, factory: RunnerFactory): {
+    runner: AgentRunner;
+    skipSkillOnResume: boolean;
+};
+/**
+ * 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.
+ */
+declare function taskModelIdentity(repoRoot: string, taskBackend: RunnerId, source: SourceInput, home: Home): Promise<string | 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.
+ */
+declare function stepModel(store: RunStore, repoRoot: string, runId: string, state: ActiveRun, step: WorkflowStepDef, source: SourceInput, stepBackend: RunnerId, stepIdentity: WorkerStepIdentity | undefined, home: Home): Promise<StepModel | string>;
+/** 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`. */
+declare function stepEffort(store: RunStore, runId: string, step: WorkflowStepDef, input: StartRunInput, stepIdentity: WorkerStepIdentity | undefined, modelsLocked: boolean): string | undefined;
+export declare const atTaskHead: {
+    executionPayload: typeof executionPayload;
+    queuedPayload: typeof queuedPayload;
+    resumedPayload: typeof resumedPayload;
+    acceptedWorkflowFields: typeof acceptedWorkflowFields;
+    recordedRunner: typeof recordedRunner;
+    defaultRunner: typeof defaultRunner;
+    runnerless: typeof runnerless;
+    heldFor: typeof heldFor;
+    accountFor: typeof accountFor;
+    workerStep: typeof workerStep;
+    executionInput: typeof executionInput;
+    executionWorkflow: typeof executionWorkflow;
+    requeueJob: typeof requeueJob;
+    baseBranch: typeof baseBranch;
+    worktreeSetup: typeof continuationWorktreeSetup;
+    jobInput: typeof jobInput;
+    jobWorkflow: typeof jobWorkflow;
+    resumedJob: typeof resumedJob;
+    storedWorkflow: typeof storedWorkflow;
+    interruptedIndex: typeof interruptedIndex;
+    interruptedDefinition: typeof interruptedDefinition;
+    heldAccount: typeof heldAccount;
+    worktree: typeof inputWorktree;
+    workflowName: typeof workflowName;
+    images: typeof acceptedImages;
+    task: typeof acceptedTask;
+    skillHint: typeof acceptedSkillHint;
+    ownedJob: typeof ownedJob;
+    verifyIdentity: typeof verifyWorkerIdentity;
+    autonomous: typeof inputAutonomous;
+    reviveWorkflow: typeof reviveWorkflow;
+    queuedResumeSession: typeof queuedResumeSession;
+    recoveryInput: typeof queuedRecoveryInput;
+    registry: typeof discoverRunSkills;
+    acceptedRunFields: typeof acceptedRunFields;
+    acceptInput: typeof acceptInput;
+    modelIdentity: typeof taskModelIdentity;
+    config: typeof readLaunchConfig;
+    runner: typeof taskRunner;
+    systemPrompt: typeof taskSystemPrompt;
+    hydrateQueuedInput: typeof hydrateQueuedInput;
+    attachments: typeof readPersistedAttachments;
+};
+export declare const atStepOpen: {
+    afterStepPayload: typeof afterStepPayload;
+    sessionPayload: typeof sessionPayload;
+    sessionWaitPayload: typeof sessionWaitPayload;
+    retryIndex: typeof retryIndex;
+    workflowLength: typeof workflowLength;
+    workflowStep: typeof workflowStep;
+    workflowSlice: typeof workflowSlice;
+    workflowChainNote: typeof workflowChainNote;
+    runner: typeof stepRunner;
+    prompt: typeof stepPrompt;
+    skill: typeof stepSkill;
+    toolGrant: typeof continuationToolGrant;
+    enabledSkills: (state: ActiveRun, repoRoot: string, disabled: ReturnType<typeof readDisabledTeamSkills>) => Skill[];
+    disabledSkills: typeof readDisabledTeamSkills;
+    projectUiState: typeof readProjectUiState;
+    projectUiStateSync: typeof readProjectUiStateSync;
+    teamSkills: typeof teamSkills;
+    filterSkills: typeof filterDisabledTeamSkills;
+    contextVariables: typeof contextVariables;
+    model: typeof stepModel;
+    effort: typeof stepEffort;
+    openingInputs: typeof openingInputs;
+    agentEnvForStep: typeof agentEnvForStep;
+    workerStep: typeof workerStep;
+};
+export declare const atLiveInput: {
+    disabledSkills: typeof readDisabledTeamSkills;
+    projectUiState: typeof readProjectUiState;
+    projectUiStateSync: typeof readProjectUiStateSync;
+    teamSkills: typeof teamSkills;
+    filterSkills: typeof filterDisabledTeamSkills;
+    queuedMessages: typeof queuedMessageSource;
+    taskAttachmentUrls: typeof taskAttachmentUrls;
+    enabledSkills: (state: ActiveRun, repoRoot: string, disabled: ReturnType<typeof readDisabledTeamSkills>) => Skill[];
+};
+export declare const atContinue: {
+    resumedStep: typeof resumedStep;
+    storedWorkflow: typeof storedWorkflow;
+    workflowStep: typeof workflowStep;
+    workflowLength: typeof workflowLength;
+    agentEnvForStep: typeof agentEnvForStep;
+    workerStep: typeof workerStep;
+    registry: typeof discoverRunSkills;
+    enabledSkills: (state: ActiveRun, repoRoot: string, disabled: ReturnType<typeof readDisabledTeamSkills>) => Skill[];
+    disabledSkills: typeof readDisabledTeamSkills;
+    projectUiState: typeof readProjectUiState;
+    projectUiStateSync: typeof readProjectUiStateSync;
+    teamSkills: typeof teamSkills;
+    filterSkills: typeof filterDisabledTeamSkills;
+    isPrintTransport: typeof printSessionTransport;
+    skill: typeof continuedSkill;
+    checkpoint: typeof continuedCheckpoint;
+    prompt: typeof continuedPrompt;
+    rejoinLine: typeof rejoinContinuationLine;
+    verifyIdentity: typeof verifyWorkerIdentity;
+    waitingBeforeFinalWorkflowStep: typeof waitingBeforeFinalWorkflowStep;
+    waitingWorkflowStepIndex: typeof waitingWorkflowStepIndex;
+    continuationNextStep: typeof continuationNextStep;
+    ciWorkflowResumeStepIndex: typeof ciWorkflowResumeStepIndex;
+    resumableSessionId: typeof resumableSessionId;
+    continuedSessionId: typeof continuedSessionId;
+    isSyntheticContinuation: typeof isSyntheticContinuation;
+    owningStep: typeof continuationOwningStep;
+    definitionStep: typeof continuationDefStep;
+    toolGrant: typeof continuationToolGrant;
+    extraSystemPrompt: typeof continuedSystemPrompt;
+    recordedProfile: typeof continuedProfileId;
+    definitionId: typeof continuationStepId;
+    model: typeof continuationModel;
+    effort: typeof continuationEffort;
+    runner: typeof continuationRunner;
+    hydrateQueuedContinuation: typeof hydrateQueuedContinuation;
+    config: typeof readLaunchConfig;
+    worktreeSetup: typeof continuationWorktreeSetup;
+    opening: typeof continuationOpening;
+    openingImages: typeof continuationImages;
+};
+declare function hydrateQueuedInput(context: RunModuleContext, readAttachments: AttachmentReader, runId: string, input: StartRunInput): StartRunInput;
+declare function hydrateQueuedContinuation(context: RunModuleContext, readAttachments: AttachmentReader, runId: string, continuation: PendingContinuation): PendingContinuation & {
+    persistedImages: ContentBlock[];
+    persistedAttachments: PersistedAttachment[];
+};
+declare function readPersistedAttachments(context: RunModuleContext, runId: string, urls: string[], kind: 'task' | 'queued' | 'continuation'): PersistedAttachments;
+interface PersistedAttachments {
+    blocks: ContentBlock[];
+    attachments: PersistedAttachment[];
+}
+type AttachmentReader = (runId: string, urls: string[], kind: 'task' | 'queued' | 'continuation') => PersistedAttachments;
+/** 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. */
+declare function continuationOpening(store: RunStore, host: OpeningHost, runId: string, stepId: string, state: ActiveRun, record: RunRecord | undefined, input: {
+    prompt: string;
+    images: PastedContent[];
+    persistedImages: ContentBlock[];
+    persistedAttachments: PersistedAttachment[];
+}): ContinuationOpening;
+/** A Continue's opening images and attachments. */
+declare function continuationImages(host: OpeningHost, runId: string, stepId: string, checkpoint: RunRecord['continuationMessage'], input: {
+    images: PastedContent[];
+    persistedImages: ContentBlock[];
+    persistedAttachments: PersistedAttachment[];
+}): {
+    openingImages: ContentBlock[];
+    attachments: PersistedAttachment[];
+};
+/**
+ * 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.
+ */
+declare function openingInputs(store: RunStore, dataDir: string, execution: Execution): {
+    attachments: PersistedAttachment[];
+    images: ContentBlock[] | undefined;
+};
+declare function agentEnvForStep({ store, repoRoot, home }: LaunchContext, host: LaunchContextHost, runId: string, backend: RunnerId, options?: {
+    recordedProfileId?: string | undefined;
+    stepId?: string | undefined;
+    phase?: 'step-open' | 'continue';
+}): Promise<{
+    env: Record<string, string>;
+    profileId: string;
+    accountBinding?: WorkerAccountBinding | undefined;
+}>;
+declare function workerStep({ store, repoRoot, home }: LaunchContext, runId: string, stepId: string | undefined): WorkerStepIdentity | undefined;
+/** Non-launch readers receive only the setting their operation consumes. */
+export declare function narrowTitleConfig(repoRoot: string, home: Home): Promise<Pick<CezConfig, 'liveTitleUpdates'>>;
+export declare function narrowReviewConfig(repoRoot: string, home: Home): Promise<Pick<CezConfig, 'reviewGate'>>;
+declare function continuationWorktreeSetup(handle: LaunchConfig): unknown;
+/** Opaque handles capture source references. Binding performs no source-field reads. */
+declare class InputToken {
+    #private;
+    constructor();
+}
+declare const configIdentity: unique symbol;
+/** A type-only view keeps loadConfig's original promise and object identity. */
+export type LaunchConfig = {
+    readonly [configIdentity]: never;
+};
+export type LaunchSource = InputToken;
+export declare function bindLaunchSource(input: StartRunInput): LaunchSource;
+declare function taskRunner(source: LaunchSource, config: LaunchConfig): RunnerId;
+declare function taskSystemPrompt(store: RunStore, runId: string, source: LaunchSource, config: LaunchConfig): string | undefined;
+declare function acceptedRunFields(input: StartRunInput, workflow: WorkflowDef, effectiveInput: StartRunInput, clientRequest?: {
+    id: string;
+    hash: string;
+}): Parameters<RunStore['createRun']>[0];
+declare function acceptInput(repoRoot: string, input: StartRunInput, home: Home): StartRunInput;
+declare function discoverRunSkills(repoRoot: string, builtin: Skill[], home: Home): Promise<Skill[]>;
+declare function teamSkills(repoRoot: string, home: Home): Skill[];
+declare function continuationOwningStep(record: RunRecord | undefined, sessionId: string | undefined): RunRecord['steps'][number] | undefined;
+declare function continuationToolGrant(identity: WorkerStepIdentity | undefined, definition: WorkflowStepDef | undefined, backend: RunnerId): import("../../core/agent-runner.ts").ToolGrant;
+declare function continuedSystemPrompt(record: RunRecord | undefined): string | undefined;
+declare function continuedProfileId(owningStep: RunRecord['steps'][number] | undefined): string | undefined;
+declare function continuationStepId(toolsStep: WorkflowStepDef | undefined): string | undefined;
+declare function contextVariables(run: RunRecord): {
+    task: string;
+    'workflow.name': string;
+};
+declare function reviveWorkflow(context: RunModuleContext, host: QueuedRevivalHost, run: RunRecord): Promise<WorkflowDef | null>;
+declare function queuedResumeSession(context: RunModuleContext, host: QueuedRevivalHost, run: RunRecord, sessionStep: RunRecord['steps'][number]): {
+    backend: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi";
+    sessionBackend: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi";
+    sameAccount: boolean;
+    recoveredSessionId: string | undefined;
+};
+type SyntheticContinuationRead = (run: RunRecord, step: StepState) => boolean;
+/** 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. */
+declare function waitingBeforeFinalWorkflowStep(run: RunRecord, isSyntheticContinuation: SyntheticContinuationRead, waitingWorkflowStepIndex: (run: RunRecord) => number): boolean;
+/** Locate the original workflow step whose closed session a synthetic Continue is resuming. */
+declare function waitingWorkflowStepIndex(run: RunRecord, isSyntheticContinuation: SyntheticContinuationRead, ciWorkflowResumeStepIndex: (run: RunRecord) => number): number;
+declare function continuationNextStep(store: Pick<RunStore, 'getRun'>, runId: string, waitingWorkflowStepIndex: (run: RunRecord) => number): WorkflowStepDef | undefined;
+declare function ciWorkflowResumeStepIndex(run: RunRecord): number;
+/**
+ * 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.
+ */
+declare function resumableSessionId(store: Pick<RunStore, 'getRun' | 'readEvents'>, runId: string, sessionStep: StepState | undefined): string | undefined;
+/** 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. */
+declare function continuedSessionId(record: RunRecord | undefined, continuationStepId: string, resumeSessionId: string | undefined): string | undefined;
+declare function isSyntheticContinuation(run: RunRecord, step: StepState): boolean;
+declare function verifyWorkerIdentity(store: RunStore, repoRoot: string, runId: string, home: Home): void;
+declare function inputAutonomous(input: StartRunInput): boolean;
+declare function ownedJob(context: RunModuleContext, host: {
+    historyDeletionPending(runId: string): boolean;
+}, run: RunRecord): {
+    workflow: WorkflowDef;
+    input: StartRunInput;
+};
+declare function acceptedImages(input: StartRunInput): PastedContent[] | undefined;
+declare function acceptedTask(input: StartRunInput): string;
+declare function acceptedSkillHint(workflow: WorkflowDef): string | undefined;
+declare function stepRunner(step: WorkflowStepDef, taskBackend: RunnerId): RunnerId;
+declare function stepPrompt(step: WorkflowStepDef, source: SourceInput): string;
+declare function stepSkill(step: WorkflowStepDef): string | undefined;
+export declare function namingTask(run: RunRecord): string;
+export declare function namingSkillHint(workflow: WorkflowDef | null): string | undefined;
+declare function queuedMessageSource(run: RunRecord | undefined): QueuedMessage[] | undefined;
+declare function taskAttachmentUrls(run: RunRecord | undefined): string[] | undefined;
+declare function continuedSkill(step: WorkflowStepDef | undefined): string | undefined;
+declare function continuedCheckpoint(run: RunRecord | undefined): RunRecord['continuationMessage'];
+declare function continuedPrompt(run: RunRecord, fallback: string): string;
+declare function rejoinContinuationLine(held: Omit<PendingContinuation, 'lineJoinedAt'>): PendingContinuation;
+declare function printSessionTransport(sessionStep: RunRecord['steps'][number]): boolean;
+declare function inputWorktree(source: SourceInput): boolean | undefined;
+declare function executionPayload<T extends object>(runId: string, workflow: WorkflowDef, fields: T): {
+    runId: string;
+    workflow: {
+        name: string;
+        description?: string | undefined;
+        steps: {
+            id: string;
+            name?: string | undefined;
+            prompt?: string | undefined;
+            skill?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            timeoutMs?: number | undefined;
+            runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+            agentProfile?: string | undefined;
+            allowedTools?: string[] | undefined;
+            bashAllowlist?: string[] | undefined;
+            command?: string | undefined;
+            onFail?: {
+                retry: string;
+                max: number;
+            } | undefined;
+        }[];
+        source: "built-in" | "file";
+        path?: string | undefined;
+    };
+} & T;
+declare function queuedPayload(workflow: WorkflowDef, input: StartRunInput): {
+    workflow: {
+        name: string;
+        description?: string | undefined;
+        steps: {
+            id: string;
+            name?: string | undefined;
+            prompt?: string | undefined;
+            skill?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            timeoutMs?: number | undefined;
+            runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+            agentProfile?: string | undefined;
+            allowedTools?: string[] | undefined;
+            bashAllowlist?: string[] | undefined;
+            command?: string | undefined;
+            onFail?: {
+                retry: string;
+                max: number;
+            } | undefined;
+        }[];
+        source: "built-in" | "file";
+        path?: string | undefined;
+    };
+    input: StartRunInput;
+};
+declare function resumedPayload(workflow: WorkflowDef, startAt: number, input: StartRunInput): {
+    workflow: {
+        name: string;
+        description?: string | undefined;
+        steps: {
+            id: string;
+            name?: string | undefined;
+            prompt?: string | undefined;
+            skill?: string | undefined;
+            model?: string | undefined;
+            effort?: string | undefined;
+            timeoutMs?: number | undefined;
+            runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+            agentProfile?: string | undefined;
+            allowedTools?: string[] | undefined;
+            bashAllowlist?: string[] | undefined;
+            command?: string | undefined;
+            onFail?: {
+                retry: string;
+                max: number;
+            } | undefined;
+        }[];
+        source: "built-in" | "file";
+        path?: string | undefined;
+    };
+    startAt: number;
+    input: StartRunInput;
+};
+declare function afterStepPayload<T extends object>(index: number, step: WorkflowStepDef, nextStep: WorkflowStepDef | undefined, fields: T): {
+    index: number;
+    step: {
+        id: string;
+        name?: string | undefined;
+        prompt?: string | undefined;
+        skill?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        timeoutMs?: number | undefined;
+        runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+        agentProfile?: string | undefined;
+        allowedTools?: string[] | undefined;
+        bashAllowlist?: string[] | undefined;
+        command?: string | undefined;
+        onFail?: {
+            retry: string;
+            max: number;
+        } | undefined;
+    };
+    nextStep: {
+        id: string;
+        name?: string | undefined;
+        prompt?: string | undefined;
+        skill?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        timeoutMs?: number | undefined;
+        runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+        agentProfile?: string | undefined;
+        allowedTools?: string[] | undefined;
+        bashAllowlist?: string[] | undefined;
+        command?: string | undefined;
+        onFail?: {
+            retry: string;
+            max: number;
+        } | undefined;
+    } | undefined;
+} & T;
+declare function sessionPayload<T extends object>(step: WorkflowStepDef, fields: T): {
+    step: {
+        id: string;
+        name?: string | undefined;
+        prompt?: string | undefined;
+        skill?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        timeoutMs?: number | undefined;
+        runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+        agentProfile?: string | undefined;
+        allowedTools?: string[] | undefined;
+        bashAllowlist?: string[] | undefined;
+        command?: string | undefined;
+        onFail?: {
+            retry: string;
+            max: number;
+        } | undefined;
+    };
+} & T;
+declare function sessionWaitPayload<T extends object>(stepId: string, nextStep: WorkflowStepDef | undefined, fields: T): {
+    stepId: string;
+    nextStep: {
+        id: string;
+        name?: string | undefined;
+        prompt?: string | undefined;
+        skill?: string | undefined;
+        model?: string | undefined;
+        effort?: string | undefined;
+        timeoutMs?: number | undefined;
+        runner?: "claude" | "codex" | "cursor" | "omp" | "opencode" | "pi" | undefined;
+        agentProfile?: string | undefined;
+        allowedTools?: string[] | undefined;
+        bashAllowlist?: string[] | undefined;
+        command?: string | undefined;
+        onFail?: {
+            retry: string;
+            max: number;
+        } | undefined;
+    } | undefined;
+} & T;
+declare function acceptedWorkflowFields(workflow: WorkflowDef): Pick<RunRecord, 'workflowDef'>;
+declare function workflowName(workflow: WorkflowDef): string;
+declare function workflowLength(workflow: WorkflowDef): number;
+declare function workflowStep(workflow: WorkflowDef, index: number): WorkflowStepDef | undefined;
+declare function workflowSlice(workflow: WorkflowDef, start: number, end: number): WorkflowStepDef[];
+declare function workflowChainNote(workflow: WorkflowDef, index: number): string | undefined;
+declare function jobInput(job: PendingJob): StartRunInput;
+declare function jobWorkflow(job: PendingJob): WorkflowDef;
+declare function resumedJob(run: RunRecord, job: PendingJob): PendingJob;
+declare function storedWorkflow(run: RunRecord): WorkflowDef | undefined;
+declare function interruptedIndex(run: RunRecord, stepId: string | undefined): number;
+declare function interruptedDefinition(run: RunRecord, index: number): WorkflowStepDef | undefined;
+declare function heldAccount(run: RunRecord, runner: RunnerId, readHolds: () => Parameters<typeof accountHeldFor>[1]): boolean;
+declare function resumedStep(run: RunRecord, waitingIndex: () => number): WorkflowStepDef | undefined;
+declare function executionInput(execution: Execution): LaunchSource;
+declare function executionWorkflow(execution: Execution): WorkflowDef;
+declare function baseBranch(handle: LaunchConfig): string | undefined;
+declare function retryIndex(workflow: WorkflowDef, step: WorkflowStepDef): number;
+declare function requeueJob(workflow: WorkflowDef, source: SourceInput, startAt: number | undefined): PendingJob;
+type SourceInput = StartRunInput | LaunchSource;
+declare function recordedRunner(run: RunRecord): RunnerId | undefined;
+declare function defaultRunner(config: LaunchConfig): RunnerId;
+declare function runnerless(store: Pick<RunStore, 'getRun'>, id: string): boolean;
+declare function heldFor(...args: Parameters<typeof accountHeldFor>): boolean;
+declare function accountFor(...args: Parameters<typeof executionAccount>): ReturnType<typeof executionAccount>;
+export {};