@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.160

package/dist/services/interactive-before-versions.js

@@ -0,0 +1,148 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+import { PreparedInteractiveGitBaseline } from "./interactive-git-baseline.js";
+import { ObservedMemorySources } from "./memory-source-observations.js";
+import { memorySourceKey } from "./memory-stage-results.js";
+import { localEnvironmentAllowed } from "./workspace-files.js";
+function refuse(reason) {
+    throw new AppError("interactive_before_versions_invalid", "Interactive must retain selected original versions before changing them", 2, { reason, effect: "no_effect" });
+}
+function safe(name) {
+    return typeof name === "string" && !!name && name.length <= 4096 && !path.posix.isAbsolute(name) && !path.win32.isAbsolute(name)
+        && !name.includes("\\") && !name.includes("\0") && name.split("/").every(part => part && part !== "." && part !== ".."
+        && ![".git", ".dd-flow", "node_modules"].includes(part.normalize("NFC").toLowerCase()) && localEnvironmentAllowed(part));
+}
+function absent(root, logical) {
+    let current = root;
+    const parts = logical.split("/");
+    for (let index = 0; index < parts.length; index++) {
+        current = path.join(current, parts[index]);
+        try {
+            const stat = fs.lstatSync(current);
+            if (index === parts.length - 1 || !stat.isDirectory())
+                refuse("unobserved_existing_source");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+    }
+}
+function rootIdentity(baseline) {
+    const value = baseline.snapshot(), actual = fs.lstatSync(value.workspace);
+    if (!actual.isDirectory() || fs.realpathSync(value.workspace) !== value.workspace
+        || actual.dev !== value.workspace_identity.dev || actual.ino !== value.workspace_identity.ino)
+        refuse("workspace_identity_changed");
+    return value;
+}
+/** Before-image evidence, not write approval. Reuses the existing bounded,
+ * private-file-aware source reader. No backup file, Git object, RUN or project
+ * mutation is created; the request/Work owner must retain these bytes first. */
+export class PreparedInteractiveBeforeVersions {
+    sha256;
+    #value;
+    #baseline;
+    #observed;
+    constructor(value, baseline, observed) {
+        if (Buffer.byteLength(JSON.stringify(value)) > 96 * 1024 * 1024)
+            refuse("before_versions_exceed_bound");
+        this.#value = structuredClone(value);
+        this.#baseline = baseline;
+        this.#observed = observed;
+        this.sha256 = createHash("sha256").update(JSON.stringify(value)).digest("hex");
+        Object.freeze(this);
+    }
+    static capture(baseline, paths) {
+        if (!(baseline instanceof PreparedInteractiveGitBaseline) || !Array.isArray(paths) || paths.length > 20_000
+            || paths.some(name => !safe(name)) || new Set(paths).size !== paths.length)
+            refuse("invalid_selected_paths");
+        const source = rootIdentity(baseline), byPath = new Map(source.entries.map(item => [item.path, item]));
+        const entries = [], files = [];
+        for (const name of [...paths].sort()) {
+            const before = byPath.get(name);
+            if (!before || before.kind === "missing") {
+                absent(source.workspace, name);
+                entries.push({ path: name, kind: "missing", mode: null, sha256: null, base64: null });
+            }
+            else {
+                if (before.kind !== "file")
+                    refuse("regular_file_scope_required");
+                const actual = fs.lstatSync(path.join(source.workspace, name));
+                if (!actual.isFile() || actual.nlink !== 1 || (actual.mode & 0o7777) !== before.mode)
+                    refuse("before_version_changed");
+                files.push(name);
+                entries.push({ path: name, kind: "file", mode: before.mode, sha256: before.sha256, base64: null });
+            }
+        }
+        const observed = ObservedMemorySources.capture({ workspace: source.workspace }, files.map(name => ({ root: "workspace", path: name })));
+        const hashes = observed.hashes();
+        for (const item of entries.filter(item => item.kind === "file")) {
+            if (hashes.get(memorySourceKey("workspace", item.path)) !== item.sha256)
+                refuse("before_version_changed");
+            item.base64 = observed.bytes({ root: "workspace", path: item.path }).toString("base64");
+        }
+        const prepared = new PreparedInteractiveBeforeVersions({ schema_id: "dd-flow/interactive-before-versions@1",
+            baseline_sha256: baseline.sha256, workspace: source.workspace, entries }, baseline, observed);
+        prepared.revalidate();
+        return prepared;
+    }
+    snapshot() { return structuredClone(this.#value); }
+    bytes() { return Buffer.from(JSON.stringify(this.#value)); }
+    reference() { return { path: "runtime/before-versions.json", sha256: this.sha256 }; }
+    revalidate() {
+        rootIdentity(this.#baseline);
+        this.#observed.revalidate();
+        for (const item of this.#value.entries) {
+            if (item.kind === "missing")
+                absent(this.#value.workspace, item.path);
+            else {
+                const stat = fs.lstatSync(path.join(this.#value.workspace, item.path));
+                if (!stat.isFile() || stat.nlink !== 1 || (stat.mode & 0o7777) !== item.mode)
+                    refuse("before_version_changed");
+            }
+        }
+    }
+}
+/** Historical parsing against an independently selected retained baseline.
+ * Never re-read the now-edited project to reconstruct its original content. */
+export function restoreInteractiveBeforeVersions(bytes, expectedSha256, baseline) {
+    if (!(baseline instanceof PreparedInteractiveGitBaseline) || !bytes.length || bytes.length > 96 * 1024 * 1024
+        || createHash("sha256").update(bytes).digest("hex") !== expectedSha256)
+        refuse("retained_before_versions_changed");
+    let value;
+    try {
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return refuse("invalid_retained_before_versions");
+    }
+    const original = baseline.snapshot(), byPath = new Map(original.entries.map(item => [item.path, item]));
+    if (!value || Object.keys(value).sort().join() !== "baseline_sha256,entries,schema_id,workspace"
+        || value.schema_id !== "dd-flow/interactive-before-versions@1" || value.baseline_sha256 !== baseline.sha256
+        || value.workspace !== original.workspace || !Array.isArray(value.entries) || value.entries.length > 20_000)
+        refuse("retained_before_scope_changed");
+    let previous = "", total = 0;
+    for (const item of value.entries) {
+        if (!item || Object.keys(item).sort().join() !== "base64,kind,mode,path,sha256" || !safe(item.path) || item.path <= previous)
+            refuse("invalid_retained_before_versions");
+        const before = byPath.get(item.path);
+        if (item.kind === "missing") {
+            if (before && before.kind !== "missing" || item.mode !== null || item.sha256 !== null || item.base64 !== null)
+                refuse("retained_absence_changed");
+        }
+        else {
+            if (item.kind !== "file" || before?.kind !== "file" || item.mode !== before.mode || item.sha256 !== before.sha256 || typeof item.base64 !== "string")
+                refuse("retained_original_changed");
+            const content = Buffer.from(item.base64, "base64");
+            total += content.length;
+            if (content.length > 16 * 1024 * 1024 || total > 64 * 1024 * 1024 || content.toString("base64") !== item.base64
+                || createHash("sha256").update(content).digest("hex") !== before.sha256)
+                refuse("retained_original_changed");
+        }
+        previous = item.path;
+    }
+    return structuredClone(value);
+}

package/dist/services/interactive-bundle-data.js

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+const partLimit = 1024 * 1024, totalLimit = 32 * partLimit;
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function refuse(reason) {
+    throw new AppError("interactive_bundle_data_invalid", "Interactive data must fit the existing retained bundle limits", 2, { reason, effect: "no_effect" });
+}
+function pathFor(logical, ordinal) { return `${logical}.parts/${String(ordinal).padStart(4, "0")}.bin`; }
+function supported(logical) { if (!["runtime/git-baseline.json", "runtime/before-versions.json", "runtime/work-context.json"].includes(logical))
+    refuse("unsupported_data_role"); }
+/** Packaging only, not admission. Keep ordinary small JSON unchanged; large
+ * before-images use explicit immutable parts instead of widening global limits. */
+export function putInteractiveBundleData(blobs, logical, input) {
+    supported(logical);
+    if (!input.length || input.byteLength > totalLimit)
+        refuse("unbounded_data");
+    const bytes = Buffer.from(input), additions = new Map();
+    const sha256 = hash(bytes);
+    if (bytes.length <= partLimit)
+        additions.set(logical, bytes);
+    else {
+        const parts = [];
+        for (let offset = 0; offset < bytes.length; offset += partLimit) {
+            const part = Buffer.from(bytes.subarray(offset, offset + partLimit)), file = pathFor(logical, parts.length);
+            additions.set(file, part);
+            parts.push({ path: file, bytes: part.length, sha256: hash(part) });
+        }
+        const index = { schema_id: "dd-flow/interactive-bundle-parts@1", logical_path: logical, bytes: bytes.length, sha256, parts };
+        additions.set(logical, Buffer.from(JSON.stringify(index)));
+    }
+    const existing = new Set([...blobs.keys()].map(name => name.toLowerCase()));
+    if ([...additions.keys()].some(name => existing.has(name.toLowerCase())))
+        refuse("data_path_collision");
+    const total = [...blobs.values(), ...additions.values()].reduce((sum, value) => sum + value.length, 0);
+    if (total > totalLimit)
+        refuse("bundle_budget_exceeded");
+    for (const [file, content] of additions)
+        blobs.set(file, content);
+    return { sha256, reference: { path: logical, sha256: hash(additions.get(logical)) } };
+}
+/** Reads only the selected inventory, never nearby files or current project
+ * bytes. For multipart data reference hashes the physical index; sha256 hashes
+ * the reconstructed logical data. They intentionally are not interchangeable. */
+export function readInteractiveBundleData(bundle, logical) {
+    supported(logical);
+    const physical = (file) => {
+        const refs = bundle.manifest.inventory.filter(item => item.path === file);
+        if (refs.length !== 1)
+            refuse("data_reference_required");
+        const bytes = bundle.blob(file);
+        if (!bytes.length || bytes.length > partLimit || hash(bytes) !== refs[0].sha256)
+            refuse("data_part_changed");
+        return { bytes, reference: refs[0] };
+    };
+    const root = physical(logical);
+    let value;
+    try {
+        value = JSON.parse(root.bytes.toString("utf8"));
+    }
+    catch {
+        value = null;
+    }
+    if (!value || typeof value !== "object" || value.schema_id !== "dd-flow/interactive-bundle-parts@1")
+        return { ...root, sha256: root.reference.sha256 };
+    const index = value;
+    if (Object.keys(index).sort().join() !== "bytes,logical_path,parts,schema_id,sha256" || index.logical_path !== logical
+        || !Number.isSafeInteger(index.bytes) || index.bytes <= partLimit || index.bytes > totalLimit
+        || typeof index.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(index.sha256) || !Array.isArray(index.parts)
+        || index.parts.length !== Math.ceil(index.bytes / partLimit))
+        refuse("invalid_data_index");
+    const parts = [];
+    for (const [ordinal, part] of index.parts.entries()) {
+        if (!part || Object.keys(part).sort().join() !== "bytes,path,sha256" || part.path !== pathFor(logical, ordinal)
+            || part.bytes !== Math.min(partLimit, index.bytes - ordinal * partLimit))
+            refuse("invalid_data_part");
+        const selected = physical(part.path);
+        if (selected.reference.sha256 !== part.sha256 || selected.bytes.length !== part.bytes)
+            refuse("data_part_changed");
+        parts.push(selected.bytes);
+    }
+    const bytes = Buffer.concat(parts);
+    if (bytes.length !== index.bytes || hash(bytes) !== index.sha256)
+        refuse("logical_data_changed");
+    return { bytes, sha256: index.sha256, reference: root.reference };
+}

package/dist/services/interactive-checks.js

@@ -0,0 +1,179 @@
+import { AppError } from "../shared/errors.js";
+import { hybridDigest } from "./hybrid-contracts.js";
+import { appendAudit } from "./audit.js";
+import { readInteractiveStageScope } from "./interactive-stage-entry.js";
+import { readDescriptorStageInput } from "./descriptor-stage-coordinator.js";
+import { assertPreparedRunBundleSqlAuthority } from "./runs.js";
+import { PreparedInteractiveWorkspaceChanges } from "./interactive-mutation-scope.js";
+import { readInteractiveWorkGit } from "./interactive-work-start.js";
+import { readInteractiveWorkHistory } from "./interactive-work-history.js";
+import { codeCheckProfileHash, projectPolicyCheckDeclarations, runCodeChecks, PreparedCheckEvidence, validateCheckDeclaration } from "./code-checks.js";
+import { memoryCheckEnvironment } from "./memory-verification-checks.js";
+function refuse(reason) {
+    throw new AppError("interactive_checks_invalid", "Interactive checks require retained obligations and the exact current patch", 2, { reason, effect: "no_effect" });
+}
+const event = "interactive.check_plan";
+function latest(context, scope) {
+    const row = context.db.get("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? ORDER BY id DESC LIMIT 1", [scope.projectId, event, scope.runId]);
+    if (!row)
+        return null;
+    if (Buffer.byteLength(row.payload_json) > 1024 * 1024)
+        refuse("unbounded_check_plan");
+    const value = JSON.parse(row.payload_json);
+    if (value.run_id !== scope.runId || value.plan?.run_id !== scope.runId || value.plan.schema_id !== "dd-flow/interactive-check-plan@1"
+        || value.sha256 !== hybridDigest(value.plan) || !Array.isArray(value.plan.checks))
+        refuse("changed_check_plan");
+    return value;
+}
+/** One existing aggregate check runner and receipt store. Selection is retained
+ * before execution, independently of the Stage proposal being assessed. */
+export class PreparedInteractiveChecks {
+    sha256;
+    #selected;
+    #packet;
+    #changes;
+    #history;
+    #plan;
+    #environment;
+    constructor(selected, packet, changes, history, plan, environment) {
+        this.#selected = selected;
+        this.#packet = packet;
+        this.#changes = changes;
+        this.#history = history;
+        this.#plan = structuredClone(plan);
+        this.#environment = environment;
+        this.sha256 = hybridDigest(plan);
+        Object.freeze(this);
+    }
+    static prepare(context, input) {
+        if (context.db.isOwnedWriteTransaction?.())
+            refuse("preparation_outside_writer_required");
+        if (!["hardening", "review"].includes(input.stage) || !Array.isArray(input.additionalChecks) || input.additionalChecks.length > 4096)
+            refuse("invalid_check_selection");
+        const selected = readInteractiveStageScope(context, input), { scope, bundle, run } = selected;
+        const packet = readDescriptorStageInput(context, scope, bundle), frozen = bundle.execution.snapshot().scope, git = readInteractiveWorkGit(bundle);
+        if (!run.run_root)
+            refuse("run_root_required");
+        if (selected.selected.needs_scope_refresh)
+            refuse("current_scope_required");
+        const checks = [...projectPolicyCheckDeclarations(frozen.workspace, "code"), ...projectPolicyCheckDeclarations(frozen.workspace, "readiness")];
+        const ids = new Set(checks.map(check => check.id));
+        for (const extra of input.additionalChecks) {
+            if (!extra || Object.keys(extra).sort().join() !== "command,id,purpose" || typeof extra.id !== "string" || !/^CHK-[A-Za-z0-9-]{1,64}$/.test(extra.id)
+                || ids.has(extra.id) || [extra.command, extra.purpose].some(value => typeof value !== "string" || !value.trim() || value.includes("\0") || Buffer.byteLength(value) > 16384))
+                refuse("invalid_check_selection");
+            ids.add(extra.id);
+            checks.push({ ...extra, source: "plan", availability: "available", run_at: "readiness" });
+        }
+        checks.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        for (const check of checks)
+            validateCheckDeclaration(frozen.workspace, check);
+        if (!checks.length && (typeof input.noChecksReason !== "string" || !input.noChecksReason.trim() || input.noChecksReason.includes("\0") || Buffer.byteLength(input.noChecksReason) > 16384))
+            refuse("explicit_no_checks_reason_required");
+        if (checks.length && input.noChecksReason !== undefined)
+            refuse("no_checks_reason_with_checks");
+        const changes = PreparedInteractiveWorkspaceChanges.prepare(context, scope, bundle, { projectRoot: frozen.projectRoot,
+            workspace: frozen.workspace, gitExecutable: git.git_executable, env: context.env });
+        const plan = { schema_id: "dd-flow/interactive-check-plan@1", run_id: input.runId, stage: input.stage, attempt: packet.attempt,
+            bundle_sha256: bundle.sha256, input_sha256: packet.inputSha256, user_inputs_sha256: selected.selected.inputs.sha256,
+            scope_revision: selected.selected.revision, file_changes_sha256: hybridDigest(changes.snapshot().delta.changes),
+            profile_sha256: codeCheckProfileHash(frozen.workspace, checks), checks, no_checks_reason: checks.length ? null : input.noChecksReason };
+        if (Buffer.byteLength(JSON.stringify({ run_id: plan.run_id, sha256: "a".repeat(64), plan })) > 1024 * 1024)
+            refuse("unbounded_check_plan");
+        const prepared = new PreparedInteractiveChecks(selected, packet, changes, hybridDigest(readInteractiveWorkHistory(context, scope, bundle)), plan, memoryCheckEnvironment(context, scope.projectId, scope.runId));
+        prepared.revalidate(context);
+        return prepared;
+    }
+    static restore(context, input) {
+        const selected = readInteractiveStageScope(context, input), retained = latest(context, selected.scope);
+        if (!retained || retained.plan.stage !== input.stage)
+            refuse("retained_check_plan_required");
+        const prepared = this.prepare(context, { ...input, additionalChecks: retained.plan.checks.filter(check => check.source === "plan")
+                .map(({ id, command, purpose }) => ({ id, command, purpose })),
+            ...(retained.plan.no_checks_reason === null ? {} : { noChecksReason: retained.plan.no_checks_reason }) });
+        if (prepared.sha256 !== retained.sha256)
+            refuse("retained_check_plan_changed");
+        return prepared;
+    }
+    /** Carry declared obligations into the initial critic's current Stage. The
+     * common evidence owner still rejects changed task/patch/policy or missing
+     * receipts; this does not execute or bless an author's test claims. */
+    static prepareReview(context, input) {
+        const selected = readInteractiveStageScope(context, { ...input, stage: "review" }), retained = latest(context, selected.scope);
+        if (!retained)
+            return null;
+        return this.prepare(context, { ...input, stage: "review", additionalChecks: retained.plan.checks.filter(check => check.source === "plan")
+                .map(({ id, command, purpose }) => ({ id, command, purpose })),
+            ...(retained.plan.no_checks_reason === null ? {} : { noChecksReason: retained.plan.no_checks_reason }) });
+    }
+    value() { return structuredClone(this.#plan); }
+    checkInput() {
+        const { bundle_sha256, user_inputs_sha256, scope_revision, file_changes_sha256, profile_sha256, checks } = this.#plan;
+        return { projectId: this.#selected.scope.projectId, runId: this.#plan.run_id, runHome: this.#packet.runRoot,
+            workspaceRoot: this.#selected.bundle.execution.snapshot().scope.workspace, scope: "aggregate",
+            checks: structuredClone(checks), expectedProfileHash: profile_sha256,
+            // Stage custody changes do not by themselves invalidate checks of the
+            // same task/patch/policy. The common runner still owns reuse eligibility.
+            evidenceContext: `interactive:${hybridDigest({ bundle_sha256, user_inputs_sha256, scope_revision, file_changes_sha256, profile_sha256, checks })}`,
+            artifactDir: `${this.#selected.bundle.descriptor.stage(this.#plan.stage).directory}/checks/${this.sha256}`,
+            ...(this.#environment ? { checkEnvironment: this.#environment } : {}) };
+    }
+    assertSelection(context) {
+        this.#selected.assertCustody(context);
+        const { scope, bundle } = this.#selected, run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
+        if (run.status !== "running" || index.current_stage !== this.#plan.stage
+            || hybridDigest(readDescriptorStageInput(context, scope, bundle)) !== hybridDigest(this.#packet)
+            || hybridDigest(readInteractiveWorkHistory(context, scope, bundle)) !== this.#history)
+            refuse("check_selection_changed");
+        const previous = latest(context, scope);
+        if (previous && previous.plan.user_inputs_sha256 === this.#plan.user_inputs_sha256
+            && previous.plan.checks.some(check => !this.#plan.checks.some(current => hybridDigest(current) === hybridDigest(check))))
+            refuse("check_obligation_dropped");
+    }
+    revalidate(context) {
+        this.#changes.revalidate();
+        readInteractiveWorkGit(this.#selected.bundle);
+        if (codeCheckProfileHash(this.checkInput().workspaceRoot, this.#plan.checks) !== this.#plan.profile_sha256
+            || hybridDigest(memoryCheckEnvironment(context, this.#selected.scope.projectId, this.#plan.run_id) ?? null) !== hybridDigest(this.#environment ?? null))
+            refuse("check_policy_changed");
+        context.db.readSnapshot(() => this.assertSelection(context));
+    }
+    retain(context) {
+        this.revalidate(context);
+        return context.db.writeTransaction(() => {
+            this.#changes.assertCustody(context);
+            this.assertSelection(context);
+            if (latest(context, this.#selected.scope)?.sha256 === this.sha256)
+                return { changed: false };
+            appendAudit(context, { projectId: this.#selected.scope.projectId, eventType: event, payload: { run_id: this.#plan.run_id, sha256: this.sha256, plan: this.value() } });
+            return { changed: true };
+        });
+    }
+    assertCustody(context) {
+        this.#changes.assertCustody(context);
+        this.assertSelection(context);
+        if (latest(context, this.#selected.scope)?.sha256 !== this.sha256)
+            refuse("retained_check_plan_required");
+    }
+    async execute(context) {
+        this.retain(context);
+        if (!this.#plan.checks.length)
+            return [];
+        const receipts = await runCodeChecks(context, this.checkInput());
+        try {
+            this.revalidate(context);
+        }
+        catch (error) {
+            if (error instanceof AppError)
+                error.details.effect = "committed";
+            throw error;
+        }
+        return receipts;
+    }
+    evidence(context) {
+        this.revalidate(context);
+        if (latest(context, this.#selected.scope)?.sha256 !== this.sha256)
+            refuse("retained_check_plan_required");
+        return this.#plan.checks.length ? PreparedCheckEvidence.prepare(context, this.checkInput()) : null;
+    }
+}

package/dist/services/interactive-execution.js

@@ -0,0 +1,33 @@
+import { AppError } from "../shared/errors.js";
+import { FrozenGenericExecution } from "./generic-execution.js";
+import { PreparedInteractiveAttachedSession } from "./interactive-attached-session.js";
+import { prepareOperatorProfile, resolveOperatorProfile } from "./operator-profiles.js";
+/** Fresh interactive selection only; continuation restores the retained bundle
+ * rather than re-reading current defaults or claiming a different Session. */
+export function prepareInteractiveExecution(context, input) {
+    const { scope, flow, profiles, selection } = input;
+    if (flow.descriptor.id !== "interactive" || Object.hasOwn(selection, "attachedSessionReceipt")) {
+        throw new AppError("interactive_execution_invalid", "Interactive execution must use its registered flow and CLI-owned Session binding", 2, { effect: "no_effect" });
+    }
+    const mode = selection.execution ?? "attached";
+    const stageSessionMode = selection.stageSessionMode ?? (mode === "attached" ? "same_session" : "new_session");
+    let attached = null;
+    let receipts = new Map();
+    const receiptBytes = new Map();
+    if (mode === "attached") {
+        if (!input.source && !input.launchArgs)
+            throw new AppError("interactive_attached_session_required", "Interactive defaults to the current trusted Session; select managed execution explicitly when unavailable", 2, { phase: "prepare", effect: "no_effect", next_action: "provide_matching_attached_session_or_choose_managed" });
+        if (stageSessionMode !== "same_session")
+            throw new AppError("interactive_execution_invalid", "An attached root cannot claim a new physical Session per Stage; choose managed execution for that route", 2, { effect: "no_effect" });
+        const profile = prepareOperatorProfile(typeof selection.rootProfile === "object" ? selection.rootProfile : resolveOperatorProfile(profiles, selection.rootProfile));
+        attached = input.source ? PreparedInteractiveAttachedSession.prepare(context, scope, profile, input.source)
+            : PreparedInteractiveAttachedSession.prepareCurrent(context, scope, profile, input.launchArgs);
+        const evidence = attached.evidence();
+        receipts = evidence.receipts;
+        receiptBytes.set(evidence.reference.sha256, evidence.bytes);
+    }
+    const execution = FrozenGenericExecution.prepare(flow, profiles, { ...selection, execution: mode,
+        stageSessionMode, delegation: selection.delegation ?? { mode: "external", max_parallel: 1 },
+        ...(attached ? { attachedSessionReceipt: attached.evidence().reference } : {}) }, scope, receipts);
+    return { execution, attached, receipts, receiptBytes };
+}