pilotswarm-sdk 0.5.76 → 0.5.78

package/dist/orchestration_1_0_78/lifecycle.js

@@ -0,0 +1,981 @@
+import { describeCronAt } from "../cron-at.js";
+import { normalizeMessageSender } from "../message-sender.js";
+import { COMMAND_VERSION_KEY, RESPONSE_LATEST_KEY, RESPONSE_VERSION_KEY, commandResponseKey, } from "../types.js";
+import { createSessionProxy } from "../session-proxy.js";
+import { beginGracefulShutdown, cancelInFlightDistiller, } from "./agents.js";
+import { FIRST_SUMMARIZE_DELAY, INTERNAL_SYSTEM_TURN_PROMPT, REPEAT_SUMMARIZE_DELAY, } from "./state.js";
+import { appendSystemContext, extractPromptSystemContext, mergePrompt, } from "./utils.js";
+// ─── Custom status / KV helpers ─────────────────────────────
+export function publishStatus(runtime, status, extra = {}) {
+    const { state } = runtime;
+    const signal = {
+        status,
+        iteration: state.iteration,
+        ...(state.lastResponseVersion > 0 ? { responseVersion: state.lastResponseVersion } : {}),
+        ...(state.lastCommandVersion > 0 ? { commandVersion: state.lastCommandVersion } : {}),
+        ...(state.lastCommandId ? { commandId: state.lastCommandId } : {}),
+        ...(state.cronAtSchedule
+            ? {
+                cronActive: true,
+                cronKind: "wall-clock",
+                cronReason: state.cronAtSchedule.reason,
+                cronNextFireAt: state.cronAtSchedule.nextFireAtMs,
+                cronTimezone: state.cronAtSchedule.tz,
+                cronMaxFires: state.cronAtSchedule.maxFires,
+                cronFiresCompleted: state.cronAtSchedule.firesCompleted,
+            }
+            : state.cronSchedule
+                ? {
+                    cronActive: true,
+                    cronKind: "interval",
+                    cronInterval: state.cronSchedule.intervalSeconds,
+                    cronReason: state.cronSchedule.reason,
+                }
+                : { cronActive: false }),
+        ...(state.contextUsage ? { contextUsage: state.contextUsage } : {}),
+        ...extra,
+        // A late answer may finish another turn while this question remains open.
+        // Keep the question independently of latestResponse and its newer iteration.
+        ...(status === "input_required" && state.pendingInputQuestion ? {
+            pendingQuestion: state.pendingInputQuestion.question,
+            questionIteration: state.pendingInputQuestion.iteration ?? state.iteration,
+            choices: state.pendingInputQuestion.choices,
+            allowFreeform: state.pendingInputQuestion.allowFreeform,
+        } : {}),
+    };
+    runtime.ctx.setCustomStatus(JSON.stringify(signal));
+}
+function writeJsonValue(ctx, key, value) {
+    ctx.setValue(key, JSON.stringify(value));
+}
+export function readCounter(ctx, key) {
+    const raw = ctx.getValue(key);
+    if (raw == null)
+        return 0;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function bumpCounter(ctx, key) {
+    const next = readCounter(ctx, key) + 1;
+    ctx.setValue(key, String(next));
+    return next;
+}
+export function* writeLatestResponse(runtime, payload) {
+    const version = bumpCounter(runtime.ctx, RESPONSE_VERSION_KEY);
+    const emittedAt = yield runtime.ctx.utcNow();
+    const responsePayload = {
+        schemaVersion: 1,
+        version,
+        emittedAt,
+        ...payload,
+    };
+    writeJsonValue(runtime.ctx, RESPONSE_LATEST_KEY, responsePayload);
+    runtime.state.lastResponseVersion = version;
+    return responsePayload;
+}
+export function* writeCommandResponse(runtime, response) {
+    const version = bumpCounter(runtime.ctx, COMMAND_VERSION_KEY);
+    const emittedAt = yield runtime.ctx.utcNow();
+    const payload = {
+        ...response,
+        schemaVersion: 1,
+        version,
+        emittedAt,
+    };
+    writeJsonValue(runtime.ctx, commandResponseKey(response.id), payload);
+    runtime.state.lastCommandVersion = version;
+    runtime.state.lastCommandId = response.id;
+    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+            eventType: "session.command_completed",
+            data: { cmd: response.cmd, id: response.id },
+        }]);
+    return payload;
+}
+// ─── Hydration / dehydration / checkpointing ────────────────
+export function wrapWithResumeContext(runtime, userPrompt, extra) {
+    const base = runtime.state.pendingRehydrationMessage ??
+        `The session was dehydrated and has been rehydrated on a new worker. ` +
+            `The LLM conversation history is preserved.`;
+    runtime.state.pendingRehydrationMessage = undefined;
+    const parts = [userPrompt, ``, `[SYSTEM: ${base}`];
+    if (extra)
+        parts.push(extra);
+    parts.push(`]`);
+    return parts.join("\n");
+}
+/**
+ * Session lifecycle protocol (§3.4 tier 3): release the worker affinity by
+ * rotating the GUID — a pure orchestration-state change, no activity at all.
+ * Nothing needs uploading (every completed turn committed its snapshot
+ * inside the runTurn activity) and nothing needs telling the old worker:
+ * its local copy is a cache reclaimed by its own eviction clock. The next
+ * event hydrates wherever duroxide places the new key.
+ */
+export function* releaseAffinity(runtime, reason, eventData) {
+    const { ctx, state } = runtime;
+    ctx.traceInfo(`[orch] releasing worker affinity (reason=${reason})`);
+    state.activeTimer = null;
+    state.affinityKey = yield ctx.newGuid();
+    runtime.session = createSessionProxy(ctx, runtime.input.sessionId, state.affinityKey, state.config, "agent-handoff-v2");
+    try {
+        yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                eventType: "session.affinity_released",
+                data: { reason, snapshotVersion: state.snapshotVersion, ...(eventData ?? {}) },
+            }]);
+    }
+    catch (err) {
+        ctx.traceInfo(`[orch] affinity_released event failed (non-fatal): ${err.message ?? err}`);
+    }
+}
+export function* maybeSummarize(runtime) {
+    if (runtime.options.isSystem)
+        return;
+    const now = yield runtime.ctx.utcNow();
+    if (runtime.state.nextSummarizeAt === 0) {
+        runtime.state.nextSummarizeAt = now + FIRST_SUMMARIZE_DELAY;
+        return;
+    }
+    if (now < runtime.state.nextSummarizeAt)
+        return;
+    try {
+        runtime.ctx.traceInfo(`[orch] summarizing session title`);
+        yield runtime.manager.summarizeSession(runtime.input.sessionId);
+    }
+    catch (err) {
+        runtime.ctx.traceInfo(`[orch] summarize failed: ${err.message}`);
+    }
+    runtime.state.nextSummarizeAt = now + REPEAT_SUMMARIZE_DELAY;
+}
+// ─── Task context / cron action helpers ─────────────────────
+export function ensureTaskContext(runtime, sourcePrompt) {
+    if (runtime.state.taskContext || !sourcePrompt)
+        return;
+    runtime.state.taskContext = sourcePrompt.slice(0, 2000);
+    const base = typeof runtime.options.baseSystemMessage === "string"
+        ? runtime.options.baseSystemMessage ?? ""
+        : runtime.options.baseSystemMessage?.content ?? "";
+    runtime.state.config.systemMessage = base + (base ? "\n\n" : "") +
+        "[RECURRING TASK]\n" +
+        "Original user request (always remember, even if conversation history is truncated):\n\"" +
+        runtime.state.taskContext + "\"";
+}
+export function applyCronAction(runtime, action, sourcePrompt) {
+    runtime.state.interruptedCronTimer = null;
+    if (action.action === "cancel") {
+        runtime.ctx.traceInfo("[orch] cron cancelled");
+        runtime.state.cronSchedule = undefined;
+        runtime.state.cronAtSchedule = undefined;
+        return;
+    }
+    ensureTaskContext(runtime, sourcePrompt);
+    runtime.state.cronAtSchedule = undefined;
+    runtime.state.cronSchedule = {
+        intervalSeconds: action.intervalSeconds,
+        reason: action.reason,
+    };
+    runtime.ctx.traceInfo(`[orch] cron scheduled: every ${action.intervalSeconds}s (${action.reason})`);
+}
+export function* applyCronAtAction(runtime, action, sourcePrompt) {
+    runtime.state.interruptedCronTimer = null;
+    if (action.action === "cancel") {
+        runtime.ctx.traceInfo("[orch] cron_at cancelled");
+        runtime.state.cronAtSchedule = undefined;
+        runtime.state.cronSchedule = undefined;
+        yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                eventType: "session.cron_at_cancelled",
+                data: {},
+            }]);
+        return;
+    }
+    ensureTaskContext(runtime, sourcePrompt);
+    const afterUtcMs = yield runtime.ctx.utcNow();
+    const nextFire = yield runtime.manager.computeCronAtNextFire(action.schedule, afterUtcMs, action.schedule.lastOccurrenceKey);
+    runtime.state.cronSchedule = undefined;
+    runtime.state.cronAtSchedule = {
+        ...action.schedule,
+        firesCompleted: action.schedule.firesCompleted ?? 0,
+        nextFireAtMs: nextFire.nextFireAtMs,
+        nextOccurrenceKey: nextFire.occurrenceKey,
+    };
+    runtime.ctx.traceInfo(`[orch] cron_at scheduled: ${describeCronAt(runtime.state.cronAtSchedule)} (${runtime.state.cronAtSchedule.reason})`);
+    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+            eventType: "session.cron_at_scheduled",
+            data: {
+                ...runtime.state.cronAtSchedule,
+                nextFireAt: new Date(nextFire.nextFireAtMs).toISOString(),
+                localTime: nextFire.localTime,
+                skippedOccurrences: nextFire.skippedOccurrences,
+            },
+        }]);
+}
+export function* drainLeadingQueuedScheduleActions(runtime, sourcePrompt) {
+    while (runtime.state.pendingToolActions[0]?.type === "cron" || runtime.state.pendingToolActions[0]?.type === "cron_at") {
+        const action = runtime.state.pendingToolActions.shift();
+        if (action.type === "cron") {
+            applyCronAction(runtime, action, sourcePrompt);
+        }
+        else {
+            yield* applyCronAtAction(runtime, action, sourcePrompt);
+        }
+    }
+}
+export const drainLeadingQueuedCronActions = drainLeadingQueuedScheduleActions;
+// ─── Cancellation tombstone helpers ─────────────────────────
+export function promptIdsIntersectCancellation(runtime, ids) {
+    return ids.length > 0 && ids.some((id) => runtime.state.cancelledMessageIds.has(id));
+}
+export function* recordCancelledMessageIds(runtime, ids, reason) {
+    const nextIds = ids.filter((id) => id && !runtime.state.emittedCancelledMessageIds.has(id));
+    if (nextIds.length === 0)
+        return;
+    for (const id of nextIds)
+        runtime.state.emittedCancelledMessageIds.add(id);
+    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+            eventType: "pending_messages.cancelled",
+            data: {
+                clientMessageIds: nextIds,
+                reason,
+            },
+        }]);
+}
+// ─── Pending child-digest accumulation ──────────────────────
+export function bufferChildUpdate(runtime, update, observedAtMs) {
+    if (!runtime.state.pendingChildDigest) {
+        runtime.state.pendingChildDigest = {
+            startedAtMs: observedAtMs,
+            updates: [],
+        };
+    }
+    const nextEntry = {
+        sessionId: update.sessionId,
+        updateType: update.updateType,
+        ...(update.content ? { content: update.content.slice(0, 2000) } : {}),
+        ...(update.cycleOrigin ? { cycleOrigin: update.cycleOrigin } : {}),
+        ...(update.cycleStatus ? { cycleStatus: update.cycleStatus } : {}),
+        ...(update.verdict ? { verdict: update.verdict } : {}),
+        observedAtMs,
+    };
+    const existingIndex = runtime.state.pendingChildDigest.updates.findIndex((entry) => entry.sessionId === update.sessionId);
+    if (existingIndex >= 0) {
+        // One entry per child, latest wins — EXCEPT that a lifecycle update
+        // (completed / failed / cancelled) is never overwritten by a later
+        // wait or progress note. With the batch window scaled up to five
+        // minutes (childUpdateBatchMs) a child can finish and then start
+        // waiting inside one window; the parent must still see the finish.
+        const existing = runtime.state.pendingChildDigest.updates[existingIndex];
+        if (childUpdateRank(nextEntry.updateType) >= childUpdateRank(existing.updateType)) {
+            runtime.state.pendingChildDigest.updates[existingIndex] = nextEntry;
+        }
+    }
+    else {
+        runtime.state.pendingChildDigest.updates.push(nextEntry);
+    }
+}
+function childUpdateRank(updateType) {
+    switch (updateType) {
+        case "failed":
+        case "cancelled":
+        case "deleted":
+        case "completed":
+            return 2;
+        default:
+            return 1;
+    }
+}
+/** True when the buffered digest carries a child failure or cancellation — the parent should hear those at once. */
+export function pendingChildDigestHasError(runtime) {
+    const digest = runtime.state.pendingChildDigest;
+    if (!digest)
+        return false;
+    return digest.updates.some((entry) => entry.updateType === "failed" || entry.updateType === "cancelled" || entry.updateType === "deleted");
+}
+export function clearPendingChildDigest(runtime) {
+    runtime.state.pendingChildDigest = null;
+}
+export function buildPendingChildDigestSystemPrompt(runtime) {
+    const digest = runtime.state.pendingChildDigest;
+    if (!digest || digest.updates.length === 0)
+        return undefined;
+    const lines = digest.updates.map((update) => {
+        const agent = runtime.state.subAgents.find((entry) => entry.sessionId === update.sessionId);
+        const label = agent?.orchId ?? update.sessionId;
+        const task = agent?.task ? `Task: "${agent.task.slice(0, 120)}"\n` : "";
+        const status = agent?.status ?? update.updateType;
+        const resultText = String(update.content || agent?.result || "").trim();
+        const result = resultText ? resultText.slice(0, 240) : "(no summary)";
+        return `  - Agent ${label}\n` +
+            `    ${task}` +
+            `    Update: ${update.updateType}\n` +
+            `    Status: ${status}\n` +
+            `    Result: ${result}`;
+    });
+    return `Buffered child updates arrived during the last 30 seconds:\n${lines.join("\n")}\nReview the updates and continue your task.`;
+}
+export function flushPendingChildDigestIntoPrompt(runtime, rawPrompt) {
+    const childDigestPrompt = buildPendingChildDigestSystemPrompt(runtime);
+    if (!childDigestPrompt)
+        return rawPrompt;
+    clearPendingChildDigest(runtime);
+    return appendSystemContext(rawPrompt, childDigestPrompt);
+}
+// ─── Followup queueing ──────────────────────────────────────
+export function queueFollowup(runtime, nextPrompt) {
+    let text = nextPrompt;
+    const trimmed = text.trim();
+    if (trimmed.startsWith("[SYSTEM:") && trimmed.endsWith("]")) {
+        text = trimmed.slice("[SYSTEM:".length, -1).trim();
+    }
+    runtime.state.pendingPrompt = mergePrompt(runtime.state.pendingPrompt, text);
+}
+// ─── Continue-as-new construction ───────────────────────────
+export function buildContinueInput(runtime, overrides = {}) {
+    const { state, options, input } = runtime;
+    const { prompt: overridePrompt, requiredTool: overrideRequiredTool, systemPrompt: overrideSystemPrompt, cycleOrigin: overrideCycleOrigin, bootstrapPrompt: overrideBootstrapPrompt, rehydrationMessage: overrideRehydrationMessage, ...restOverrides } = overrides;
+    const carriedPrompt = overridePrompt ?? state.pendingPrompt;
+    const carriedRequiredTool = overrideRequiredTool ?? state.pendingRequiredTool;
+    const carriedSystemPrompt = overrideSystemPrompt ?? state.pendingSystemPrompt;
+    const carriedCycleOrigin = overrideCycleOrigin ?? state.pendingCycleOrigin;
+    const carriedRehydrationMessage = overrideRehydrationMessage ?? state.pendingRehydrationMessage;
+    const promptForInput = carriedPrompt
+        ?? (carriedSystemPrompt ? INTERNAL_SYSTEM_TURN_PROMPT : undefined);
+    const bootstrapForInput = overrideBootstrapPrompt
+        ?? (carriedPrompt ? state.bootstrapPrompt : carriedSystemPrompt ? true : undefined);
+    return {
+        sessionId: input.sessionId,
+        config: state.config,
+        iteration: state.iteration,
+        affinityKey: state.affinityKey,
+        preserveAffinityOnHydrate: state.preserveAffinityOnHydrate,
+        needsHydration: state.needsHydration,
+        snapshotVersion: state.snapshotVersion,
+        blobEnabled: state.blobEnabled,
+        idleTimeout: options.idleTimeout,
+        inputGracePeriod: options.inputGracePeriod,
+        ...(carriedRehydrationMessage ? { rehydrationMessage: carriedRehydrationMessage } : {}),
+        nextSummarizeAt: state.nextSummarizeAt,
+        taskContext: state.taskContext,
+        baseSystemMessage: options.baseSystemMessage,
+        ...(state.blockedError ? { blockedError: { ...state.blockedError } } : {}),
+        ...(state.cronSchedule ? { cronSchedule: state.cronSchedule } : {}),
+        ...(state.cronAtSchedule ? { cronAtSchedule: state.cronAtSchedule } : {}),
+        ...(state.contextUsage ? { contextUsage: state.contextUsage } : {}),
+        ...(state.recentClientMessageIds?.length ? { recentClientMessageIds: [...state.recentClientMessageIds] } : {}),
+        ...(carriedSystemPrompt ? { systemPrompt: carriedSystemPrompt } : {}),
+        ...(state.runtimeModelNotice ? { runtimeModelNotice: state.runtimeModelNotice } : {}),
+        ...(promptForInput ? { prompt: promptForInput } : {}),
+        // Attachment refs ride the carried prompt — without this, any prompt
+        // consumed into pendingPrompt across continue-as-new silently became
+        // text-only (the string-only carry predates image attachments).
+        ...(promptForInput && state.pendingAttachments?.length
+            ? { attachments: [...state.pendingAttachments] }
+            : {}),
+        ...(carriedRequiredTool ? { requiredTool: carriedRequiredTool } : {}),
+        ...(carriedCycleOrigin ? { cycleOrigin: carriedCycleOrigin } : {}),
+        ...(promptForInput && bootstrapForInput !== undefined ? { bootstrapPrompt: bootstrapForInput } : {}),
+        subAgents: state.subAgents,
+        ...(state.reportedFirstCompletionToParent ? { reportedFirstCompletionToParent: true } : {}),
+        ...(state.pendingToolActions.length > 0 ? { pendingToolActions: state.pendingToolActions } : {}),
+        // Session regeneration (1.0.67): epoch + in-flight pipeline state ride
+        // EVERY continue-as-new (forced CANs included) or they silently drop.
+        transcriptEpoch: state.transcriptEpoch,
+        ...(state.epochStartPending ? { epochStartPending: true } : {}),
+        ...(state.regen ? { regen: state.regen } : {}),
+        ...(state.pendingEpochCommit ? { pendingEpochCommit: state.pendingEpochCommit } : {}),
+        ...(state.epochStartIteration ? { epochStartIteration: state.epochStartIteration } : {}),
+        ...(state.lastRegenAtMs ? { lastRegenAtMs: state.lastRegenAtMs } : {}),
+        parentSessionId: options.parentSessionId,
+        nestingLevel: options.nestingLevel,
+        ...(options.isSystem ? { isSystem: true } : {}),
+        ...(input.agentId ? { agentId: input.agentId } : {}),
+        retryCount: 0,
+        ...(state.pendingInputQuestion ? { pendingInputQuestion: state.pendingInputQuestion } : {}),
+        ...(state.waitingForAgentIds ? { waitingForAgentIds: state.waitingForAgentIds } : {}),
+        ...(state.interruptedWaitTimer ? { interruptedWaitTimer: state.interruptedWaitTimer } : {}),
+        // A queued-while-blocked prompt must survive the epoch boundary too,
+        // or continue-as-new becomes one more way to destroy it.
+        ...(state.budgetStash && state.budgetStash.length > 0 ? { budgetStash: state.budgetStash } : {}),
+        ...(state.interruptedCronTimer ? { interruptedCronTimer: state.interruptedCronTimer } : {}),
+        ...(state.pendingChildDigest ? { pendingChildDigest: state.pendingChildDigest } : {}),
+        ...(state.pendingShutdown ? { pendingShutdown: state.pendingShutdown } : {}),
+        // Multi-writer attribution posture (security model): carried so a
+        // shared session stays attributed across continue-as-new. Omitted
+        // entirely for single-writer sessions, keeping the CAN input
+        // byte-identical to pre-sender builds.
+        ...(state.observedSenderKeys?.length ? { observedSenderKeys: [...state.observedSenderKeys] } : {}),
+        ...(state.multiWriter ? { multiWriter: true } : {}),
+        ...(state.sharedPreambleSent ? { sharedPreambleSent: true } : {}),
+        ...(state.ownerDisplay ? { ownerDisplay: state.ownerDisplay } : {}),
+        ...restOverrides,
+    };
+}
+export function buildContinueInputWithPrompt(runtime, nextPrompt, overrides = {}) {
+    const extracted = extractPromptSystemContext(nextPrompt);
+    const mergedPrompt = mergePrompt(runtime.state.pendingPrompt, extracted.prompt);
+    const mergedSystemPrompt = mergePrompt(runtime.state.pendingSystemPrompt, extracted.systemPrompt);
+    return buildContinueInput(runtime, {
+        ...(mergedPrompt ? { prompt: mergedPrompt } : {}),
+        ...(mergedSystemPrompt ? { systemPrompt: mergedSystemPrompt } : {}),
+        ...overrides,
+    });
+}
+/** Capture the active timer state into a continueAsNew input and yield the version-bumped CAN. */
+export function* versionedContinueAsNew(runtime, canInput) {
+    const { state } = runtime;
+    if (state.activeTimer) {
+        const now = yield runtime.ctx.utcNow();
+        const remainingMs = Math.max(0, state.activeTimer.deadlineMs - now);
+        canInput.activeTimerState = {
+            remainingMs,
+            reason: state.activeTimer.reason,
+            type: state.activeTimer.type,
+            originalDurationMs: state.activeTimer.originalDurationMs,
+            ...(state.activeTimer.shouldRehydrate ? { shouldRehydrate: true } : {}),
+            ...(state.activeTimer.waitPlan ? { waitPlan: state.activeTimer.waitPlan } : {}),
+            ...(state.activeTimer.content ? { content: state.activeTimer.content } : {}),
+            ...(state.activeTimer.question ? { question: state.activeTimer.question } : {}),
+            ...(state.activeTimer.choices ? { choices: state.activeTimer.choices } : {}),
+            ...(state.activeTimer.allowFreeform !== undefined ? { allowFreeform: state.activeTimer.allowFreeform } : {}),
+            ...(state.activeTimer.agentIds ? { agentIds: state.activeTimer.agentIds } : {}),
+        };
+    }
+    // Lifecycle protocol: no checkpoint before a warm CAN — every turn
+    // already committed its snapshot inside the runTurn activity, so a CAN
+    // carries no undurable state.
+    canInput.sourceOrchestrationVersion = runtime.versions.currentVersion;
+    yield runtime.ctx.continueAsNewVersioned(canInput, runtime.versions.latestVersion);
+}
+export function continueInput(runtime, overrides = {}) {
+    return buildContinueInput(runtime, overrides);
+}
+export function continueInputWithPrompt(runtime, nextPrompt, overrides = {}) {
+    return buildContinueInputWithPrompt(runtime, nextPrompt, overrides);
+}
+// ─── Command handling ───────────────────────────────────────
+export function* handleCommand(runtime, cmdMsg) {
+    runtime.ctx.traceInfo(`[orch-cmd] ${cmdMsg.cmd} id=${cmdMsg.id}`);
+    yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+            eventType: "session.command_received",
+            data: { cmd: cmdMsg.cmd, id: cmdMsg.id },
+        }]);
+    switch (cmdMsg.cmd) {
+        case "set_model": {
+            const newModel = String(cmdMsg.args?.model || "").trim();
+            if (!newModel) {
+                const resp = {
+                    id: cmdMsg.id,
+                    cmd: cmdMsg.cmd,
+                    error: "set_model requires a non-empty model",
+                };
+                yield* writeCommandResponse(runtime, resp);
+                publishStatus(runtime, "idle");
+                return;
+            }
+            const oldModel = runtime.state.config.model || "(default)";
+            const hasEffort = cmdMsg.args?.reasoningEffort !== undefined;
+            const oldEffort = runtime.state.config.reasoningEffort ?? null;
+            const newEffort = hasEffort
+                ? (cmdMsg.args?.reasoningEffort ? String(cmdMsg.args.reasoningEffort) : null)
+                : oldEffort;
+            // Context-window tier is applied like reasoning effort: omitted from
+            // the args → preserve the session's current tier; present → apply it
+            // (the next turn rebinds the model, requiresModelRebind() sees the
+            // change). Durable via the checkpointed orchestration config.
+            const hasContextTier = cmdMsg.args?.contextTier !== undefined;
+            const oldContextTier = runtime.state.config.contextTier ?? null;
+            const newContextTier = hasContextTier
+                ? (cmdMsg.args?.contextTier ? String(cmdMsg.args.contextTier) : null)
+                : oldContextTier;
+            runtime.state.config = {
+                ...runtime.state.config,
+                model: newModel,
+                ...(hasEffort ? { reasoningEffort: newEffort } : {}),
+                ...(hasContextTier ? { contextTier: newContextTier } : {}),
+            };
+            const newModelLabel = newEffort ? `${newModel}:${newEffort}` : newModel;
+            runtime.state.runtimeModelNotice = `Runtime model for this turn is ${newModelLabel}. If asked what model you are using, answer this value.`;
+            yield* captureModelSwitchInterruptedTimer(runtime, newModelLabel);
+            yield runtime.manager.updateSessionModel(runtime.input.sessionId, newModel, newEffort, newContextTier, String(cmdMsg.args?.source ?? "user"));
+            yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                    eventType: "session.model_changed",
+                    data: { oldModel, newModel, oldReasoningEffort: oldEffort, newReasoningEffort: newEffort, oldContextTier, newContextTier, source: cmdMsg.args?.source ?? "user" },
+                }]);
+            const resp = {
+                id: cmdMsg.id,
+                cmd: cmdMsg.cmd,
+                result: { ok: true, oldModel, newModel, oldReasoningEffort: oldEffort, newReasoningEffort: newEffort, oldContextTier, newContextTier, appliesOn: "next_turn" },
+            };
+            yield* writeCommandResponse(runtime, resp);
+            publishStatus(runtime, "idle");
+            yield* versionedContinueAsNew(runtime, continueInputWithPrompt(runtime, `Continue on ${newModelLabel}.`, {
+                bootstrapPrompt: true,
+            }));
+            return;
+        }
+        case "regenerate": {
+            const state = runtime.state;
+            const nowMs = yield runtime.ctx.utcNow();
+            const source = String(cmdMsg.args?.source ?? "operator");
+            // Operator force: an explicit operator action (button/API/MCP, gated
+            // session:manage) may bypass the SOFT rate limits (min-age; cooldown
+            // is already operator-exempt below). It never bypasses the hard
+            // gates: a regen already in flight, or a system session.
+            const force = cmdMsg.args?.force === true && source === "operator";
+            const refuse = function* (reason) {
+                yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                        eventType: "session.regenerate_refused",
+                        data: { attemptId: cmdMsg.id, reason, source, requestedBy: cmdMsg.requestedBy ?? null },
+                    }]);
+                yield* writeCommandResponse(runtime, { id: cmdMsg.id, cmd: cmdMsg.cmd, error: reason });
+                publishStatus(runtime, "idle");
+            };
+            if (state.regen) {
+                yield* refuse("already_pending");
+                return;
+            }
+            if (runtime.options.isSystem) {
+                yield* refuse("is_system");
+                return;
+            }
+            // A session tearing down must not start a 5-minute distill pipeline
+            // the shutdown would then abandon (leaking the distiller and, on a
+            // held grounding prompt, spinning continue-as-news). Force cannot
+            // bypass this — it is a hard gate, not a rate limit.
+            if (state.pendingShutdown) {
+                yield* refuse("shutting_down");
+                return;
+            }
+            // The previous flip's rebirth is not yet proven (grounding turn
+            // pending). Starting another regen now would replace the unconsumed
+            // pendingEpochCommit and merge the two grounding bootstraps
+            // (adversarial-review finding). Also a hard gate — force cannot skip it.
+            if (state.epochStartPending) {
+                yield* refuse("epoch_unsettled");
+                return;
+            }
+            if (!force && state.iteration - state.epochStartIteration < 5) {
+                yield* refuse("too_young");
+                return;
+            }
+            // Cooldown applies to every agent-driven trigger — self (tool) AND
+            // parent — so a supervising parent (which a child can prompt-inject)
+            // cannot destroy a child's transcript every few turns. Operator and
+            // policy triggers bypass the cooldown but still respect min-age.
+            const REGEN_COOLDOWN_MS = 6 * 60 * 60 * 1000;
+            if ((source === "tool" || source === "parent")
+                && state.lastRegenAtMs > 0 && nowMs - state.lastRegenAtMs < REGEN_COOLDOWN_MS) {
+                yield* refuse("cooldown");
+                return;
+            }
+            if (source === "tool") {
+                // Owner-sender gate: a non-owner-attributed turn must not
+                // trigger a self-regen. Positive assertion — refuse whenever an
+                // explicitly non-owner sender is present (a collaborator human,
+                // OR a child/system-instigated turn whose injection tried to
+                // make the agent self-regen). A senderless self-driven turn
+                // (the common single-writer case) has no non-owner principal
+                // and is allowed. Not gated on the derived multiWriter flag,
+                // which never flips for agent/system senders.
+                const sender = normalizeMessageSender(cmdMsg.sender);
+                if (sender && sender.relation !== "owner") {
+                    yield* refuse("not_owner");
+                    return;
+                }
+            }
+            else if (source === "parent") {
+                if (!cmdMsg.requestedBy || cmdMsg.requestedBy !== runtime.options.parentSessionId) {
+                    yield* refuse("not_parent");
+                    return;
+                }
+            }
+            const handoffRaw = typeof cmdMsg.args?.handoff === "string" ? cmdMsg.args.handoff : undefined;
+            const instructionsRaw = typeof cmdMsg.args?.instructions === "string" ? cmdMsg.args.instructions : undefined;
+            state.regen = {
+                attemptId: cmdMsg.id,
+                stage: "requested",
+                requestedAtMs: nowMs,
+                trigger: source === "tool" ? "tool" : source === "parent" ? "parent" : source === "policy" ? "policy" : "operator",
+                ...(cmdMsg.requestedBy ? { requestedBy: cmdMsg.requestedBy } : {}),
+                ...(handoffRaw ? { handoff: handoffRaw.slice(0, 4_000) } : {}),
+                ...(instructionsRaw ? { instructions: instructionsRaw.slice(0, 4_000) } : {}),
+                // LLM (service-session) distillation is the default; callers may
+                // pick the fast deterministic package per regen.
+                distillMode: cmdMsg.args?.distill_mode === "deterministic" ? "deterministic" : "llm",
+                ...(typeof cmdMsg.args?.distillerReasoningEffort === "string" && cmdMsg.args.distillerReasoningEffort
+                    ? { distillerReasoningEffort: String(cmdMsg.args.distillerReasoningEffort) }
+                    : {}),
+                ...(typeof cmdMsg.args?.distillerContextTier === "string" && cmdMsg.args.distillerContextTier
+                    ? { distillerContextTier: String(cmdMsg.args.distillerContextTier) }
+                    : {}),
+                ...(typeof cmdMsg.args?.distillerModel === "string" && cmdMsg.args.distillerModel
+                    ? { distillerModel: String(cmdMsg.args.distillerModel) }
+                    : {}),
+                ...(typeof cmdMsg.args?.model === "string" && cmdMsg.args.model
+                    ? { model: String(cmdMsg.args.model) }
+                    : {}),
+            };
+            yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                    eventType: "session.regenerate_requested",
+                    data: { attemptId: cmdMsg.id, trigger: state.regen.trigger, requestedBy: cmdMsg.requestedBy ?? null, hasHandoff: Boolean(handoffRaw) },
+                }]);
+            yield* writeCommandResponse(runtime, {
+                id: cmdMsg.id,
+                cmd: cmdMsg.cmd,
+                result: { ok: true, accepted: true, attemptId: cmdMsg.id, fromEpoch: state.transcriptEpoch, appliesOn: "pipeline" },
+            });
+            publishStatus(runtime, "running", { regenStage: "requested" });
+            return;
+        }
+        case "cancel_regen": {
+            const state = runtime.state;
+            if (!state.regen) {
+                yield* writeCommandResponse(runtime, { id: cmdMsg.id, cmd: cmdMsg.cmd, error: "no_regen_pending" });
+                publishStatus(runtime, "idle");
+                return;
+            }
+            const cancelled = state.regen.attemptId;
+            yield* cancelInFlightDistiller(runtime);
+            state.regen = null;
+            yield runtime.manager.recordSessionEvent(runtime.input.sessionId, [{
+                    eventType: "session.regenerate_failed",
+                    data: { attemptId: cancelled, stage: "cancelled", error: "cancelled by request" },
+                }]);
+            yield* writeCommandResponse(runtime, { id: cmdMsg.id, cmd: cmdMsg.cmd, result: { ok: true, cancelledAttemptId: cancelled } });
+            publishStatus(runtime, "idle");
+            return;
+        }
+        case "list_models": {
+            publishStatus(runtime, "idle", { cmdProcessing: cmdMsg.id });
+            let models;
+            try {
+                const raw = yield runtime.manager.listModels();
+                models = typeof raw === "string" ? JSON.parse(raw) : raw;
+            }
+            catch (err) {
+                const resp = {
+                    id: cmdMsg.id,
+                    cmd: cmdMsg.cmd,
+                    error: err.message || String(err),
+                };
+                yield* writeCommandResponse(runtime, resp);
+                publishStatus(runtime, "idle");
+                return;
+            }
+            const resp = {
+                id: cmdMsg.id,
+                cmd: cmdMsg.cmd,
+                result: { models, currentModel: runtime.state.config.model },
+            };
+            yield* writeCommandResponse(runtime, resp);
+            publishStatus(runtime, "idle");
+            return;
+        }
+        case "get_info": {
+            const resp = {
+                id: cmdMsg.id,
+                cmd: cmdMsg.cmd,
+                result: {
+                    model: runtime.state.config.model || "(default)",
+                    iteration: runtime.state.iteration,
+                    sessionId: runtime.input.sessionId,
+                    affinityKey: runtime.state.affinityKey,
+                    affinityKeyShort: runtime.state.affinityKey?.slice(0, 8),
+                    preserveAffinityOnHydrate: runtime.state.preserveAffinityOnHydrate,
+                    needsHydration: runtime.state.needsHydration,
+                    blobEnabled: runtime.state.blobEnabled,
+                    contextUsage: runtime.state.contextUsage,
+                },
+            };
+            yield* writeCommandResponse(runtime, resp);
+            publishStatus(runtime, "idle");
+            return;
+        }
+        case "done":
+        case "cancel":
+        case "delete": {
+            runtime.ctx.traceInfo(`[orch] ${cmdMsg.cmd} command received — beginning graceful ${cmdMsg.cmd}`);
+            yield* beginGracefulShutdown(runtime, cmdMsg.cmd, cmdMsg);
+            return;
+        }
+        default: {
+            const resp = {
+                id: cmdMsg.id,
+                cmd: cmdMsg.cmd,
+                error: `Unknown command: ${cmdMsg.cmd}`,
+            };
+            yield* writeCommandResponse(runtime, resp);
+            publishStatus(runtime, "idle");
+            return;
+        }
+    }
+}
+function* captureModelSwitchInterruptedTimer(runtime, newModelLabel) {
+    const timer = runtime.state.activeTimer;
+    if (!timer)
+        return;
+    const now = yield runtime.ctx.utcNow();
+    const notePrefix = `Model switch accepted; continuing immediately on ${newModelLabel}`;
+    switch (timer.type) {
+        case "wait": {
+            const remainingMs = Math.max(0, timer.deadlineMs - now);
+            runtime.state.interruptedWaitTimer = {
+                remainingSec: Math.max(1, Math.round(remainingMs / 1000)),
+                reason: timer.reason,
+                shouldRehydrate: timer.shouldRehydrate ?? false,
+                ...(timer.waitPlan ? { waitPlan: timer.waitPlan } : {}),
+            };
+            runtime.ctx.traceInfo(`[orch-cmd] ${notePrefix}; will auto-resume interrupted wait (${runtime.state.interruptedWaitTimer.remainingSec}s remain)`);
+            runtime.state.activeTimer = null;
+            return;
+        }
+        case "cron": {
+            const remainingMs = Math.max(0, timer.deadlineMs - now);
+            runtime.state.interruptedCronTimer = {
+                remainingMs,
+                reason: timer.reason,
+                originalDurationMs: timer.originalDurationMs,
+                ...(timer.shouldRehydrate ? { shouldRehydrate: true } : {}),
+            };
+            runtime.ctx.traceInfo(`[orch-cmd] ${notePrefix}; will auto-resume interrupted cron (${Math.round(remainingMs / 1000)}s remain)`);
+            runtime.state.activeTimer = null;
+            return;
+        }
+        case "cron_at":
+        case "idle":
+        case "agent-poll":
+        case "input-grace":
+            runtime.ctx.traceInfo(`[orch-cmd] ${notePrefix}; clearing active ${timer.type} timer`);
+            runtime.state.activeTimer = null;
+            return;
+    }
+}
+// ─── Session regeneration pipeline (1.0.67, proposal §4) ────────
+//
+// Called from the run loop AFTER drain whenever state.regen is set: one
+// stage per invocation, returning to the loop between stages so a queued
+// cancel_regen / cancel / delete pre-empts a pending regen. Archive and
+// distill are attempt-idempotent activities; any pre-flip failure aborts
+// into the fail-safe (regen cleared, session continues in the old epoch —
+// nothing has changed). The flip is the point of no return: a continue-as-
+// new carrying the fresh epoch, the boundary record, and the flip-mutation
+// table's dispositions (contextUsage zeroed, shared preamble re-armed,
+// pending question and roster carried).
+/** Overall budget for a service-session distillation before the deterministic fallback. */
+const DISTILLER_SESSION_DEADLINE_MS = 5 * 60 * 1000;
+/** Durable pause between distiller polls (drain sweeps for pre-empting cmds in between). */
+const DISTILLER_POLL_MS = 10_000;
+/**
+ * Deterministic distill: the in-activity closure package (M1 path). Shared by
+ * the per-regen deterministic mode and every LLM-path fallback (no model,
+ * distiller failed, deadline exceeded) — the regen never blocks on
+ * distillation quality.
+ */
+function* runDeterministicDistill(runtime, regen) {
+    const state = runtime.state;
+    const distill = yield runtime.manager.runRegenDistill(runtime.input.sessionId, state.transcriptEpoch, regen.attemptId, {
+        ...(regen.handoff ? { handoff: regen.handoff } : {}),
+        ...(regen.instructions ? { instructions: regen.instructions } : {}),
+        ...(state.config.model ? { sessionModel: state.config.model } : {}),
+        ...(regen.distillerModel ? { distillerModel: regen.distillerModel } : {}),
+        ...(regen.distillerReasoningEffort ? { distillerReasoningEffort: regen.distillerReasoningEffort } : {}),
+        ...(regen.distillerContextTier ? { distillerContextTier: regen.distillerContextTier } : {}),
+        ...(regen.archiveArtifactId ? { archiveArtifactId: regen.archiveArtifactId } : {}),
+        ...(regen.archiveChunkIds?.length ? { archiveChunkIds: regen.archiveChunkIds } : {}),
+    });
+    const bootstrap = String(distill?.bootstrap ?? "");
+    if (!bootstrap)
+        throw new Error("distill produced no bootstrap");
+    state.regen = {
+        ...regen,
+        stage: "distilled",
+        packageArtifactId: String(distill?.packageArtifactId ?? ""),
+        bootstrap,
+    };
+    state.regen.distillMs = Number(distill?.distillMs) || 0;
+    state.regen.distillerModel = String(distill?.distillerModel ?? "");
+    state.regen.distillModeFinal = "deterministic";
+}
+export function* advanceRegenPipeline(runtime) {
+    const { state } = runtime;
+    const regen = state.regen;
+    if (!regen)
+        return false;
+    const sessionId = runtime.input.sessionId;
+    try {
+        if (regen.stage === "requested") {
+            publishStatus(runtime, "running", { regenStage: "archiving" });
+            const archive = yield runtime.manager.runRegenArchive(sessionId, state.transcriptEpoch, regen.attemptId);
+            state.regen = {
+                ...regen,
+                stage: "archived",
+                archiveArtifactId: String(archive?.archiveArtifactId ?? ""),
+            };
+            // Chunk list rides alongside the id so the distiller can page the
+            // WHOLE archive; archiveArtifactId stays the first chunk for
+            // consumers (and already-archived epochs) that predate chunking.
+            state.regen.selectionStrategy = String(archive?.selectionStrategy ?? "");
+            state.regen.elidedCount = Number(archive?.elidedCount) || 0;
+            state.regen.archiveChunkIds = Array.isArray(archive?.archiveChunkIds)
+                ? archive.archiveChunkIds.map((id) => String(id))
+                : [];
+            state.regen.archiveMs = Number(archive?.archiveMs) || 0;
+            state.regen.turnsArchived = Number(archive?.turnsArchived) || 0;
+            state.regen.compactionsArchived = Number(archive?.compactionsArchived) || 0;
+            return false;
+        }
+        if (regen.stage === "archived") {
+            publishStatus(runtime, "running", { regenStage: "distilling" });
+            // Deterministic mode (per-regen choice) → the in-activity closure
+            // package, exactly the M1 path. LLM mode (default) → spawn the
+            // regen-distiller SERVICE SESSION under the tree root and poll it.
+            if (regen.distillMode === "deterministic") {
+                yield* runDeterministicDistill(runtime, regen);
+                return false;
+            }
+            const spawn = yield runtime.manager.runRegenSpawnDistiller(sessionId, state.transcriptEpoch, regen.attemptId, {
+                ...(regen.archiveArtifactId ? { archiveArtifactId: regen.archiveArtifactId } : {}),
+                ...(regen.archiveChunkIds?.length ? { archiveChunkIds: regen.archiveChunkIds } : {}),
+                ...(regen.handoff ? { handoff: regen.handoff } : {}),
+                ...(regen.instructions ? { instructions: regen.instructions } : {}),
+                ...(regen.distillerModel ? { distillerModel: regen.distillerModel } : {}),
+                ...(regen.distillerReasoningEffort ? { distillerReasoningEffort: regen.distillerReasoningEffort } : {}),
+                ...(regen.distillerContextTier ? { distillerContextTier: regen.distillerContextTier } : {}),
+            });
+            if (!spawn?.distillerSessionId) {
+                // No resolvable distiller model (or deterministic-only deployment
+                // kill switch inside the activity) — the deterministic package is
+                // the floor, never a blocked regen.
+                runtime.ctx.traceInfo(`[orch] distiller spawn fell back (${String(spawn?.fallback ?? "unknown")}) — deterministic package`);
+                yield* runDeterministicDistill(runtime, regen);
+                return false;
+            }
+            const spawnedAt = yield runtime.ctx.utcNow();
+            state.regen = {
+                ...regen,
+                stage: "distilling",
+                distillerSessionId: String(spawn.distillerSessionId),
+                // Record the RESOLVED model separately — leave distillerModel
+                // (the requester's override) intact so a later deterministic
+                // fallback still resolves the operator's choice, not "(default)".
+                distillerModelResolved: String(spawn.distillerModel ?? "(default)"),
+                distillStartedAtMs: spawnedAt,
+            };
+            return false;
+        }
+        if (regen.stage === "distilling") {
+            publishStatus(runtime, "running", { regenStage: "distilling", distillerSessionId: regen.distillerSessionId });
+            const nowMs = yield runtime.ctx.utcNow();
+            const startedAt = regen.distillStartedAtMs ?? regen.requestedAtMs;
+            const check = yield runtime.manager.runRegenCheckDistiller(regen.distillerSessionId);
+            if (check?.status === "completed") {
+                const collect = yield runtime.manager.runRegenCollectDistiller(sessionId, state.transcriptEpoch, regen.attemptId, regen.distillerSessionId, {
+                    ...(regen.archiveArtifactId ? { archiveArtifactId: regen.archiveArtifactId } : {}),
+                    ...(regen.archiveChunkIds?.length ? { archiveChunkIds: regen.archiveChunkIds } : {}),
+                    ...(regen.handoff ? { handoff: regen.handoff } : {}),
+                    ...(regen.instructions ? { instructions: regen.instructions } : {}),
+                    ...(regen.distillerModel ? { distillerModel: regen.distillerModel } : {}),
+                    ...(regen.distillerReasoningEffort ? { distillerReasoningEffort: regen.distillerReasoningEffort } : {}),
+                    ...(regen.distillerContextTier ? { distillerContextTier: regen.distillerContextTier } : {}),
+                });
+                const bootstrap = String(collect?.bootstrap ?? "");
+                if (!bootstrap)
+                    throw new Error("distiller collect produced no bootstrap");
+                const doneAt = yield runtime.ctx.utcNow();
+                state.regen = {
+                    ...regen,
+                    stage: "distilled",
+                    packageArtifactId: String(collect?.packageArtifactId ?? ""),
+                    bootstrap,
+                    distillerModelResolved: String(collect?.distillerModel ?? regen.distillerModelResolved ?? "(default)"),
+                };
+                state.regen.distillMs = Math.max(0, doneAt - startedAt);
+                state.regen.distillModeFinal = String(collect?.distillMode ?? "llm");
+                return false;
+            }
+            if (check?.status === "failed" || nowMs - startedAt > DISTILLER_SESSION_DEADLINE_MS) {
+                runtime.ctx.traceInfo(`[orch] distiller ${regen.distillerSessionId} ${check?.status === "failed" ? `failed (${check?.reason})` : "deadline exceeded"} — cancelling + deterministic package`);
+                yield runtime.manager.runRegenCancelDistiller(regen.distillerSessionId);
+                yield* runDeterministicDistill(runtime, regen);
+                return false;
+            }
+            // Still running: pace the poll with a short durable timer, then
+            // yield back to the drain (which sweeps for pre-empting cmds).
+            yield runtime.ctx.scheduleTimer(DISTILLER_POLL_MS);
+            return false;
+        }
+        // stage "distilled" → FLIP. COMMIT POINT: the distill result is in
+        // history; from here replay roll-forwards through the CAN.
+        const nowMs = yield runtime.ctx.utcNow();
+        publishStatus(runtime, "running", { regenStage: "flipping" });
+        const fromEpoch = state.transcriptEpoch;
+        const toEpoch = fromEpoch + 1;
+        const r = regen;
+        // Clear the armed idle/affinity/cron timer (stashing wait/cron as
+        // interrupted so they re-arm after the grounding turn) — exactly as
+        // set_model does before its bootstrap CAN. Without this the reborn
+        // execution restores the timer and drain parks on it BEFORE decide
+        // dispatches the grounding bootstrap, delaying the rebirth for up to
+        // the hold window.
+        yield* captureModelSwitchInterruptedTimer(runtime, "regenerated context");
+        // Optional model rebind: the reborn session's grounding turn runs on
+        // config.model, so an operator-supplied replacement (e.g. escaping a
+        // removed model) must be applied to the carried config before the CAN.
+        if (r.model && typeof r.model === "string") {
+            state.config = { ...state.config, model: r.model };
+            yield runtime.manager.updateSessionModel(sessionId, r.model);
+        }
+        // Drop runtime notices that describe the dead transcript before the
+        // carry-list is built.
+        state.runtimeModelNotice = undefined;
+        const canInput = {
+            ...continueInputWithPrompt(runtime, regen.bootstrap ?? "", { bootstrapPrompt: true }),
+            // Grounding is prompt-level in M1 (FIRST ACTIONS in the rendered
+            // bootstrap): a hard requiredTool would fail the grounding turn on
+            // deployments without fact tools. Enforce once fact tools are
+            // guaranteed present.
+            transcriptEpoch: toEpoch,
+            epochStartPending: true,
+            epochStartIteration: state.iteration,
+            lastRegenAtMs: nowMs,
+            regen: undefined,
+            contextUsage: undefined,
+            sharedPreambleSent: false,
+            pendingEpochCommit: {
+                fromEpoch,
+                toEpoch,
+                attemptId: regen.attemptId,
+                trigger: regen.trigger,
+                requestedAtMs: regen.requestedAtMs,
+                ...(regen.archiveArtifactId ? { archiveArtifactId: regen.archiveArtifactId } : {}),
+                ...(regen.archiveChunkIds?.length ? { archiveChunkIds: regen.archiveChunkIds } : {}),
+                ...(regen.packageArtifactId ? { packageArtifactId: regen.packageArtifactId } : {}),
+                ...(r.turnsArchived ? { turnsArchived: r.turnsArchived } : {}),
+                ...(r.compactionsArchived ? { compactionsArchived: r.compactionsArchived } : {}),
+                ...(r.archiveMs ? { archiveMs: r.archiveMs } : {}),
+                ...(r.distillMs ? { distillMs: r.distillMs } : {}),
+                ...(r.distillModeFinal ? { distillMode: r.distillModeFinal } : {}),
+                ...((r.distillerModelResolved || r.distillerModel) ? { distillerModel: r.distillerModelResolved || r.distillerModel } : {}),
+                ...(r.distillerSessionId && r.distillModeFinal === "llm" ? { distillerSessionId: r.distillerSessionId } : {}),
+            },
+        };
+        yield* versionedContinueAsNew(runtime, canInput);
+        return true;
+    }
+    catch (err) {
+        // FAIL-SAFE (pre-flip only): clear the pipeline so a later attempt is
+        // not refused as pending; the session continues in the old epoch. If a
+        // distiller service session was in flight, cancel it first so it does
+        // not park idle forever (the sweeper never reclaims a live session).
+        const failedStage = state.regen?.stage ?? "requested";
+        const attemptId = state.regen?.attemptId ?? "unknown";
+        yield* cancelInFlightDistiller(runtime);
+        state.regen = null;
+        runtime.ctx.traceInfo(`[orch] regen attempt ${attemptId} failed at ${failedStage}: ${err?.message ?? err}`);
+        yield runtime.manager.recordSessionEvent(sessionId, [{
+                eventType: "session.regenerate_failed",
+                data: { attemptId, stage: failedStage, error: String(err?.message ?? err).slice(0, 500) },
+            }]);
+        publishStatus(runtime, "idle");
+        return false;
+    }
+}
+//# sourceMappingURL=lifecycle.js.map