agentfootprint 9.136.0 → 9.138.0

package/dist/esm/lib/trace-toolpack/traceToolpack.js

@@ -40,7 +40,9 @@ import { defineTool } from '../../core/tools.js';
 import { unconfiguredCredentialProvider } from '../../identity/types.js';
 import { unconfiguredArtifacts } from '../../artifacts/capability.js';
 import { boundedPreview, clampParam, displayKey, displayText, normalizeKey, renderPreview, safeStringify, } from './bounded.js';
+import { askInner, framed, innerPackSlot } from './innerDescent.js';
 import { openRecording } from './openRecording.js';
+import { homeMountOf, innerCommitCount, mountChain, openSubflow, opensWithSeed, subflowResultsOf, subflowWrote, } from './subflowRecords.js';
 import { resolveToolpackOptions, TOOLPACK_HARD_CAPS, } from './types.js';
 // ── Display caps that are structural (not consumer-tunable) ───────────────
 const OVERVIEW_STAGE_CAP = 40;
@@ -81,6 +83,12 @@ const TOOL_RESULT_PREVIEW_CHARS = 400;
 /** Schemas embed an `enum` of valid ids/keys only when the set is small —
  *  free #9 validation without bloating the tools block on long runs. */
 const SCHEMA_ENUM_CAP = 48;
+/**
+ * Artifact bags whose pack must not name `inspect_subflow` — the inner packs
+ * `inspect_tool_run` opens. Module-private on purpose: not an option a
+ * consumer sets, a fact about how the pack is reached.
+ */
+const WITHOUT_SUBFLOW_DOOR = new WeakSet();
 function stagePartOf(runtimeStageId) {
     const hash = runtimeStageId.lastIndexOf('#');
     return hash > 0 ? runtimeStageId.slice(0, hash) : runtimeStageId;
@@ -109,6 +117,9 @@ function buildIndex(artifacts) {
         for (const entry of bundle.trace)
             knownPaths.add(entry.path);
     }
+    const subflowDoor = !WITHOUT_SUBFLOW_DOOR.has(artifacts);
+    const subflowResults = subflowDoor ? subflowResultsOf(artifacts.snapshot) : undefined;
+    const homes = new Map();
     // Walk the execution tree: node → children → next (≈ execution order).
     const nodes = new Map();
     const orderedIds = [];
@@ -132,11 +143,20 @@ function buildIndex(artifacts) {
         visit(node.next);
     };
     visit(artifacts.snapshot.executionTree);
-    // Steps present in the commit log but missing from the tree (defensive).
+    // Steps present in the commit log but missing from the tree. A subflow's own
+    // log opens with its MOUNT's seed commit, which its tree does not hold — so
+    // an id that committed before the tree's first step goes FIRST, not last.
+    const treeFirstIdx = firstIdxOf.get(orderedIds[0] ?? '') ?? Infinity;
+    const before = [];
     for (const id of bundlesOf.keys()) {
-        if (!nodes.has(id))
+        if (nodes.has(id))
+            continue;
+        if ((firstIdxOf.get(id) ?? Infinity) < treeFirstIdx)
+            before.push(id);
+        else
             orderedIds.push(id);
     }
+    orderedIds.unshift(...before);
     const idsByStagePart = new Map();
     const groupsByStagePart = new Map();
     const groups = [];
@@ -189,10 +209,22 @@ function buildIndex(artifacts) {
         untrackedStepCount,
         initialState: artifacts.snapshot.initialState,
         explained: new Set(),
+        subflowResults,
+        subflowDoor,
+        homeMountOf: (id) => {
+            if (subflowResults === undefined)
+                return undefined;
+            if (!homes.has(id))
+                homes.set(id, homeMountOf(subflowResults, id));
+            return homes.get(id);
+        },
     };
 }
 // ── Shared message helpers ─────────────────────────────────────────────────
 function unknownIdMessage(id, index) {
+    const home = index.homeMountOf(id);
+    if (home !== undefined)
+        return innerIdMessage(id, home);
     const stagePart = stagePartOf(id);
     const siblings = index.idsByStagePart.get(stagePart);
     if (siblings && siblings.length > 0) {
@@ -208,6 +240,17 @@ function unknownIdMessage(id, index) {
             : '') +
         `. Call run_overview to list every stage.`);
 }
+/** An id from a subflow's OWN log, pasted into a tool over the log above it. */
+function innerIdMessage(id, mount) {
+    return (`'${id}' is a step INSIDE subflow mount ${mount} — an id of that subflow's own log, not ` +
+        `of this one. Open it there: inspect_subflow({ mount: '${mount}', runtimeStageId: '${id}' }).`);
+}
+/** The one line a subflow mount carries: it can be opened, and how. */
+function mountLine(index, id) {
+    return index.subflowResults !== undefined && id in index.subflowResults
+        ? `inside: inspect_subflow({ mount: '${id}' }) opens this subflow's own log.`
+        : `inside: no own log kept for this mount — inspect_subflow({ mount: '${id}' }) says why.`;
+}
 function unknownKeySuffix(index) {
     if (index.knownPaths.size === 0)
         return '';
@@ -298,6 +341,7 @@ function matchWindow(text, needleLower, radius) {
  * | `get_value`         | The full value of K as of step X (capped, truncation-marked) |
  * | `inspect_tool_call` | One tool call end to end: proposed args → ran-with args → result → outcome |
  * | `inspect_tool_run`  | INSIDE one tool call — the chart it ran, when that tool kept its record |
+ * | `inspect_subflow`   | INSIDE one subflow mount — the subflow's own log, one level at a time |
  * | `read_narrative`    | The human-readable story, paginated (only when narrative provided) |
  *
  * Mount on an Agent (`Agent.create({...}).tool(...tools)`) or drive scripted
@@ -330,6 +374,7 @@ export function traceToolpack(artifacts, options) {
         buildGetValue(index, opts),
         buildInspectToolCall(artifacts, calls),
         buildInspectToolRun(artifacts, calls, options),
+        buildInspectSubflow(artifacts, index, options),
     ];
     if (artifacts.narrative !== undefined) {
         tools.push(buildReadNarrative(artifacts.narrative));
@@ -346,11 +391,21 @@ export { TRACE_TOOL_NAMES } from './traceToolNames.js';
 // ── Schema fragments ───────────────────────────────────────────────────────
 function idProperty(index, description) {
     const property = { type: 'string', description };
-    if (index.orderedIds.length > 0 && index.orderedIds.length <= SCHEMA_ENUM_CAP) {
+    // No enum when subflows kept their own logs: the model may then hold an
+    // INNER id, and it is owed the correction toward `inspect_subflow` that only
+    // `execute` can give — a schema refusal would read as "no such step".
+    if (index.orderedIds.length > 0 &&
+        index.orderedIds.length <= SCHEMA_ENUM_CAP &&
+        !hasMountLogs(index)) {
         property.enum = index.orderedIds;
     }
     return property;
 }
+/** True when at least one subflow mount kept its own log in this snapshot. */
+function hasMountLogs(index) {
+    const results = index.subflowResults;
+    return (results !== undefined && Object.keys(results).some((key) => innerCommitCount(results, key) > 0));
+}
 /**
  * Key params get guidance (known keys in the description) but NO enum:
  * unlike step ids — whose universe is complete — a key OUTSIDE the commit
@@ -365,6 +420,23 @@ function keyProperty(index, description) {
     return { type: 'string', description: `${description}${hint}` };
 }
 // ── run_overview ───────────────────────────────────────────────────────────
+/**
+ * ONE line, only when the run mounted subflows: their inner steps are not in
+ * this log, and here is the door. By reference — nothing from inside a
+ * subflow is printed until the model asks for it.
+ */
+function overviewSubflowLine(index) {
+    if (!index.subflowDoor)
+        return undefined;
+    const mounts = index.groups.filter((group) => group.isSubflow).flatMap((group) => group.ids);
+    if (mounts.length === 0)
+        return undefined;
+    const results = index.subflowResults;
+    const openable = mounts.find((id) => results !== undefined && id in results);
+    return openable !== undefined
+        ? `[subflow] steps ran their own log: inspect_subflow({ mount: '${openable}' }) opens one.`
+        : `[subflow] steps kept no own log here — inspect_subflow({ mount }) says why.`;
+}
 function buildRunOverview(artifacts, index) {
     return defineTool({
         name: 'run_overview',
@@ -401,6 +473,9 @@ function buildRunOverview(artifacts, index) {
             if (index.groups.length > OVERVIEW_STAGE_CAP) {
                 lines.push(`…and ${index.groups.length - OVERVIEW_STAGE_CAP} more stages (output capped)`);
             }
+            const subflowHint = overviewSubflowLine(index);
+            if (subflowHint !== undefined)
+                lines.push(subflowHint);
             const loops = index.groups.filter((g) => g.ids.length > 1);
             if (loops.length > 0) {
                 const top = [...loops]
@@ -1158,6 +1233,8 @@ function buildTraceNode(artifacts, index, opts) {
             lines.push(`STEP ${runtimeStageId} — "${name}"${flags}`);
             if (node?.description)
                 lines.push(`description: ${node.description}`);
+            if (node?.subflowId && index.subflowDoor)
+                lines.push(mountLine(index, runtimeStageId));
             // Writes — verb-aware values via commitValueAt (delta-mode safe).
             const writes = new Map(); // path → verb (last wins)
             for (const bundle of bundles ?? []) {
@@ -1484,7 +1561,8 @@ function buildWhoWrote(index, opts) {
                     (beforeStageId !== undefined ? ` before ${beforeStageId}` : '') +
                     ` in the commit log.` +
                     (index.knownPaths.has(path) ? '' : unknownKeySuffix(index)) +
-                    basisLines(index, basis));
+                    basisLines(index, basis) +
+                    writtenInsideLine(index, path, beforeIdx));
             }
             const writerIdx = index.commitLog.indexOf(writer);
             const verb = writer.trace.find((entry) => entry.path === path)?.verb ?? 'set';
@@ -1498,10 +1576,49 @@ function buildWhoWrote(index, opts) {
                 basisLines(index, [...basis, ...read.basis]) +
                 (untracked.length > 0
                     ? `\n⚠ that step also consumed ${untracked.join('/')}. ${honestyLine(index, 'incomplete-sources')}`
-                    : ''));
+                    : '') +
+                mergeBackLine(index, writer.runtimeStageId, path));
         },
     });
 }
+/**
+ * A write by a subflow MOUNT is its merge-back: the value was made inside. One
+ * line names the question that reaches the inner writer; '' otherwise.
+ */
+function mergeBackLine(index, writerId, path) {
+    if (!index.subflowDoor || index.nodes.get(writerId)?.subflowId === undefined)
+        return '';
+    // The outputMapper may rename or compute the key: claim a writer inside only
+    // when the mount's own log wrote this very path. Otherwise name the mount.
+    if (!subflowWrote(index.subflowResults?.[writerId], path)) {
+        return `\n↳ ${writerId} is a subflow mount — ${mountLine(index, writerId)}`;
+    }
+    return (`\n↳ ${writerId} is a subflow mount — this write is its merge-back. ` +
+        `inspect_subflow({ mount: '${writerId}', key: '${displayKey(path)}' }) names the writer ` +
+        `inside.`);
+}
+/**
+ * A key this log never wrote may still be written INSIDE a subflow mounted at
+ * this level — its own log never merged it back. One line naming the latest
+ * such mount; '' when none did (asked only on a miss).
+ */
+function writtenInsideLine(index, path, beforeIdx) {
+    const results = index.subflowResults;
+    if (!index.subflowDoor || results === undefined)
+        return '';
+    // Only mounts that ran BEFORE the anchor answer "who wrote it before X".
+    const mounts = [...index.orderedIds]
+        .reverse()
+        .filter((id) => index.nodes.get(id)?.subflowId !== undefined)
+        .filter((id) => beforeIdx === undefined || (index.lastIdxOf.get(id) ?? Infinity) < beforeIdx);
+    const inside = mounts.find((id) => subflowWrote(results[id], path));
+    if (inside === undefined)
+        return '';
+    // "Not merged back" is a claim about THIS log: true only if it never wrote the key.
+    const where = index.knownPaths.has(path) ? '' : ' (not merged back here)';
+    return (`\n↳ but subflow ${inside} wrote '${displayKey(path)}' in its OWN log${where}: ` +
+        `inspect_subflow({ mount: '${inside}', key: '${displayKey(path)}' }) names the writer.`);
+}
 // ── get_value ──────────────────────────────────────────────────────────────
 function buildGetValue(index, opts) {
     return defineTool({
@@ -1967,23 +2084,18 @@ function buildInspectToolCall(artifacts, reader) {
  *     that just says "nothing" teaches the model the tool is broken.
  */
 function buildInspectToolRun(artifacts, reader, options) {
-    // One inner pack at a time, memoized by call id: three drills into one
-    // inner run build one index, and the memo pins at most ONE inner run's
-    // index beyond the record the store is already holding.
-    let memoId;
-    let memoTools;
-    const innerToolsFor = (record) => {
-        if (memoTools !== undefined && memoId === record.toolCallId)
-            return memoTools;
+    // One inner pack at a time, memoized by call id (`innerDescent`): three
+    // drills into one inner run build one index.
+    const slot = innerPackSlot((inner) => traceToolpack(inner, options));
+    const openRecord = (record) => {
         if (record.recording === undefined) {
             return (`tool call '${record.toolCallId}' ran '${record.toolName}', which keeps records — but ` +
                 `THIS one could not be captured: ${record.problem ?? 'reason not recorded'}. The call ` +
                 `itself was unaffected; inspect_tool_call('${record.toolCallId}') still has the ` +
                 `envelope (arguments in, result out).`);
         }
-        let inner;
         try {
-            inner = {
+            const inner = {
                 // `openRecording` is the adapter, not a copy of it: same lift, same
                 // two teaching refusals if the bag is malformed. The two fields it
                 // cannot lift from JSON — control edges, and a narrative nobody
@@ -1992,14 +2104,13 @@ function buildInspectToolRun(artifacts, reader, options) {
                 ...(record.controlDeps !== undefined && { controlDeps: record.controlDeps }),
                 ...(record.narrative !== undefined && { narrative: record.narrative }),
             };
+            WITHOUT_SUBFLOW_DOOR.add(inner);
+            return inner;
         }
         catch (e) {
             return (`the retained record for '${record.toolCallId}' could not be opened: ` +
                 `${e instanceof Error ? e.message : String(e)}`);
         }
-        memoId = record.toolCallId;
-        memoTools = traceToolpack(inner, options);
-        return memoTools;
     };
     return defineTool({
         name: 'inspect_tool_run',
@@ -2007,8 +2118,8 @@ function buildInspectToolRun(artifacts, reader, options) {
             'record of what they ran; this opens it. Called with just a toolCallId it returns a ' +
             'bounded overview of the inner run (its stages, its errors, its state keys). Add ' +
             "'find' to search that inner run in free text, 'variable' to ask why an inner value is " +
-            "what it is, 'runtimeStageId' to open one inner step, or both 'runtimeStageId' and " +
-            "'key' for an inner value in full. The ids it returns are the INNER chart's — the " +
+            "what it is, 'key' alone for who last wrote an inner key, 'runtimeStageId' to open one " +
+            "inner step, or both 'runtimeStageId' and 'key' for an inner value in full. The ids it returns are the INNER chart's — the " +
             'outer trace tools do not accept them. Reach for it when inspect_tool_call says a ' +
             'record was kept and the question is about what the tool DID, not what it returned.',
         inputSchema: {
@@ -2025,7 +2136,8 @@ function buildInspectToolRun(artifacts, reader, options) {
                 },
                 key: {
                     type: 'string',
-                    description: "Optional, with runtimeStageId: the inner state key to fetch in full, e.g. 'forecast'.",
+                    description: "Optional: an inner state key, e.g. 'forecast' — alone, who last wrote it inside; " +
+                        'with runtimeStageId, its value in full as of that step.',
                 },
                 variable: {
                     type: 'string',
@@ -2047,49 +2159,163 @@ function buildInspectToolRun(artifacts, reader, options) {
             const record = lookup.get(toolCallId);
             if (record === undefined)
                 return unknownInnerRunMessage(toolCallId, lookup, reader);
-            const inner = innerToolsFor(record);
+            const inner = slot(record.toolCallId, () => openRecord(record));
             if (typeof inner === 'string')
                 return inner;
-            // Param-shaped dispatch (the `backtrack({ element })` precedent): the
-            // narrowest question the caller asked wins, and the default — no
-            // extra params at all — is the entry point, exactly as run_overview
-            // is the entry point one level up.
-            let body;
-            if (find !== undefined) {
-                body = await callTraceTool(inner, 'find_in_trace', { query: find });
-            }
-            else if (variable !== undefined) {
-                body = await callTraceTool(inner, 'backtrack', { variable });
-            }
-            else if (runtimeStageId !== undefined && key !== undefined) {
-                body = await callTraceTool(inner, 'get_value', { runtimeStageId, key });
-            }
-            else if (runtimeStageId !== undefined) {
-                body = await callTraceTool(inner, 'trace_node', { runtimeStageId });
-            }
-            else if (key !== undefined) {
-                body =
-                    `'key' names a value AS OF a step, so it needs a step: pass runtimeStageId too, or ` +
-                        `use 'variable' to ask why '${displayKey(key)}' is what it is across the whole inner ` +
-                        `run.`;
-            }
-            else {
-                body = await callTraceTool(inner, 'run_overview', {});
-            }
-            return [
-                `INSIDE TOOL CALL ${toolCallId} — '${record.toolName}' ran a recorded flowchart ` +
+            const body = await askInner(inner, { runtimeStageId, key, variable, find }, callTraceTool);
+            return framed({
+                header: `INSIDE TOOL CALL ${toolCallId} — '${record.toolName}' ran a recorded flowchart ` +
                     `(${record.steps} committed step(s), ${record.outcome}).`,
-                body,
-                `next inside call '${toolCallId}': inspect_tool_run({ toolCallId: '${toolCallId}', ` +
+                next: `next inside call '${toolCallId}': inspect_tool_run({ toolCallId: '${toolCallId}', ` +
                     `runtimeStageId: '<inner id>' }) opens a step · add 'key' for a value in full · ` +
                     `'variable' asks why an inner value is what it is · 'find' searches this inner run.`,
-                `⚠ the ids above are INNER ids — they name steps of ${record.toolName}'s own chart, not ` +
-                    `of the run that called it. trace_node / get_value / trace_slice do not accept them; ` +
-                    `come back through inspect_tool_run.`,
-            ].join('\n');
+                namespace: `⚠ the ids above are INNER ids — they name steps of ${record.toolName}'s own chart, ` +
+                    `not of the run that called it. trace_node / get_value / trace_slice do not accept ` +
+                    `them; come back through inspect_tool_run.`,
+            }, body);
+        },
+    });
+}
+// ── inspect_subflow ────────────────────────────────────────────────────────
+/** How many mounts a correction names. */
+const MOUNT_SUGGESTION_CAP = 8;
+/**
+ * INSIDE a subflow mount — the subflow's OWN log, opened.
+ *
+ * A subflow runs in an isolated runtime and commits to its own log, so this
+ * run's log holds only the mount boundary: what went in, what came back. The
+ * evidence of who wrote a value IN there was always recorded (footprintjs keeps
+ * it in `subflowResults`) — no tool served it. This one does, through the same
+ * descent `inspect_tool_run` uses (`innerDescent`): the inner views are the
+ * pack's own tools over the mount's own record, so the inner answers carry the
+ * same reason codes, folded from the SUBFLOW's own `initialState`.
+ *
+ *   - BY REFERENCE. Nothing from inside a subflow is printed until the model
+ *     asks; the outer views carry one line naming the door.
+ *   - ONE LEVEL AT A TIME. A mount nested inside a subflow is opened through
+ *     its parent's pack — this tool walks the chain (`mountChain`), each level
+ *     answering only for its own log.
+ *   - ITS OWN NAMESPACE. Inner ids are said to be inner on every answer, and
+ *     an outer tool handed one corrects toward here (`innerIdMessage`).
+ */
+function buildInspectSubflow(artifacts, index, options) {
+    const slot = innerPackSlot((inner) => traceToolpack(inner, options));
+    const isStep = (id) => index.nodes.has(id) || index.firstIdxOf.has(id);
+    const mountIds = () => index.orderedIds.filter((id) => index.nodes.get(id)?.subflowId);
+    const notAMount = (mount) => {
+        if (isStep(mount)) {
+            return `'${mount}' is an outer step, not a subflow mount — trace_node('${mount}') opens it.`;
+        }
+        const mounts = mountIds();
+        const sameStage = mounts.filter((id) => stagePartOf(id) === mount);
+        if (sameStage.length > 0) {
+            return (`'${mount}' ran ${sameStage.length} time(s); a mount is ONE execution: ` +
+                `${sameStage.slice(0, MOUNT_SUGGESTION_CAP).join(', ')}` +
+                `${sameStage.length > MOUNT_SUGGESTION_CAP ? ', …' : ''}. Retry with one of those ids.`);
+        }
+        if (mounts.length === 0)
+            return `the traced run mounted no subflows — there is no inner log to open.`;
+        return (`unknown mount '${mount}'. Subflow mounts in the traced run: ` +
+            `${mounts.slice(0, MOUNT_SUGGESTION_CAP).join(', ')}` +
+            `${mounts.length > MOUNT_SUGGESTION_CAP ? ', …' : ''}.`);
+    };
+    return defineTool({
+        name: 'inspect_subflow',
+        description: "Open a [subflow] step's OWN log (the run's log holds only its boundary). Mount id alone: " +
+            "inner overview. 'key': its last writer inside. 'variable': why it is what it is. " +
+            "'find': search. 'runtimeStageId' (+'key'): one inner step (value). Inner ids go back here.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                mount: { type: 'string', description: "The mount step, e.g. 'sf-tools#11'." },
+                runtimeStageId: { type: 'string', description: 'Optional: an inner step id.' },
+                key: { type: 'string', description: 'Optional: an inner state key.' },
+                variable: { type: 'string', description: 'Optional: an inner state key to explain.' },
+                find: { type: 'string', description: 'Optional: free text to locate inside.' },
+            },
+            required: ['mount'],
+            additionalProperties: false,
+        },
+        execute: async ({ mount, runtimeStageId, key, variable, find }) => {
+            const question = { runtimeStageId, key, variable, find };
+            const results = index.subflowResults;
+            const isMount = index.nodes.get(mount)?.subflowId !== undefined;
+            // A mount nested below this level: open its parent here, ask there.
+            if (!isMount && !isStep(mount) && results !== undefined) {
+                const chain = mountChain(results, mount, isStep);
+                if (chain !== undefined && chain.length > 1) {
+                    const parent = chain[0];
+                    const pack = slot(parent, () => openSubflowArtifacts(artifacts, parent));
+                    if (typeof pack === 'string')
+                        return pack;
+                    return callTraceTool(pack, 'inspect_subflow', { mount, ...definedOf(question) });
+                }
+            }
+            if (!isMount)
+                return notAMount(mount);
+            if (runtimeStageId !== undefined &&
+                runtimeStageId !== mount &&
+                isStep(runtimeStageId) &&
+                index.homeMountOf(runtimeStageId) !== mount) {
+                return (`'${runtimeStageId}' is a step of the run ABOVE subflow ${mount}, not of its own log — ` +
+                    `trace_node('${runtimeStageId}') opens it there.`);
+            }
+            const inner = slot(mount, () => openSubflowArtifacts(artifacts, mount));
+            if (typeof inner === 'string')
+                return inner;
+            const body = await askInner(inner, question, callTraceTool);
+            const name = index.nodes.get(mount)?.name;
+            const parent = index.homeMountOf(mount);
+            const commits = innerCommitCount(index.subflowResults, mount);
+            return framed({
+                header: `INSIDE SUBFLOW ${mount}${name !== undefined ? ` — "${name}"` : ''}` +
+                    `${parent !== undefined ? ` (nested in ${parent})` : ''}: its own log, ` +
+                    `${commits} commit(s)${opensWithSeed(index.subflowResults, mount) ? ", the mount's seed first" : ''}.`,
+                next: `next inside '${mount}': inspect_subflow({ mount: '${mount}', runtimeStageId: ` +
+                    `'<inner id>' }) opens a step · 'key' alone names its last writer inside · 'variable' ` +
+                    `asks why an inner value is what it is · 'find' searches this inner log.`,
+                namespace: `⚠ the ids above are INNER ids — steps of subflow ${mount}'s own log, not of the run ` +
+                    `that mounted it. trace_node / get_value / trace_slice correct them back here.`,
+            }, body);
         },
     });
 }
+/**
+ * The run's own control-dependence lookup, keyed by every subflow bag opened
+ * below it — so each level filters the RUN's edges to its own log
+ * (`openSubflowArtifacts`), at any depth.
+ */
+const RAW_CONTROL_DEPS = new WeakMap();
+/** The mount's record as an artifact bag, or why there is none. */
+function openSubflowArtifacts(artifacts, mount) {
+    const opened = openSubflow(artifacts.snapshot, mount);
+    if (typeof opened === 'string')
+        return `inspect_subflow: ${opened}`;
+    // Step ids are unique across a run, so the RUN's lookup answers inner ids —
+    // but a decider OUTSIDE this log is not an inner step: keep only edges from
+    // a decider in the mount's own log, so no outer id is served as an inner one.
+    // Always filter the run's RAW lookup, never this level's filtered one: a
+    // nested mount's deciders are not in its parent's log, so filtering the
+    // parent's view would drop every edge one level further down.
+    const raw = RAW_CONTROL_DEPS.get(artifacts) ?? artifacts.controlDeps;
+    const innerIds = new Set(opened.commitLog.map((bundle) => bundle.runtimeStageId));
+    const bag = {
+        snapshot: opened,
+        ...(raw !== undefined && {
+            controlDeps: (id) => {
+                const dep = raw(id);
+                return dep !== undefined && innerIds.has(dep.deciderId) ? dep : undefined;
+            },
+        }),
+    };
+    if (raw !== undefined)
+        RAW_CONTROL_DEPS.set(bag, raw);
+    return bag;
+}
+/** The question's params that were actually given (strict schemas refuse `undefined`). */
+function definedOf(question) {
+    return Object.fromEntries(Object.entries(question).filter((entry) => entry[1] !== undefined));
+}
 /** No tool in this run keeps a record — name the switch, not the emptiness. */
 function noInnerRecordsMessage(toolCallId) {
     return (`inspect_tool_run: nothing in this run kept a record below the tool boundary, so there is ` +