pilotswarm-sdk 0.5.19 → 0.5.21

package/dist/session-proxy.js

@@ -10,12 +10,14 @@ import { mergePromptSections } from "./prompt-layering.js";
 import { approvePermissionForSession } from "./permissions.js";
 import { formatSessionOwnerLabel, getSessionOwnerKind, matchesSessionOwnerFilters } from "./session-owner-utils.js";
 import { cmsRetryBestEffort, cmsRetryCritical } from "./cms-retry.js";
+import { archiveName, artifactExists, assembleRegenClosure, buildMapReduceSeedPrompt, deterministicPackage, DISTILLER_SYSTEM_MESSAGE, distillInputName, distillOutputName, packageName, parseDistillerResponse, renderBootstrap, runRegenArchive, runRegenDistill, } from "./regen-worker.js";
+import { REGEN_DISTILLER_SERVICE_KIND } from "./distiller-tools.js";
 import { computeCronAtNextFire } from "./cron-at.js";
 import { SpanStatusCode, trace as otelTrace } from "@opentelemetry/api";
 import os from "node:os";
 import fs from "node:fs";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { attemptStoreRecovery, runTurnCommit, runTurnPreamble } from "./session-lifecycle.js";
 import { supportsVersionedSnapshots, writeTurnSentinel } from "./snapshot-protocol.js";
 const SYSTEM_AGENT_IDS = new Set(["pilotswarm", "sweeper", "resourcemgr", "facts-manager", "agent-tuner"]);
@@ -439,7 +441,12 @@ async function tryReadSnapshotSizeBytes(sessionStore, sessionId) {
 export function createSessionProxy(ctx, sessionId, affinityKey, config) {
     return {
         runTurn(prompt, bootstrap, turnIndex, turnMeta) {
-            return ctx.scheduleActivityOnSession("runTurn", {
+            return ctx.scheduleActivityOnSession(
+            // The epoch-start turn is a distinct activity name (runTurn2):
+            // pre-1.0.67 workers don't register it, so a rolling deploy can
+            // never hand the fresh-epoch create to a worker that would
+            // silently resume the dead transcript instead.
+            turnMeta?.epochStart ? "runTurn2" : "runTurn", {
                 sessionId,
                 prompt,
                 config,
@@ -463,6 +470,8 @@ export function createSessionProxy(ctx, sessionId, affinityKey, config) {
                 ...(turnMeta?.attachments && turnMeta.attachments.length > 0
                     ? { attachments: turnMeta.attachments }
                     : {}),
+                ...(turnMeta?.transcriptEpoch ? { transcriptEpoch: turnMeta.transcriptEpoch } : {}),
+                ...(turnMeta?.epochStart ? { epochStart: true } : {}),
             }, affinityKey);
         },
         dehydrate(reason, eventData) {
@@ -656,6 +665,40 @@ export function createSessionManagerProxy(ctx) {
         computeCronAtNextFire(schedule, afterUtcMs, lastOccurrenceKey) {
             return ctx.scheduleActivity("computeCronAtNextFire", { schedule, afterUtcMs, lastOccurrenceKey });
         },
+        // ── Session regeneration (1.0.67) ──────────────────────
+        /** ARCHIVE stage: transcript slice → attempt-scoped artifact. Idempotent per attempt. */
+        runRegenArchive(sessionId, epoch, attemptId) {
+            return ctx.scheduleActivity("runRegenArchive", { sessionId, epoch, attemptId });
+        },
+        /** DISTILL (deterministic): closure package in-activity → ResumePackage artifact + bootstrap. */
+        runRegenDistill(sessionId, epoch, attemptId, opts) {
+            return ctx.scheduleActivity("runRegenDistill", { sessionId, epoch, attemptId, ...(opts ?? {}) });
+        },
+        /** Post-flip boundary: epoch_committed event + transcript_epoch + regen_count, one CMS transaction. */
+        commitEpochBoundary(sessionId, commit) {
+            return ctx.scheduleActivity("commitEpochBoundary", { sessionId, commit });
+        },
+        /** Proven rebirth: session.regenerated event + last_regen_stats. */
+        recordRegenerated(sessionId, payload) {
+            return ctx.scheduleActivity("recordRegenerated", { sessionId, payload });
+        },
+        // ── Service-session distiller (1.0.68) ─────────────────
+        /** Spawn the regen-distiller service session under the tree root (idempotent per attempt). */
+        runRegenSpawnDistiller(sessionId, epoch, attemptId, opts) {
+            return ctx.scheduleActivity("runRegenSpawnDistiller", { sessionId, epoch, attemptId, ...(opts ?? {}) });
+        },
+        /** Poll the distiller service session: running | completed (with response) | failed. */
+        runRegenCheckDistiller(distillerSessionId) {
+            return ctx.scheduleActivity("runRegenCheckDistiller", { distillerSessionId });
+        },
+        /** Parse/validate the distiller's final message into the package (+dumps); deterministic fallback on junk. */
+        runRegenCollectDistiller(sessionId, epoch, attemptId, distillerSessionId, opts) {
+            return ctx.scheduleActivity("runRegenCollectDistiller", { sessionId, epoch, attemptId, distillerSessionId, ...(opts ?? {}) });
+        },
+        /** Best-effort cancel of a timed-out/failed distiller service session. */
+        runRegenCancelDistiller(distillerSessionId) {
+            return ctx.scheduleActivity("runRegenCancelDistiller", { distillerSessionId });
+        },
     };
 }
 // ─── Activity Registration ───────────────────────────────────────
@@ -695,7 +738,7 @@ artifactStore) {
         ...(clientConfig?.aadDbUser != null && { aadDbUser: clientConfig.aadDbUser }),
     });
     // ── runTurn ──────────────────────────────────────────────
-    runtime.registerActivity("runTurn", async (activityCtx, input) => {
+    const runTurnHandler = async (activityCtx, input) => {
         // Attachment count is traced unconditionally: a 2026-07-21 incident
         // showed turns whose ActivityScheduled input carried refs executing
         // WITHOUT them (suspected work-item redelivery after eviction/lock
@@ -786,12 +829,17 @@ artifactStore) {
                         // observability-only reads (lossy flag, snapshot_store_empty).
                         expectedVersion: input.snapshot.expectedVersion ?? 0,
                         turnKey: input.snapshot.turnKey,
+                        // Session regeneration: epoch scopes every store call to
+                        // the current chain and gates local-dir trust. Absent on
+                        // pre-1.0.67 inputs → 0 (legacy chain, today's behavior).
+                        transcriptEpoch: input.transcriptEpoch ?? 0,
                         dropWarmSession: () => sessionManager.dropWarmSession(input.sessionId),
                         trace,
                     }
                     : null;
                 let lifecycleBaseVersion = 0;
                 let lifecycleRehydrated = false;
+                let lifecyclePreambleFresh = false;
                 // Protocol-native persistence stats: the legacy dehydrate/hydrate
                 // activities no longer run, so the preamble/commit paths feed the
                 // same CMS summary + events the Stats pane reads. Best-effort only.
@@ -819,6 +867,7 @@ artifactStore) {
                     }
                     lifecycleBaseVersion = pre.baseVersion;
                     lifecycleRehydrated = pre.kind === "hydrated";
+                    lifecyclePreambleFresh = pre.kind === "fresh";
                     if (lifecycleRehydrated) {
                         await recordLifecycleHydration(pre.baseVersion);
                     }
@@ -837,7 +886,7 @@ artifactStore) {
                                 },
                             }], workerNodeId), (msg) => activityCtx.traceInfo(msg));
                     }
-                    if (pre.kind === "fresh" && pre.lossy && catalog) {
+                    if (pre.kind === "fresh" && pre.lossy && !input.epochStart && catalog) {
                         await cmsRetryBestEffort(`runTurn.recordEvent snapshot-store-empty session=${input.sessionId}`, () => catalog.recordEvents(input.sessionId, [{
                                 eventType: "session.snapshot_store_empty",
                                 data: {
@@ -850,9 +899,17 @@ artifactStore) {
                 const executeTurnBody = async () => {
                     let session = null;
                     let effectivePrompt = input.prompt;
+                    // Conditional epoch init (runTurn2): create a brand-new SDK session
+                    // ONLY when the epoch's chain is empty (preamble "fresh"). A committed
+                    // grounding turn recovers via already-committed above; a non-empty
+                    // chain resumes — an unconditional reset would erase a committed
+                    // grounding turn on activity retry.
+                    const epochCreate = input.epochStart === true && (!lifecycle || lifecyclePreambleFresh);
                     try {
                         session = await sessionManager.getOrCreate(input.sessionId, runConfig, {
                             turnIndex: input.turnIndex,
+                            transcriptEpoch: input.transcriptEpoch ?? 0,
+                            ...(epochCreate ? { epochStart: true } : {}),
                             trace,
                             lockHeld: true,
                         });
@@ -1279,6 +1336,62 @@ artifactStore) {
                                 return `[SYSTEM: set_session_model failed: ${err?.message || String(err)}]`;
                             }
                         },
+                        regenerateContext: async (args) => {
+                            try {
+                                if (!storeUrl)
+                                    return "[SYSTEM: regenerate_context failed: no storeUrl is configured.]";
+                                const sdkClient = new PilotSwarmClient(internalClientConfig());
+                                try {
+                                    await sdkClient.start();
+                                    await sdkClient.duroxideClient.enqueueEvent(`session-${input.sessionId}`, "messages", JSON.stringify({
+                                        type: "cmd",
+                                        cmd: "regenerate",
+                                        id: `regenerate-tool-${randomUUID()}`,
+                                        args: {
+                                            ...(args.handoff ? { handoff: String(args.handoff).slice(0, 4_000) } : {}),
+                                            ...(args.instructions ? { instructions: String(args.instructions).slice(0, 4_000) } : {}),
+                                            source: "tool",
+                                        },
+                                        // Owner-gate evidence: the runTurn activity input's
+                                        // authoritative sender, stamped server-side — the
+                                        // cmd handler refuses non-owner turns on shared
+                                        // sessions. Never an LLM-supplied value.
+                                        ...(input.sender ? { sender: input.sender } : {}),
+                                    }));
+                                }
+                                finally {
+                                    await sdkClient.stop().catch(() => { });
+                                }
+                                return "[SYSTEM: Regeneration accepted. Finish this turn cleanly NOW — at the next boundary the runtime archives your transcript, distills a resume package, and rebuilds your context. Durable state (facts, artifacts, children, schedule) is untouched.]";
+                            }
+                            catch (err) {
+                                return `[SYSTEM: regenerate_context failed: ${err?.message || String(err)}]`;
+                            }
+                        },
+                        regenerateAgent: async (args) => {
+                            try {
+                                const child = await resolveManagedChild(args.agent_id);
+                                const sdkClient = await getInlineClient();
+                                await sdkClient._getDuroxideClient().enqueueEvent(child.orchId, "messages", JSON.stringify({
+                                    type: "cmd",
+                                    cmd: "regenerate",
+                                    id: `regenerate-parent-${randomUUID()}`,
+                                    args: {
+                                        ...(args.handoff ? { handoff: String(args.handoff).slice(0, 4_000) } : {}),
+                                        ...(args.instructions ? { instructions: String(args.instructions).slice(0, 4_000) } : {}),
+                                        source: "parent",
+                                    },
+                                    // Parent-of gate evidence: the child's handler accepts
+                                    // source "parent" only when this id equals its own
+                                    // carried parentSessionId.
+                                    requestedBy: input.sessionId,
+                                }));
+                                return `[SYSTEM: Regeneration requested for sub-agent ${child.orchId}. It applies at the child's next turn boundary; check_agents will reflect the rebirth. Continue your work in this SAME turn.]`;
+                            }
+                            catch (err) {
+                                return `[SYSTEM: regenerate_agent failed: ${err?.message || String(err)}]`;
+                            }
+                        },
                         messageAgent: async (args) => {
                             try {
                                 const child = await resolveManagedChild(args.agent_id);
@@ -2165,7 +2278,12 @@ artifactStore) {
                 catch { }
             }
         }
-    });
+    };
+    runtime.registerActivity("runTurn", runTurnHandler);
+    // Session regeneration: the epoch-start turn dispatches under a NEW
+    // activity name so pre-1.0.67 workers — which would silently resume the
+    // dead transcript — structurally cannot receive it (deployment gate §4).
+    runtime.registerActivity("runTurn2", runTurnHandler);
     // ── abortTurn ────────────────────────────────────────────
     // Stop-turn fast-path interrupt. Routed on the session affinity key so it
     // lands on the worker owning the warm ManagedSession and runs CONCURRENTLY
@@ -2997,5 +3115,289 @@ artifactStore) {
         activityCtx.traceInfo(`[computeCronAtNextFire] tz=${input.schedule?.tz} after=${input.afterUtcMs}`);
         return computeCronAtNextFire(input.schedule, input.afterUtcMs, input.lastOccurrenceKey);
     });
+    // ── Session regeneration activities (1.0.67) ──────────────
+    const regenDeps = (activityCtx) => {
+        if (!catalog)
+            throw new Error("session regeneration requires the CMS catalog");
+        return {
+            catalog,
+            artifactStore: artifactStore ?? null,
+            resolveModelOptions: (ref) => sessionManager.resolveModelSessionOptions(ref),
+            fallbackDistillerModel: process.env.PILOTSWARM_DISTILLER_FALLBACK_MODEL || undefined,
+            trace: (message) => activityCtx.traceInfo(`[regen] ${message}`),
+        };
+    };
+    runtime.registerActivity("runRegenArchive", async (activityCtx, input) => {
+        activityCtx.traceInfo(`[runRegenArchive] session=${input.sessionId} epoch=${input.epoch} attempt=${input.attemptId}`);
+        return runRegenArchive(regenDeps(activityCtx), input);
+    });
+    runtime.registerActivity("runRegenDistill", async (activityCtx, input) => {
+        activityCtx.traceInfo(`[runRegenDistill] session=${input.sessionId} epoch=${input.epoch} attempt=${input.attemptId}`);
+        return runRegenDistill(regenDeps(activityCtx), input);
+    });
+    runtime.registerActivity("commitEpochBoundary", async (activityCtx, input) => {
+        if (!catalog)
+            throw new Error("session regeneration requires the CMS catalog");
+        activityCtx.traceInfo(`[commitEpochBoundary] session=${input.sessionId} toEpoch=${input.commit?.toEpoch}`);
+        return catalog.recordEpochCommitted(input.sessionId, input.commit);
+    });
+    runtime.registerActivity("recordRegenerated", async (activityCtx, input) => {
+        if (!catalog)
+            throw new Error("session regeneration requires the CMS catalog");
+        activityCtx.traceInfo(`[recordRegenerated] session=${input.sessionId} epoch=${input.payload?.epoch}`);
+        return catalog.recordRegenerated(input.sessionId, input.payload);
+    });
+    // ── Service-session distiller activities (1.0.68) ──────────
+    // The distiller is a REAL session (service_kind="regen-distiller") under
+    // the served tree's ROOT: lifecycle events, metrics, and normal sweeper
+    // cleanup apply because nothing is special-cased. Its id is deterministic
+    // per attempt so activity retries reuse the same session.
+    const distillerSessionIdFor = (sessionId, epoch, attemptId) => {
+        const digest = createHash("sha1")
+            .update(`ps-regen-distiller:${sessionId}:e${epoch}:${attemptId}`)
+            .digest();
+        const b = Buffer.from(digest.subarray(0, 16));
+        b[6] = (b[6] & 0x0f) | 0x50; // UUIDv5 version bits
+        b[8] = (b[8] & 0x3f) | 0x80; // RFC 4122 variant
+        const h = b.toString("hex");
+        return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+    };
+    const enqueueDistillerCmd = async (distillerSessionId, cmd, idPrefix) => {
+        const sdkClient = new PilotSwarmClient(internalClientConfig());
+        try {
+            await sdkClient.start();
+            await sdkClient.duroxideClient.enqueueEvent(`session-${distillerSessionId}`, "messages", JSON.stringify({ type: "cmd", cmd, id: `${idPrefix}-${randomUUID()}` }));
+        }
+        finally {
+            await sdkClient.stop().catch(() => { });
+        }
+    };
+    runtime.registerActivity("runRegenSpawnDistiller", async (activityCtx, input) => {
+        if (!catalog)
+            throw new Error("distiller spawn requires the CMS catalog");
+        if (!artifactStore)
+            throw new Error("distiller spawn requires an artifact store");
+        if (!storeUrl)
+            throw new Error("distiller spawn requires a storeUrl");
+        // Deployment kill switch: force the deterministic package fleet-wide.
+        // Read in the ACTIVITY (recorded in history) — never in the orchestration.
+        if (process.env.PILOTSWARM_REGEN_DETERMINISTIC_ONLY === "1") {
+            return { fallback: "deterministic-only" };
+        }
+        const deps = regenDeps(activityCtx);
+        const distillerSessionId = distillerSessionIdFor(input.sessionId, input.epoch, input.attemptId);
+        // Build the seed once — reused by the fresh spawn and by the re-seed
+        // path below so a create-then-crash-before-send retry still delivers it.
+        const buildSeed = async () => {
+            const closure = await assembleRegenClosure({ catalog, artifactStore: artifactStore }, input.sessionId);
+            const seed = buildMapReduceSeedPrompt({
+                servedSessionId: input.sessionId,
+                epoch: input.epoch,
+                attemptId: input.attemptId,
+                archiveArtifactId: input.archiveArtifactId || archiveName(input.epoch, input.attemptId),
+                closure,
+                ...(input.handoff ? { handoff: input.handoff } : {}),
+                ...(input.instructions ? { instructions: input.instructions } : {}),
+            });
+            // Dump the EXACT distiller input (§9 dumps) on the served session.
+            await artifactStore.uploadArtifact(input.sessionId, distillInputName(input.epoch, input.attemptId), Buffer.from(seed, "utf8"), "text/markdown");
+            return seed;
+        };
+        const existing = await catalog.getSession(distillerSessionId).catch(() => null);
+        if (existing) {
+            // Only reuse a row that is ACTUALLY our distiller for THIS session —
+            // re-verify the service columns before trusting its output as this
+            // regen's package. The id is per-attempt and unguessable, so a
+            // mismatch is not a real attack, but defense-in-depth: never collect
+            // a foreign/mislabelled session as the distiller (adversarial-review
+            // finding). A mismatch throws → the pipeline falls back deterministically.
+            if (existing.serviceKind !== REGEN_DISTILLER_SERVICE_KIND || existing.serviceOf !== input.sessionId) {
+                throw new Error(`distiller id collision: ${distillerSessionId} exists but is not this session's distiller `
+                    + `(serviceKind=${existing.serviceKind ?? "null"}, serviceOf=${existing.serviceOf ?? "null"})`);
+            }
+            // Re-seed if the seed never landed (activity retried after
+            // createSession but before send): otherwise the distiller sits with
+            // no orchestration/work and the regen burns the whole 5-min deadline
+            // before falling back (adversarial-review finding). Idempotent —
+            // _startTurn ensures the orchestration then enqueues the prompt.
+            const seeded = (await catalog.getSessionEventsBefore(distillerSessionId, Number.MAX_SAFE_INTEGER, 1, ["user.message"]).catch(() => [])).length > 0;
+            if (!seeded) {
+                activityCtx.traceInfo(`[runRegenSpawnDistiller] ${distillerSessionId} exists but was never seeded — re-seeding`);
+                const seed = await buildSeed();
+                const reseedClient = new PilotSwarmClient(internalClientConfig());
+                try {
+                    await reseedClient.start();
+                    await catalog.markSessionService(distillerSessionId, REGEN_DISTILLER_SERVICE_KIND, input.sessionId);
+                    await reseedClient._startTurn(distillerSessionId, seed, { bootstrap: true });
+                }
+                finally {
+                    await reseedClient.stop().catch(() => { });
+                }
+            }
+            else {
+                activityCtx.traceInfo(`[runRegenSpawnDistiller] reusing ${distillerSessionId} (attempt retry)`);
+            }
+            return { distillerSessionId, distillerModel: existing.model ?? "(existing)", reused: true };
+        }
+        // Model policy (§9): per-call override → CLUSTER DEFAULT → configured
+        // fallback. The served session's model is deliberately not in the chain.
+        const candidates = [input.distillerModel, undefined, deps.fallbackDistillerModel];
+        let resolvedRef;
+        let resolvedAny = false;
+        for (const ref of candidates) {
+            if (deps.resolveModelOptions(ref)) {
+                resolvedRef = ref;
+                resolvedAny = true;
+                break;
+            }
+        }
+        if (!resolvedAny) {
+            activityCtx.traceInfo(`[runRegenSpawnDistiller] no distiller model resolvable — caller falls back deterministically`);
+            return { fallback: "no-model" };
+        }
+        // Root ancestor: service sessions collect under the tree root so a
+        // sub-agent's distiller is still visible at the top (§9.1).
+        let rootId = input.sessionId;
+        for (let hop = 0; hop < 16; hop++) {
+            const row = await catalog.getSession(rootId).catch(() => null);
+            if (!row?.parentSessionId)
+                break;
+            rootId = row.parentSessionId;
+        }
+        const seed = await buildSeed();
+        const owner = await resolveEffectiveSpawnOwner((id) => catalog.getSession(id), rootId).catch(() => null);
+        const sdkClient = new PilotSwarmClient(internalClientConfig());
+        try {
+            await sdkClient.start();
+            const session = await sdkClient.createSession({
+                sessionId: distillerSessionId,
+                parentSessionId: rootId,
+                nestingLevel: 1,
+                agentId: REGEN_DISTILLER_SERVICE_KIND,
+                ...(resolvedRef ? { model: resolvedRef } : {}),
+                systemMessage: DISTILLER_SYSTEM_MESSAGE,
+                toolNames: ["read_transcript_page"],
+                ...(owner ? { owner } : {}),
+            });
+            await catalog.markSessionService(distillerSessionId, REGEN_DISTILLER_SERVICE_KIND, input.sessionId);
+            await cmsRetryBestEffort(`runRegenSpawnDistiller.updateSession meta session=${distillerSessionId}`, () => catalog.updateSession(distillerSessionId, {
+                title: `Regen Distiller — ${input.sessionId.slice(0, 8)} e${input.epoch}→e${input.epoch + 1}`,
+                agentId: REGEN_DISTILLER_SERVICE_KIND,
+            }), (msg) => activityCtx.traceInfo(msg));
+            await session.send(seed, { bootstrap: true });
+        }
+        finally {
+            await sdkClient.stop().catch(() => { });
+        }
+        activityCtx.traceInfo(`[runRegenSpawnDistiller] spawned ${distillerSessionId} under root ${rootId} model=${resolvedRef ?? "(default)"}`);
+        return { distillerSessionId, distillerModel: resolvedRef ?? "(default)" };
+    });
+    runtime.registerActivity("runRegenCheckDistiller", async (_activityCtx, input) => {
+        if (!catalog)
+            throw new Error("distiller check requires the CMS catalog");
+        const row = await catalog.getSession(input.distillerSessionId).catch(() => null);
+        if (!row)
+            return { status: "failed", reason: "missing" };
+        const rows = await catalog.getSessionEventsBefore(input.distillerSessionId, Number.MAX_SAFE_INTEGER, 1, ["assistant.message"]);
+        if (rows.length > 0)
+            return { status: "completed" };
+        if (row.state === "failed" || row.state === "cancelled" || row.state === "completed") {
+            return { status: "failed", reason: row.state };
+        }
+        return { status: "running" };
+    });
+    runtime.registerActivity("runRegenCollectDistiller", async (activityCtx, input) => {
+        if (!catalog)
+            throw new Error("distiller collect requires the CMS catalog");
+        if (!artifactStore)
+            throw new Error("distiller collect requires an artifact store");
+        const { sessionId, epoch, attemptId, distillerSessionId } = input;
+        const filename = packageName(epoch, attemptId);
+        const bootstrapMeta = {
+            epoch,
+            ...(input.archiveArtifactId ? { archiveArtifactId: input.archiveArtifactId } : {}),
+            packageArtifactId: filename,
+        };
+        // Attempt idempotency: a retry after the package landed re-renders from it.
+        if (await artifactExists(artifactStore, sessionId, filename)) {
+            const stored = await artifactStore.downloadArtifact(sessionId, filename);
+            const pkg = parseDistillerResponse(stored.body.toString("utf8"));
+            return {
+                packageArtifactId: filename,
+                bootstrap: renderBootstrap(pkg, bootstrapMeta),
+                distillerModel: "(reused)",
+                distillMode: "llm",
+                packageBytes: stored.body.length,
+            };
+        }
+        // Scan the last few assistant messages (newest first), not just the
+        // latest: a distiller that emits the JSON and THEN narrates ("done!")
+        // would otherwise be misread as junk (adversarial-review finding). The
+        // latest message is still dumped as the raw output of record.
+        const rows = await catalog.getSessionEventsBefore(distillerSessionId, Number.MAX_SAFE_INTEGER, 5, ["assistant.message"]);
+        const candidates = rows
+            .slice()
+            .sort((a, b) => Number(b.seq) - Number(a.seq))
+            .map((r) => String(r.data?.content ?? ""))
+            .filter((t) => t.trim());
+        const responseText = candidates[0] ?? "";
+        // Dump the RAW pre-parse output (§9 dumps) — junk that triggers the
+        // fallback stays inspectable.
+        await artifactStore.uploadArtifact(sessionId, distillOutputName(epoch, attemptId), Buffer.from(responseText, "utf8"), "text/plain");
+        let pkg;
+        let distillMode = "llm";
+        let modelLabel = input.distillerModel ?? "(default)";
+        try {
+            if (candidates.length === 0)
+                throw new Error("distiller produced no response");
+            // Take the newest message that parses as a valid ResumePackage.
+            let parsed;
+            for (const text of candidates) {
+                try {
+                    parsed = parseDistillerResponse(text);
+                    break;
+                }
+                catch { /* try older */ }
+            }
+            if (!parsed)
+                throw new Error("no assistant message parsed as a ResumePackage");
+            pkg = parsed;
+        }
+        catch (err) {
+            activityCtx.traceInfo(`[runRegenCollectDistiller] parse failed (${err?.message || err}) — deterministic fallback`);
+            const closure = await assembleRegenClosure({ catalog, artifactStore }, sessionId);
+            pkg = deterministicPackage(closure, { ...(input.instructions ? { instructions: input.instructions } : {}) });
+            distillMode = "deterministic";
+            modelLabel = `(fallback:${modelLabel}:invalid)`;
+        }
+        const body = Buffer.from(JSON.stringify(pkg, null, 2), "utf8");
+        await artifactStore.uploadArtifact(sessionId, filename, body, "application/json");
+        // The distiller delivered — complete it so the sweeper's normal
+        // stale-terminal scan reclaims it. Best-effort: an already-terminal or
+        // unreachable distiller must never fail the collect.
+        try {
+            await enqueueDistillerCmd(distillerSessionId, "done", "distiller-complete");
+        }
+        catch (err) {
+            activityCtx.traceInfo(`[runRegenCollectDistiller] complete enqueue failed (${err?.message || err})`);
+        }
+        return {
+            packageArtifactId: filename,
+            bootstrap: renderBootstrap(pkg, bootstrapMeta),
+            distillerModel: modelLabel,
+            distillMode,
+            packageBytes: body.length,
+        };
+    });
+    runtime.registerActivity("runRegenCancelDistiller", async (activityCtx, input) => {
+        try {
+            await enqueueDistillerCmd(input.distillerSessionId, "cancel", "distiller-cancel");
+            return { ok: true };
+        }
+        catch (err) {
+            activityCtx.traceInfo(`[runRegenCancelDistiller] cancel enqueue failed (${err?.message || err})`);
+            return { ok: false };
+        }
+    });
 }
 //# sourceMappingURL=session-proxy.js.map