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

package/dist/workflows/run/continuation-session.js

@@ -0,0 +1,597 @@
+import { WAIT_KINDS } from './wait-kinds.js';
+import { fallbackProjectWriteError } from '../../project-paths.js';
+import { transitionTurnBoundary } from './turn-boundary.js';
+import { continuationNextStep, waitingWorkflowStepIndex, ciWorkflowResumeStepIndex } from './workflow-position.js';
+import { join } from 'node:path';
+import { inputDeliveryOf } from '../../core/agent-runner.js';
+import { startManagedSession } from '../../core/managed-session.js';
+import { pastedAttachmentsText } from '../pasted-content.js';
+import { continuationOpening } from './opening.js';
+import { createSessionEventHandler, launchPreamble } from './session-events.js';
+import { agentDirectories, composeSystemPrompt, expandRegistrySlashSkillText } from './prompts.js';
+import { continuationRunner } from './launch-settings.js';
+import { preserveRunAfterDisposal } from './run-guards.js';
+import { stepScope } from './steps.js';
+import { clearIdleTimer } from './input-timers.js';
+import * as inputReceipts from './input-receipts.js';
+import { seedHandoffFile } from '../../handoff.js';
+import { atContinue } from './launch-read-resolver.js';
+import { openWaits } from '../waits.js';
+import { toolGrantLists } from '../types.js';
+import { waitForCachedTeamSkills, waitForTeamSkills } from '../../skills-remote.js';
+import { continuationModel, continuationEffort } from './launch-settings.js';
+import { leadingSlashSkillName, skillSystemPrompt } from './prompts.js';
+import { hasPendingHumanAsk, pendingHumanAskSeq } from './pending-ask-facts.js';
+import { clearAutosaveTimer } from './input-timers.js';
+import { REPOSITORY_ROOT_LOCK_DISABLED_NOTE } from './run-workspace.js';
+import * as sessionEvents from './session-events.js';
+import { existsSync } from 'node:fs';
+import { rematerializeReclaimedWorktree } from '../../runs/retention.js';
+import { ownedContinuationWorkspace } from './run-workspace.js';
+/** Owns the Continue workspace and launch session. */
+export class ContinuationSession {
+    context;
+    host;
+    line;
+    sharedHost;
+    repoRootLease;
+    autosave;
+    runSkills;
+    sessionEventHost;
+    launchPreambleHost;
+    inputReceiptHost;
+    inputReceiptSteps;
+    humanWaits;
+    queuedInput;
+    workerQuestions;
+    runSettlement;
+    constructor(context, host, line, sharedHost, repoRootLease, autosave, runSkills, sessionEventHost, launchPreambleHost, inputReceiptHost, inputReceiptSteps, humanWaits, queuedInput, workerQuestions, runSettlement) {
+        this.context = context;
+        this.host = host;
+        this.line = line;
+        this.sharedHost = sharedHost;
+        this.repoRootLease = repoRootLease;
+        this.autosave = autosave;
+        this.runSkills = runSkills;
+        this.sessionEventHost = sessionEventHost;
+        this.launchPreambleHost = launchPreambleHost;
+        this.inputReceiptHost = inputReceiptHost;
+        this.inputReceiptSteps = inputReceiptSteps;
+        this.humanWaits = humanWaits;
+        this.queuedInput = queuedInput;
+        this.workerQuestions = workerQuestions;
+        this.runSettlement = runSettlement;
+    }
+    /** Where a Continue runs: an owned worker's verified workspace, or the task's worktree, which
+     *  retention may have reclaimed (#483), else the repository root. Returns undefined after an
+     *  unavailable owned workspace failed the run. */
+    async continuationWorkspace(runId, stepId, record) {
+        const path = record?.worktreePath ?? (record?.delegation?.role === 'worker' ? record.delegation.workspace.path : undefined);
+        const refusal = path && fallbackProjectWriteError(path);
+        if (refusal) {
+            this.failWorkspace(runId, stepId, refusal);
+            return undefined;
+        }
+        if (record?.delegation?.role === 'worker') {
+            const cwd = await this.ownedContinuationWorkspace(runId, stepId, record, record.delegation);
+            return cwd === undefined ? undefined : { cwd, rematerialized: false };
+        }
+        // Retention (#483) rebuilt a reclaimed directory: a bare checkout that needs setup again (#917).
+        const rematerialized = await rematerializeReclaimedWorktree(this.context.repoRoot, this.context.store, runId);
+        const cwd = record?.worktreePath && existsSync(record.worktreePath) ? record.worktreePath : this.context.repoRoot;
+        return { cwd, rematerialized };
+    }
+    /** An owned worker's workspace for a Continue, verified with its parent's context. Returns
+     *  undefined after it failed the run: owned workers never adopt or recreate an unverified resource. */
+    async ownedContinuationWorkspace(runId, stepId, record, delegation) {
+        try {
+            return await ownedContinuationWorkspace(this.context.store, this.context.repoRoot, this.context.dataDir, record, delegation);
+        }
+        catch (error) {
+            const message = `owned workspace unavailable: ${error instanceof Error ? error.message : String(error)}`;
+            this.failWorkspace(runId, stepId, message);
+            return undefined;
+        }
+    }
+    failWorkspace(runId, stepId, message) {
+        const finishedAt = new Date().toISOString();
+        this.context.store.updateStep(runId, stepId, { status: 'failed', error: message, finishedAt });
+        this.host.move(runId, 'fail-start', { error: message, finishedAt });
+        this.context.store.appendEvent(runId, { type: 'lifecycle', message });
+        this.line.unmarkStarting(runId);
+        this.host.dropActive(runId);
+    }
+    /** A Stop that arrived while the Continue resolved its workspace cancels the run before it
+     *  becomes active. */
+    settleStoppedContinuation(runId) {
+        if (!this.context.store.getRun(runId)?.stopping)
+            return false;
+        this.host.move(runId, 'cancel');
+        this.line.unmarkStarting(runId);
+        this.host.dropActive(runId);
+        return true;
+    }
+    /** The repository-root lease of a Continue that runs in the repository root. Returns undefined
+     *  when no lease is needed, so that path does not yield, else whether the lease was granted. */
+    continuationRepoRootLease(runId, state) {
+        if (state.liveSession.cwd !== this.context.repoRoot)
+            return undefined;
+        if (this.host.repositoryRootLockDisabled()) {
+            this.context.store.appendEvent(runId, {
+                type: 'note',
+                message: REPOSITORY_ROOT_LOCK_DISABLED_NOTE,
+            });
+            return undefined;
+        }
+        this.context.store.appendEvent(runId, {
+            type: 'note',
+            message: 'waiting for exclusive access to the repository working tree',
+        });
+        return this.acquireContinuationRepoRoot(runId, state);
+    }
+    /** Wait for the repository-root lease; a Stop during the wait cancels the run. */
+    async acquireContinuationRepoRoot(runId, state) {
+        if (await this.repoRootLease.acquireRepoRoot(runId, state))
+            return true;
+        this.host.move(runId, 'cancel');
+        this.host.dropActive(runId);
+        return false;
+    }
+    /** Arm autosave, seed the handoff file, and run worktree setup. Returns setup's note for the
+     *  opening message. */
+    async prepareContinuationWorktree(runId, state, record, rematerialized) {
+        this.autosave.armAutosave(runId, state);
+        if (record)
+            seedHandoffFile(this.context.dataDir, record); // idempotent — normally already there
+        // Worktree setup (#917) for a directory retention rebuilt, or one a restart interrupted.
+        return this.host.prepareWorktree(runId, state, atContinue.worktreeSetup(await atContinue.config(this.context.repoRoot, this.context.home)), (event) => this.context.store.appendEvent(runId, event), rematerialized ? 'rematerialized' : 'resume');
+    }
+    /** Mark the run and the Continue's step as running, then open the step. A Cursor session resumes
+     *  on the transport it was opened with; the runner refuses an ACP one (hearsay-tools/cezarion#1267). */
+    startContinuationStep(runId, stepId, record, sessionId, backend) {
+        this.host.move(runId, 'start', {
+            error: undefined,
+            finishedAt: undefined,
+            currentStepId: stepId,
+        });
+        // The Continue keeps the transport its session was opened on, for any runner that records one.
+        const sessionTransport = sessionId ? record?.steps.find((step) => step.sessionId === sessionId)?.sessionTransport : undefined;
+        this.context.store.updateStep(runId, stepId, {
+            status: 'running',
+            iterations: 1,
+            startedAt: new Date().toISOString(),
+            sessionId,
+            backend,
+            ...(sessionTransport ? { sessionTransport } : {}),
+        });
+        this.context.store.appendEvent(runId, { type: 'step-start', stepId, name: 'Continue', kind: 'agent', iteration: 1 });
+    }
+    /** The human ask a human Continue answers, and the human waits that answer settles. */
+    openingAnswer(runId, state, opening) {
+        const askSeq = opening.checkpoint?.origin === 'human' ? pendingHumanAskSeq(this.context.store, runId) : undefined;
+        state.inputState.answerOpeningAsk(askSeq);
+        // The human waits this answer answers; one the opening turn opens is its next question.
+        const waits = askSeq === undefined ? []
+            : openWaits(this.context.store.getRun(runId) ?? {}).filter(wait => WAIT_KINDS[wait.kind].userAnswers).map(wait => wait.id);
+        return { askSeq, waits, ...(opening.answerSource ? { answerSource: opening.answerSource } : {}) };
+    }
+    /**
+     * A completed turn acknowledges the opening payload. Until then a restart
+     * must replay it, including a crash after startSession but before delivery.
+     * Returns false when the opening input's checkpoint failed, and the turn end stops there.
+     */
+    acknowledgeOpeningTurn(runId, state, answer) {
+        if (state.liveSession.cancelled)
+            return true;
+        const session = state.liveSession.session?.open ? state.liveSession.session : undefined;
+        const opening = session ? state.inputState.openingAgentInputId : undefined;
+        const askSeq = session ? answer.askSeq : undefined;
+        // One commit (hearsay-tools/cezarion#1805): a store reopened after a crash never reads the
+        // opening input handled while the question it answers is still open.
+        const outcomes = [
+            ...(opening ? [{ kind: 'opening-handled', inputId: opening, at: new Date().toISOString() }] : []),
+            ...(askSeq !== undefined ? [{ kind: 'answered', waitIds: answer.waits }] : []),
+        ];
+        // Only the opening input's checkpoint stops the turn end; the rest is best effort, as before.
+        try {
+            this.context.store.commitOutcome(runId, outcomes, { patch: { continuationMessage: undefined } }, { bestEffort: !opening });
+        }
+        catch (error) {
+            this.host.latchAgentInputError(runId, state, session, `agent input delivery checkpoint failed: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+        if (opening) {
+            state.inputState.selectOpeningInput(undefined);
+            this.host.reconcileWorkerWaits();
+        }
+        if (askSeq !== undefined) {
+            this.context.store.appendEvent(runId, { type: 'human-input-delivered', askSeq, ...(answer.answerSource ? { source: answer.answerSource } : {}) });
+            answer.askSeq = undefined;
+            state.inputState.clearOpeningAnswer();
+        }
+        return true;
+    }
+    /**
+     * What a Continue runs with. Backend + model come off the record: the run's current backend by
+     * default, or the follow-up override that `continueRun` persisted before scheduling (#401).
+     * Returns undefined after a pre-spawn gate failed the turn.
+     */
+    async continuationLaunchSettings(runId, stepId, state, record, sessionId, backend, sink) {
+        // Resuming reattaches to a session that lives inside ONE account's config dir, so the
+        // continuation must run under the account that created it — not whatever the project has
+        // been switched to since. The owning step is the one carrying this session id.
+        const owningStep = atContinue.owningStep(record, sessionId);
+        // Which step this Continue continues does not depend on whether it resumes that step's
+        // session: a fresh session after a backend switch or an unreported native id continues the
+        // same step (hearsay-tools/cezarion#2991). An owned worker's turn runs under the identity
+        // pinned for that step (#452).
+        const toolsStep = atContinue.definitionStep(this.context.store, record, atContinue.continuedSessionId(record, stepId, sessionId));
+        const stepIdentity = this.host.workerStep(runId, atContinue.definitionId(toolsStep));
+        // The continued step also names the session's tools: resolve `allowedTools`/`bashAllowlist`
+        // from the persisted `workflowDef` exactly as the first spawn did (`runAgentStep`).
+        // Rebuilding with the bare DEFAULT_ALLOWED_TOOLS silently revoked every per-step grant
+        // (MCP servers, subagents) on Continue, restart recovery and the usage-limit auto-resume
+        // — and dropping `bashAllowlist` WIDENED Bash from an allowlist to unrestricted
+        // (`AgentRunSpec.toolGrant`, #430). Record steps share ids with `workflowDef.steps`;
+        // a synthetic `continue-N` that owns its session extends the run's tail, so it resolves
+        // from the definition's last agent step. A legacy record without `workflowDef` (#367), or
+        // a session no step owns, keeps today's defaults.
+        const toolGrant = atContinue.toolGrant(stepIdentity, toolsStep, backend);
+        const model = await continuationModel(this.context.store, this.context.repoRoot, runId, state, record, toolsStep, stepIdentity, backend, this.context.home);
+        if (typeof model === 'string') {
+            this.failContinuationBeforeSpawn(runId, stepId, sink, model);
+            return undefined;
+        }
+        const effort = continuationEffort(this.context.repoRoot, record, toolsStep, stepIdentity, this.context.home);
+        if (typeof effort === 'string') {
+            this.failContinuationBeforeSpawn(runId, stepId, sink, effort);
+            return undefined;
+        }
+        // The temp-directory preflight (#785) rides along with the account resolution: a resumed
+        // turn hits the same broken `/tmp` a fresh one would, and an agent whose shell silently
+        // returns nothing is worse than a turn that refuses to start and says why. So does an account
+        // that would open another folder than the one its session lives in (#1283).
+        const profile = await sessionEvents.stepProfileFor(this.context, this.sharedHost, runId, backend, {
+            recordedProfileId: atContinue.recordedProfile(owningStep),
+            phase: 'continue',
+            stepId: atContinue.definitionId(toolsStep),
+        });
+        if (typeof profile === 'string') {
+            this.failContinuationBeforeSpawn(runId, stepId, sink, profile);
+            return undefined;
+        }
+        return {
+            owningStep, toolsStep, toolGrant, backendModel: model.backendModel, effort: effort.effort, profile,
+            extraSystemPrompt: atContinue.extraSystemPrompt(record),
+        };
+    }
+    /** Settle this turn as a failure before anything is spawned — the shape every
+     *  pre-spawn gate needs (model identity, #405; temp directory, #785). */
+    failContinuationBeforeSpawn(runId, stepId, sink, message) {
+        const failedAt = new Date().toISOString();
+        sink.sessionEnded('error', message);
+        this.context.store.updateStep(runId, stepId, {
+            status: 'failed',
+            error: message,
+            finishedAt: failedAt,
+        });
+        this.host.move(runId, 'fail-start', { error: `continue failed: ${message}`, finishedAt: failedAt });
+        this.context.store.appendEvent(runId, {
+            type: 'lifecycle',
+            message: `continue failed — ${message}`,
+        });
+        this.host.dropActive(runId);
+    }
+    /** Record the Continue's account on its step and the settings its workers inherit. */
+    applyContinuationSettings(runId, stepId, state, backend, settings) {
+        this.context.store.updateStep(runId, stepId, { profileId: settings.profile.profileId });
+        state.liveSession.captureDelegationSettings({ cwd: state.liveSession.cwd, runner: backend, model: settings.backendModel,
+            effort: settings.effort, agentProfile: settings.profile.profileId, accountBinding: settings.profile.accountBinding,
+            systemPrompt: settings.extraSystemPrompt, ...toolGrantLists(settings.toolGrant) });
+    }
+    /** The continued step's skill files and playbook, when the step names a skill or the prompt
+     *  starts with a `/name`. Returns undefined otherwise, so that path does not yield. */
+    continuationSkills(runId, state, prompt, toolsStep, skipSkillOnResume) {
+        const continuedSkillName = atContinue.skill(toolsStep);
+        // The continued step's skill and a leading `/name` in this prompt both get their companions;
+        // upstream rebuilt only the slash name, so an ordinary Continue lost the step skill's (#1408).
+        const continuationSlash = leadingSlashSkillName(prompt);
+        if (!continuedSkillName && !continuationSlash)
+            return undefined;
+        return this.provisionContinuationSkills(runId, state, continuedSkillName, continuationSlash, skipSkillOnResume);
+    }
+    /** Reinstall the continued step's skill and a leading `/name`'s, and build the playbook. */
+    async provisionContinuationSkills(runId, state, continuedSkillName, continuationSlash, skipSkillOnResume) {
+        let skillPrompt;
+        let fallbackSkillPrompt;
+        let files = new Map();
+        if (continuedSkillName) {
+            let skill = this.runSkills.enabledSkills(state, undefined, 'continue').find((candidate) => candidate.name === continuedSkillName);
+            if (!skill)
+                skill = await this.awaitContinuedSkill(state, continuedSkillName);
+            if (skill) {
+                // Reinstall the skill and its companions — into a #483 rematerialized
+                // worktree, or a team skill's cache copy when the worktree is gone — before
+                // the playbook, which names a cache copy's directory (#1024, #1408). No note on Continue.
+                files = (await this.runSkills.provisionRunSkills(runId, state, { stepSkill: skill.name, slash: continuationSlash }, 'continue')).filesDir;
+                const playbook = skillSystemPrompt(skill, files.get(skill.name));
+                if (skipSkillOnResume)
+                    fallbackSkillPrompt = playbook;
+                else
+                    skillPrompt = playbook;
+            }
+            else if (!skipSkillOnResume) {
+                this.context.store.appendEvent(runId, {
+                    type: 'lifecycle',
+                    message: `skill /${continuedSkillName} is not in the skill registry — its instructions were not re-sent to the continued session`,
+                });
+            }
+        }
+        if (!continuedSkillName || !this.runSkills.enabledSkills(state, undefined, 'continue').some((candidate) => candidate.name === continuedSkillName)) {
+            if (continuationSlash)
+                files = (await this.runSkills.provisionRunSkills(runId, state, { slash: continuationSlash }, 'continue')).filesDir;
+        }
+        return { skillPrompt, fallbackSkillPrompt, files };
+    }
+    /** The continued step's skill when the registry did not list it yet. */
+    async awaitContinuedSkill(state, continuedSkillName) {
+        // Boot recovery can outrun the async team-skills cache (`getTeamSkillsCached`
+        // returns [] until `initialTeamSkillsLoad` resolves). Wait briefly, then
+        // re-discover; never hang Continue on the network. The on-disk clone's
+        // list arrives before the passive fetch (#859), so stop as soon as it
+        // names this skill instead of waiting out a slow first fetch of the day.
+        try {
+            await new Promise((resolve) => {
+                const timeout = setTimeout(resolve, 1_500);
+                timeout.unref?.();
+                const settle = () => { clearTimeout(timeout); resolve(); };
+                waitForTeamSkills(this.context.repoRoot, this.context.home).then(settle, settle);
+                waitForCachedTeamSkills(this.context.repoRoot, this.context.home).then((cached) => {
+                    if (cached.some((candidate) => candidate.name === continuedSkillName))
+                        settle();
+                }, () => undefined);
+            });
+            await this.runSkills.loadRunSkills(state, 'ignore');
+            return this.runSkills.enabledSkills(state, undefined, 'continue').find((candidate) => candidate.name === continuedSkillName);
+        }
+        catch {
+            // Best-effort — a slow or failing team-skills load must not fail Continue.
+            return undefined;
+        }
+    }
+    /** A Stop before the Continue's session spawned: cancel the step and the run. */
+    settleContinuationPrelaunchCancel(runId, stepId, state) {
+        // Its own step may not have started: the exit settles only running and waiting steps (B10).
+        this.context.store.updateStep(runId, stepId, { status: 'cancelled', finishedAt: new Date().toISOString() });
+        this.host.move(runId, 'cancel');
+        clearAutosaveTimer(state);
+        this.host.dropActive(runId);
+    }
+    /** A Continue's launch went stale while it provisioned (`launchStale`). A replaced active run
+     *  needs nothing more; a Stop cancels the run; a root Finish holds the Continue in the queue. */
+    settleStaleContinuationLaunch(runId, stepId, state, held) {
+        const disposition = staleContinuationDisposition(this.sharedHost.active.get(runId), state, () => this.sharedHost.workerExecutionStopped(runId));
+        if (disposition === 'replaced')
+            return;
+        if (disposition === 'cancel') {
+            state.liveSession.cancel();
+            this.settleContinuationPrelaunchCancel(runId, stepId, state);
+        }
+        else {
+            this.host.holdContinuationForRootFinish(runId, atContinue.rejoinLine(held), state);
+        }
+    }
+    /** Launch the active Continue after its facade has pinned it and left the starting set. */
+    async launchContinuation(runId, stepId, sessionId, backend, prompt, images, persistedImages, persistedAttachments, state, record, rematerialized) {
+        const lease = this.continuationRepoRootLease(runId, state);
+        if (lease && !(await lease))
+            return;
+        const setupNote = await this.prepareContinuationWorktree(runId, state, record, rematerialized);
+        // A Stop during setup settles below, at the prelaunch cancellation check before any spawn.
+        // Registry snapshot for `/skill` expansion. A continuation builds its OWN ActiveRun, and without
+        // this the resumed session expanded against an empty registry and leaked `/om-...` verbatim to
+        // the backend, which answered "Unknown skill" (open-mercato/cezar#811). Best-effort — discovery must never
+        // break Continue.
+        await this.runSkills.loadRunSkills(state, 'ignore');
+        this.startContinuationStep(runId, stepId, record, sessionId, backend);
+        const opening = continuationOpening(this.context.store, {
+            answerSource: (id, input) => this.workerQuestions.answerSource(id, input),
+            readPersistedAttachments: (...args) => this.queuedInput.readPersistedAttachments(...args),
+        }, runId, stepId, state, record, { prompt, images, persistedImages, persistedAttachments });
+        prompt = opening.prompt;
+        const answer = this.openingAnswer(runId, state, opening);
+        transitionTurnBoundary(state, { kind: 'session-open', phase: 'restore-question', session: state.liveSession.session, pending: answer.askSeq === undefined && hasPendingHumanAsk(runId, id => pendingHumanAskSeq(this.context.store, id)) });
+        const turn = { text: '', tail: 'none', scheduleWakeup: undefined, sessionError: undefined };
+        const sink = this.host.makeUiSink(runId, stepId);
+        const onEvent = createSessionEventHandler(this.context, this.sessionEventHost, {
+            runId, state, turn, stepId, backend, sink, tokenBase: 0,
+            emit: event => this.context.store.appendEvent(runId, event),
+            acknowledge: () => this.acknowledgeOpeningTurn(runId, state, answer),
+        });
+        const settings = await this.continuationLaunchSettings(runId, stepId, state, record, sessionId, backend, sink);
+        if (!settings)
+            return;
+        if (state.liveSession.cancelled) {
+            this.settleContinuationPrelaunchCancel(runId, stepId, state);
+            return;
+        }
+        if (this.host.holdContinuationForRootFinish(runId, { stepId, sessionId, backend, prompt, images, lineJoinedAt: Date.now() }, state))
+            return;
+        this.applyContinuationSettings(runId, stepId, state, backend, settings);
+        const { runner, skipSkillOnResume } = continuationRunner(backend, sessionId, settings.owningStep, this.context.createRunner);
+        // Re-expand the continued step's skill from the current registry (#790) BEFORE
+        // provisionSession. Materializing the skill used to sit after the pre-launch
+        // revalidation, so Stop during that await still launched with revoked tools.
+        // `record.systemPrompt` is only the extra prompt; the opening session put
+        // `skillSystemPrompt(skill)` in front. Skip that prefix only when this
+        // session resumes into its own thread on an in-thread runner — those
+        // already carry the playbook in history. A missing skill degrades to
+        // today's extra-only prompt with one lifecycle warning; in-thread skips
+        // do not warn. Workers still inherit only the extra prompt (#778).
+        const pendingSkills = this.continuationSkills(runId, state, prompt, settings.toolsStep, skipSkillOnResume);
+        const skills = pendingSkills
+            ? await pendingSkills
+            : { skillPrompt: undefined, fallbackSkillPrompt: undefined, files: new Map() };
+        state.liveSession.selectStep(stepId);
+        this.host.beginUsageInvocation(runId, state, stepId);
+        // A continuation's opening message becomes the session's `userPrompt` and never passes
+        // through `deliverMessage`, so it needs the SAME delivery-only `/skill` rewrite the
+        // live path applies (#811). Delivery-only: the `user-message` event above already
+        // persisted the user's original text, and the transcript must keep showing that.
+        state.liveSession.recordSessionError(undefined);
+        if (this.sharedHost.workerExecutionStopped(runId)) {
+            state.liveSession.cancel();
+            throw new Error('Worker stopped before launch');
+        }
+        const launch = await launchPreamble(this.launchPreambleHost, runId, state);
+        const { delegation, webhooksPart, ciTools } = launch;
+        // Stop/Finish can arrive while the local tool controller is starting.
+        if (launch.stale) {
+            this.settleStaleContinuationLaunch(runId, stepId, state, { stepId, sessionId, backend, prompt, images });
+            return;
+        }
+        // hearsay-tools/cezarion#2397: the tools could not start, so nothing spawns. The failure takes
+        // the session-failure path: a run that holds wakes parks and retries them with the wake-delivery
+        // backoff; any other run fails with the message.
+        if (launch.toolsError !== undefined) {
+            this.runSettlement.settleFailedContinuation(runId, state, stepId, sink, turn, new Error(launch.toolsError));
+            await this.releaseContinuationSession(runId, state, undefined, undefined, {});
+            return;
+        }
+        state.inputState.declareDelivery(inputDeliveryOf(runner));
+        state.inputState.resetUnreadInputs();
+        state.inputState.resetEarlyConsumption();
+        const session = this.startContinuationSession(runId, state, runner, {
+            stepId, sessionId, prompt, setupNote, opening, skills, skipSkillOnResume, settings, delegation, webhooksPart, ciTools,
+        }, onEvent, turn, sink);
+        return this.awaitContinuationSession(runId, state, session, { stepId, sink, turn, delegation, ciTools });
+    }
+    /** Start a Continue's session, resuming its own session when it has one. A throw revokes the
+     *  tools this launch was given and propagates to `continueRun`. */
+    startContinuationSession(runId, state, runner, launch, onEvent, turn, sink) {
+        const { delegation, ciTools, opening, skills, settings } = launch;
+        let session;
+        try {
+            // Provisioning determines the actual capability, including a fresh session after recovery.
+            const resumed = sessionEvents.launchOpening(this.context, this.sharedHost, runId, state, launch.stepId, {
+                body: expandRegistrySlashSkillText(launch.prompt, this.runSkills.enabledSkills(state, undefined, 'continue'), skills.files) +
+                    (launch.setupNote ? `\n\n${launch.setupNote}` : ''),
+                ciTools,
+                checkpoint: opening.checkpoint,
+            });
+            const continuationTail = sessionEvents.launchSystemTail(this.context, this.sharedHost, {
+                extraSystemPrompt: settings.extraSystemPrompt, delegation, webhooksPart: launch.webhooksPart,
+                env: settings.profile.env, ciTools, handoffInjected: resumed.handoffInjected, runner: state.liveSession.delegationSettings?.runner,
+            });
+            session = startManagedSession(runner, {
+                // Skill body (when resent), then the run's extra system prompt, then
+                // the handoff contract — the same order as the opening session (#790).
+                // In-thread resume omits the skill from systemPrompt; OpenCode's 404
+                // fallback uses resumeFallbackSystemPrompt so the fresh session still
+                // gets the playbook.
+                systemPrompt: composeSystemPrompt(skills.skillPrompt, continuationTail),
+                ...(launch.skipSkillOnResume ? {
+                    resumeFallbackSystemPrompt: composeSystemPrompt(skills.fallbackSkillPrompt, continuationTail),
+                } : {}),
+                userPrompt: opening.attachments.length
+                    ? `${resumed.userPrompt}\n\n${pastedAttachmentsText(opening.attachments)}`
+                    : resumed.userPrompt,
+                ...(opening.openingImages.length ? { images: opening.openingImages } : {}),
+                cwd: state.liveSession.cwd,
+                toolGrant: settings.toolGrant,
+                additionalDirectories: agentDirectories(join(this.context.dataDir, 'runs'), settings.profile.env),
+                env: { ...settings.profile.env, ...delegation?.env, ...ciTools?.env },
+                ...(ciTools ? { cezarTools: ciTools.descriptor } : {}),
+                ...(delegation ? { restrictCrossSessionMessaging: delegation.restrictCrossSessionMessaging } : {}),
+                model: settings.backendModel,
+                effort: settings.effort,
+                sessionId: launch.sessionId,
+                resume: launch.sessionId !== undefined,
+                timeoutMs: 0,
+            }, onEvent, inputReceipts.inputReceiptCallbacks(this.context, this.inputReceiptHost, this.inputReceiptSteps, runId, state, () => session, turn, sink, true));
+        }
+        catch (error) {
+            ciTools?.revoke();
+            state.liveSession.clearCiRevoker();
+            delegation?.revoke();
+            state.liveSession.clearDelegationRevoker();
+            throw error;
+        }
+        return session;
+    }
+    /** Wait for a Continue's session to close, then settle the run by how it closed. Teardown always
+     *  revokes the launch's tools, saves the worktree and leaves the active set
+     *  (`releaseContinuationSession`). */
+    async awaitContinuationSession(runId, state, session, launch) {
+        const { stepId, sink, turn } = launch;
+        const sessionClosed = this.host.trackWorkerSessionResult(runId, session);
+        state.liveSession.attachSession(session);
+        const resumedNext = continuationNextStep(this.context.store, runId, record => waitingWorkflowStepIndex(record, (run, step) => this.host.isSyntheticContinuation(run, step), ciWorkflowResumeStepIndex));
+        transitionTurnBoundary(state, { kind: 'session-open', phase: 'scope-step', session, next: stepScope(session, resumedNext) });
+        state.liveSession.markSessionOpened();
+        state.liveSession.installInterrupt(() => session.interrupt());
+        let setupComplete = false;
+        const close = {};
+        try {
+            const result = await inputReceipts.sessionResultWithReceipts(this.context, this.inputReceiptHost, this.inputReceiptSteps, runId, state, session, () => { setupComplete = true; });
+            if (preserveRunAfterDisposal(this.context.store, this.context.disposed, runId, state))
+                return;
+            this.humanWaits.withdrawCezarHumanWaits(runId);
+            sessionEvents.persistWorkerAssistantResult(this.context, this.sharedHost, runId, stepId, result.text);
+            // A durable CI wait keeps recovery live, not this failed attempt successful.
+            if (turn.sessionError || state.inputState.agentInputError)
+                throw new Error(turn.sessionError ?? state.inputState.agentInputError);
+            const settled = this.runSettlement.settleClosedContinuation(runId, state, stepId, sink, resumedNext, close);
+            if (settled)
+                await settled;
+        }
+        catch (err) {
+            if (!setupComplete) {
+                try {
+                    session.interrupt();
+                }
+                catch { /* Still wait for actual termination. */ }
+                await sessionClosed;
+            }
+            if (preserveRunAfterDisposal(this.context.store, this.context.disposed, runId, state))
+                return;
+            this.runSettlement.settleFailedContinuation(runId, state, stepId, sink, turn, err);
+        }
+        finally {
+            await this.releaseContinuationSession(runId, state, launch.delegation, launch.ciTools, close);
+        }
+    }
+    /** A Continue's session teardown: revoke the launch's tools, record the usage peaks, clear the
+     *  timers, save the worktree, leave the active set, then queue the workflow remainder. */
+    async releaseContinuationSession(runId, state, delegation, ciTools, close) {
+        ciTools?.revoke();
+        state.liveSession.clearCiRevoker();
+        delegation?.revoke();
+        state.liveSession.clearDelegationRevoker();
+        this.host.recordUsagePeaks(runId);
+        clearIdleTimer(state);
+        clearAutosaveTimer(state);
+        await this.host.saveWorktree(runId, state, 'turn end');
+        // Cancellation may be accepted while final autosave is yielding, even
+        // after success was recorded. Retire any durable queue intent before
+        // dropping the active state, otherwise pump can launch the tail with a
+        // fresh `cancelled:false` state.
+        if (state.liveSession.cancelled) {
+            close.resumeWorkflow = undefined;
+            if (this.context.store.getRun(runId)?.status !== 'cancelled') {
+                this.host.move(runId, 'cancel-late');
+            }
+        }
+        this.host.dropActive(runId);
+        if (close.resumeWorkflow) {
+            this.line.enqueueJob(runId, close.resumeWorkflow);
+            void this.host.pump();
+        }
+    }
+}
+export function staleContinuationDisposition(current, state, workerStopped) {
+    if (current !== state)
+        return 'replaced';
+    return state.liveSession.cancelled || workerStopped() ? 'cancel' : 'hold';
+}
+//# sourceMappingURL=continuation-session.js.map