@reticlehq/server 3.5.0 → 3.7.0

package/dist/language/flows/flow-tools.js

@@ -1,19 +1,24 @@
+import { CALL_SECRETS_ARG, callSecretsArg } from './fields/flow-secret-field.js';
 import { flowAuthor } from './flow-author.js';
 import { FLOW_MUTATE_TOOL } from './flow-mutate-tools.js';
-import { seedSchema } from '../../surface/tools/args/numeric-bounds.js';
+import { seedSchema, workerCountSchema } from '../../surface/tools/args/numeric-bounds.js';
+import { confirmDangerousArg } from '../../surface/tools/args/confirm-dangerous-arg.js';
 import { z } from 'zod';
 import { emptyFlowRefusal } from './empty-flow.js';
-import { aliasParam } from '../../surface/tools/args/alias-args.js';
+import { aliasParam, aliasUsed } from '../../surface/tools/args/alias-args.js';
+import { stillRecording, stillRecordingMessage } from './flow-result.js';
+import { resolveAnnotateTarget } from './annotate-notes/annotate-target.js';
 import { FlowErrorCode, RecordedSaveError, ReplayStatus, SuiteIsolation, } from '@reticlehq/core';
 import { recordSuiteFlakes } from './suite/suite-flakes.js';
-import { ReticleTool } from '@reticlehq/core';
-import { asNumber, asString, mutationTargetsFor, perturbationFor } from '@reticlehq/core';
-import { workerCountSchema } from '../../surface/tools/args/numeric-bounds.js';
+import { AppRuntime, ReticleTool } from '@reticlehq/core';
+import { asNumber, asString } from '@reticlehq/core';
 import { log } from '../../log.js';
 import { cloudFetch, syncFlowToCloud, SyncOutcome } from '../../memory/cloud/cloud-sync.js';
 import { mapWithConcurrency, resolveConcurrency } from './suite/parallel-suite.js';
-import { acquireLeasedSession, sessionPerturbationPort, suiteFixtureSeed, } from '../../surface/tools/lease-tools.js';
+import { acquireLeasedSession, suiteFixtureSeed } from '../../surface/tools/lease-tools.js';
 import { homedir } from 'node:os';
+import { withShotRun } from '../../judgement/runs/default-run-id.js';
+import { defaultRunId } from '../../judgement/runs/default-run-id.js';
 import { resolveProjectCloud } from '../../memory/cloud/cloud-config.js';
 import { buildSuiteVerdict } from './decision.js';
 import { classifyFlowAssertions, flattenSteps } from './flow-classify.js';
@@ -21,12 +26,15 @@ import { recordingBacktrackWarning } from './recording/recording-backtrack.js';
 import { isValidFlowName, flowPath } from '../../memory/project/dir/reticle-dir.js';
 import {} from './flows.js';
 import { flowsForSession } from './flow-store-for-session.js';
-import { rootForProjectId } from '../../memory/project/session-root.js';
+import { rootForTarget, sessionTarget } from '../../memory/project/session-root.js';
+import { originOf } from '../../portal/session/session-manager.js';
 import { resolveSuiteSelection } from './suite-selection.js';
-import { replayNamedFlow, flowErrorMessage, latestRecordedFlow, sessionProjectId, } from './flow-replay-run.js';
+import { flowErrorMessage, latestRecordedFlow, sessionProjectId } from './flow-replay-run.js';
 import { persistAndSyncVerificationRun, } from '../../judgement/runs/verification-sync.js';
 import { runServerVerify } from './suite/server-verify.js';
 import { healFlow } from './heal-run.js';
+import { RESULT_FIELD, resultField, suiteResult } from '../../surface/tools/reticle-result.js';
+import { replayOneFlow } from './single-replay.js';
 export { replayNamedFlow } from './flow-replay-run.js';
 import { replayAndLearn } from './flow-learning.js';
 /**
@@ -34,19 +42,21 @@ import { replayAndLearn } from './flow-learning.js';
  * set). Fire-and-forget: resolves the config, POSTs via the platform fetch, and logs the outcome. Any
  * failure is swallowed so a network hiccup never affects the local save.
  */
-async function syncSavedFlowToCloud(deps, flow, projectId) {
+async function syncSavedFlowToCloud(deps, flow, target) {
     // Per-project cloud: sync a saved flow only when cloud is attached AND flow sync is enabled.
     // The link file of the project this flow belongs to — the flow itself was already saved through
     // `flowsForSession`, and reading the credential from a different tree is how one project's work
     // reaches another project's dashboard.
-    const cloud = await resolveProjectCloud(deps.fs, rootForProjectId(deps, projectId), homedir(), process.env);
+    const cloud = await resolveProjectCloud(deps.fs, rootForTarget(deps, target), homedir(), process.env);
     if (null === cloud.config || !cloud.policy.flows)
         return; // not attached / flows disabled → local only
-    const result = await syncFlowToCloud(flow, cloud.config, projectId, cloudFetch);
+    const result = await syncFlowToCloud(flow, cloud.config, target.projectId, cloudFetch);
     if (result.outcome !== SyncOutcome.SYNCED) {
         log('cloud-flow-sync-failed', { flow: flow.name, status: result.status, error: result.error });
     }
 }
+/** A step index no recorded flow reaches; bounds `to` and `at`. */
+const MAX_REPLAY_STEP = 10_000;
 /**
  * The URL a leased context should open: the app's ORIGIN, not the live tab's current location.
  *
@@ -57,7 +67,10 @@ async function syncSavedFlowToCloud(deps, flow, projectId) {
  */
 export function leasableAppUrl(deps, sessionId) {
     try {
-        const url = deps.sessions.resolve(sessionId).url;
+        const session = deps.sessions.resolve(sessionId);
+        if (AppRuntime.WEB !== (session.runtime ?? AppRuntime.WEB))
+            return undefined; // desktop: no IPC in a lease
+        const url = session.url;
         if (typeof url !== 'string' || 0 === url.length)
             return undefined;
         return new URL(url).origin;
@@ -75,7 +88,7 @@ export function leasableAppUrl(deps, sessionId) {
  * refusal on that path is deliberately silent — a fixture is an optimisation, and a suite must not
  * die when one is unavailable.
  */
-function sessionUrlOf(deps, sessionId) {
+export function sessionUrlOf(deps, sessionId) {
     try {
         return deps.sessions.resolve(sessionId).url;
     }
@@ -112,15 +125,17 @@ export const FLOW_TOOLS = [
     FLOW_MUTATE_TOOL,
     {
         name: ReticleTool.FLOW_SAVE,
-        description: 'Persist the last/active recording (by name) as a git-checked, anchor-resolved flow at .reticle/flows/<name>.json. Each step is bound to a SEMANTIC anchor (testid/role/signal), never a volatile ref; steps without a resolvable testid are kept with degraded:true (a "add a data-testid here" marker) rather than dropped. Returns { name, stepCount, degraded, empty, assertions, warning? } — `assertions.grade` is asserted | presence-only | assertion-free: a flow that only acts (or only checks element presence) will pass even if the feature breaks, so when grade is not "asserted" follow assertions.warning and add a consequence assertion via reticle_annotate (assert-signal / assert-net / success-state). `warning` is present when the recording left a page and returned to it: replay has no navigation steps, so the next click will look for a control on a page the tab is no longer on.',
+        description: 'Persist a STOPPED recording (by name) as a git-checked, anchor-resolved flow at .reticle/flows/<name>.json. A recording that is still running is refused: stop it first with reticle_record{action:"stop"}, and the refusal names the exact call. Each step is bound to a SEMANTIC anchor (testid/role/signal), never a volatile ref; steps without a resolvable testid are kept with degraded:true (a "add a data-testid here" marker) rather than dropped. Returns { name, stepCount, degraded, empty, assertions, warning? } — `assertions.grade` is asserted | presence-only | assertion-free: a flow that only acts (or only checks element presence) will pass even if the feature breaks, so when grade is not "asserted" follow assertions.warning and add a consequence assertion via reticle_annotate (assert-signal / assert-net / success-state). `warning` is present when the recording left a page and returned to it: replay has no navigation steps, so the next click will look for a control on a page the tab is no longer on.',
         inputSchema: {
             flow: z
                 .string()
                 .optional()
                 .describe('Alias for `flowName` (the name reticle_annotate uses).'),
+            name: z.string().optional().describe('Alias for `flowName`.'),
             flowName: z
                 .string()
-                .describe('Which RECORDING to save — the name reticle_record{start} was called with. This is a lookup key, not the filename: pass `saveAs` to choose that.'),
+                .optional()
+                .describe('Which RECORDING to save — the name reticle_record{start} was called with ("last-journey" for the reticle_act {steps} just proved). Omit when only one is stopped. This is a lookup key, not the filename: pass `saveAs` to choose that.'),
             saveAs: z
                 .string()
                 .optional()
@@ -156,6 +171,7 @@ export const FLOW_TOOLS = [
             })
                 .optional(),
             intentGap: INTENT_GAP_FIELD,
+            normalized: z.array(z.string()).optional(),
             warning: z
                 .string()
                 .optional()
@@ -164,7 +180,12 @@ export const FLOW_TOOLS = [
             code: z.string().optional(),
         },
         handler: (deps, args) => {
-            const name = asString(aliasParam(args, 'flowName', ['flow'])['flowName']) ?? '';
+            const aliases = ['flow', 'name', 'recordingName'];
+            const normalized = aliasUsed(args, 'flowName', aliases);
+            const explicitName = asString(aliasParam(args, 'flowName', aliases)['flowName']);
+            // The one stopped recording when the call names none — the same defaulting record{stop} and
+            // annotate use. With several, nothing is picked: the refusal below names them.
+            const name = resolveAnnotateTarget(explicitName, deps.recordings.compiled());
             const program = deps.recordings.getCompiled(name);
             if (program === undefined) {
                 /*
@@ -177,6 +198,13 @@ export const FLOW_TOOLS = [
                  * before the names were compared.
                  */
                 const held = deps.recordings.compiled();
+                const running = stillRecording(deps.recordings.active(), name, explicitName, held);
+                if (running !== undefined) {
+                    return Promise.resolve({
+                        error: stillRecordingMessage(running),
+                        code: FlowErrorCode.NO_RECORDING,
+                    });
+                }
                 return Promise.resolve({
                     error: 0 === held.length
                         ? flowErrorMessage(FlowErrorCode.NO_RECORDING)
@@ -211,13 +239,14 @@ export const FLOW_TOOLS = [
                 ...(success !== undefined ? { success } : {}),
                 ...(intent !== undefined ? { intent } : {}),
             };
-            const projectId = sessionProjectId(deps, asString(args['sessionId']));
+            const target = sessionTarget(deps, asString(args['sessionId']));
+            const { projectId } = target;
             // A zero-step recording is not a flow. Saving it wrote a file the suite reports "unverifiable"
             // forever while telling the agent it had saved a regression test — see empty-flow.
             const emptyRefusal = emptyFlowRefusal(program.steps.length, name);
             if (emptyRefusal !== undefined)
                 return Promise.resolve(emptyRefusal);
-            const { flows, root } = flowsForSession(deps, projectId);
+            const { flows, root } = flowsForSession(deps, target);
             const author = flowAuthor();
             const toSave = {
                 ...program,
@@ -244,6 +273,7 @@ export const FLOW_TOOLS = [
                 const invoked = loaded.ok ? await loadInvoked(flows, loaded.value, projectId) : new Map();
                 return loaded.ok
                     ? {
+                        ...(0 === normalized.length ? {} : { normalized }),
                         ...res.value,
                         ...(path === undefined ? {} : { path }),
                         assertions: classifyFlowAssertions(loaded.value, invoked),
@@ -275,10 +305,11 @@ export const FLOW_TOOLS = [
         // (the prior bug) made schema-validating MCP clients reject the result ("expected object,
         // received string") — caught driving the live demo.
         handler: (deps, args) => {
-            const projectId = sessionProjectId(deps, asString(args['sessionId']));
+            const target = sessionTarget(deps, asString(args['sessionId']));
+            const { projectId } = target;
             // The APP's flows, not the daemon's. Listing where the daemon was launched is what showed a
             // React dashboard a HUD full of Electron and Tauri flows from an unrelated checkout.
-            const { flows: store, root } = flowsForSession(deps, projectId);
+            const { flows: store, root } = flowsForSession(deps, target);
             return store.list(projectId).then((names) => ({
                 // `list` deliberately returns invalid names so they are reported rather than silently
                 // dropped — but the declared outputSchema requires `path` on EVERY entry, and omitting it made
@@ -366,16 +397,15 @@ export const FLOW_TOOLS = [
     {
         name: ReticleTool.FLOW_REPLAY,
         description: "Replay a git-checked flow from .reticle/flows/<name>.json. RE-RESOLVES each step's semantic " +
-            'anchor (testid via reticle_query; signal via predicate) against the LIVE DOM — never reuses a ' +
-            'stale ref. On an anchor MISS returns legible DRIFT { step, anchor, drift:{ reasonKind, reason, ' +
-            'nearest } } (the closest surviving testid) and stops — the "whose fault is it" contract. ' +
-            'Returns { name, status: ok|drift|error, steps:[...] }; missing/malformed files and action ' +
-            'failures are status:error with a structured code (distinct from contract-changed drift). ' +
-            'An ok replay of a flow that asserts no consequence also carries unverifiable:{reason} — it ' +
-            'would read ok even if the feature were broken, so do NOT treat that ok as proof. ' +
-            'A run that stops early carries halted:{atStep, notAttempted}: `steps` is SHORTER than the ' +
-            'flow because replay stopped, not because a step was skipped — do not read a missing step as ' +
-            'an action that failed to dispatch.',
+            'anchor (testid via reticle_query; signal via predicate) against LIVE DOM. On anchor MISS returns ' +
+            'DRIFT { step, anchor, drift:{ reasonKind, reason, nearest } } and stops. ' +
+            'Returns { name, status: ok|drift|error|unverifiable, steps:[...] }. ' +
+            'Action failures are status:error. ' +
+            'Status unverifiable means flow could not be graded (missing secrets, unmet preconditions, lost ' +
+            'document) — neither pass nor fail, treat as UNKNOWN. ' +
+            'An ok replay of a flow asserting no consequence also carries unverifiable:{reason} — do not ' +
+            'treat as proof. ' +
+            'Early halt carries halted:{atStep, notAttempted}: `steps` is shorter because replay stopped.',
         inputSchema: {
             flow: z
                 .string()
@@ -384,14 +414,26 @@ export const FLOW_TOOLS = [
             flowName: z
                 .string()
                 .describe('Flow file name (without .json extension) from reticle_flow{action:"list"}.'),
-            confirmDangerous: z
-                .boolean()
-                .optional()
-                .describe('Set true to allow destructive controls during this replay only.'),
+            [CALL_SECRETS_ARG]: callSecretsArg,
+            confirmDangerous: confirmDangerousArg('this replay'),
             from: z
                 .union([z.number().int().nonnegative(), z.string().min(1)])
                 .optional()
                 .describe('Resume at this step (index or step id). Earlier steps re-run as unchecked, unreported setup; a setup step marked effect:"commits" refuses the resume.'),
+            to: z
+                .number()
+                .int()
+                .positive()
+                .max(MAX_REPLAY_STEP)
+                .optional()
+                .describe('Stop before this step (drive only to a point journeys branch from).'),
+            at: z
+                .number()
+                .int()
+                .nonnegative()
+                .max(MAX_REPLAY_STEP)
+                .optional()
+                .describe('Continue at this step on the page as it is (after another flow ran `to` it); 0 replays the whole flow on the page the flow before it left, with no reload.'),
             sweep: z
                 .boolean()
                 .optional()
@@ -409,10 +451,12 @@ export const FLOW_TOOLS = [
                 .array(z.unknown())
                 .optional()
                 .describe('Present when `seed` was given: which endpoints were delayed, and by how long.'),
+            [RESULT_FIELD]: z.string().optional(),
             // The flow's name — always present in FlowReplayResult (the description promises `{ name, … }`),
             // but omitted here, so a validating profile stripped it and a replay result arrived anonymous.
             name: z.string(),
-            status: z.string().describe('ok | drift | error'),
+            status: z.string().describe('ok | drift | error | unverifiable'),
+            runId: z.string().optional().describe('The run this replay was written down as.'),
             steps: z.array(z.unknown()),
             proposals: z.array(z.unknown()).optional(),
             deviation: z
@@ -466,41 +510,7 @@ export const FLOW_TOOLS = [
         },
         // The decision envelope is attached by replayNamedFlow only on drift/fail (clean pass stays
         // token-flat). Single-flow replay and whole-suite verify share that one implementation.
-        handler: async (deps, args) => {
-            const seed = asNumber(args['seed']);
-            if (seed === undefined)
-                return await replayAndLearn(deps, args);
-            /*
-             * Seeded chaos, and always put the page back.
-             *
-             * The targets are the endpoints the FLOW declared it depends on, so the perturbation lands on
-             * traffic the flow claims to care about rather than on something it never mentioned. No
-             * declared endpoints means nothing to slow, and the replay runs clean rather than pretending
-             * a seed did something.
-             *
-             * `finally` is not tidiness: a page left slowed is damage the NEXT run inherits, and it would
-             * inherit it as a mystery — the same rule the mutation loop had to earn.
-             */
-            const sessionId = asString(args['sessionId']);
-            const loaded = await flowsForSession(deps, sessionProjectId(deps, sessionId))
-                .flows.load(asString(args['flowName']) ?? asString(args['flow']) ?? '', sessionProjectId(deps, sessionId))
-                .catch(() => null);
-            const targets = loaded !== null && loaded.ok ? mutationTargetsFor(loaded.value) : [];
-            const rules = perturbationFor(seed, targets);
-            const port = 0 === rules.length
-                ? undefined
-                : await sessionPerturbationPort(deps.realInput, leasableAppUrl(deps, sessionId));
-            if (port === undefined)
-                return replayAndLearn(deps, args);
-            try {
-                await port.slow(rules);
-                const replay = await replayNamedFlow(deps, args);
-                return { ...replay, perturbed: rules };
-            }
-            finally {
-                await port.clear().catch(() => undefined);
-            }
-        },
+        handler: (deps, args) => replayOneFlow(deps, args, leasableAppUrl(deps, asString(args['sessionId']))),
     },
     {
         name: ReticleTool.FLOW_VERIFY,
@@ -510,6 +520,7 @@ export const FLOW_TOOLS = [
             'whatChanged, whereInSource, nextAction }] } plus `flaky` (flows seen to pass AND fail on unchanged code) — passing flows are counted, only failures carry ' +
             'detail (the actionable fix). One call replaces N hand-driven replays.',
         inputSchema: {
+            [CALL_SECRETS_ARG]: callSecretsArg,
             names: z
                 .array(z.string())
                 .optional()
@@ -521,6 +532,7 @@ export const FLOW_TOOLS = [
             parallel: workerCountSchema
                 .optional()
                 .describe('Run this many flows at once, each in its own isolated leased browser context (needs the browser pool). Clamped to the pool capacity and the flow count. Omit for the sequential single-tab run.'),
+            confirmDangerous: confirmDangerousArg('this run of the suite'),
             sessionId: z
                 .string()
                 .optional()
@@ -528,10 +540,12 @@ export const FLOW_TOOLS = [
         },
         outputSchema: {
             status: z.string().describe('pass | fail'),
+            runId: z.string().optional().describe('The run this suite was written down as.'),
             total: z.number(),
             passed: z.number(),
             failed: z.number(),
             summary: z.string(),
+            [RESULT_FIELD]: z.string().optional(),
             failures: z.array(z.unknown()),
             isolation: z
                 .string()
@@ -573,11 +587,14 @@ export const FLOW_TOOLS = [
             // feedback ask here or a validating profile strips it off the suite verdict.
             feedback_prompt: z.unknown().optional(),
         },
-        handler: async (deps, args) => {
+        // The run id is minted first, so each replayed step's screenshot is filed under the run.
+        handler: (deps, args) => withShotRun(defaultRunId(), async () => {
             const sessionId = asString(args['sessionId']);
+            const confirmed = true === args['confirmDangerous'] ? { confirmDangerous: true } : {};
             // "Replay all" means all of THIS app's flows (+ legacy), not every project's on a shared daemon.
-            const projectId = sessionProjectId(deps, sessionId);
-            const selected = await resolveSuiteSelection(deps, projectId, args);
+            const target = sessionTarget(deps, sessionId);
+            const { projectId } = target;
+            const selected = await resolveSuiteSelection(deps, target, args);
             const requested = selected.run;
             /** Named rather than subtracted — a suite that returns fewer than were asked for must say so. */
             const heldBack = {
@@ -587,7 +604,7 @@ export const FLOW_TOOLS = [
                 ...(selected.unsatisfied === undefined ? {} : { unsatisfied: selected.unsatisfied }),
             };
             // verify:server — hand the whole suite to the hosted runner; it records the verification itself.
-            const cloud = await resolveProjectCloud(deps.fs, rootForProjectId(deps, projectId), homedir(), process.env);
+            const cloud = await resolveProjectCloud(deps.fs, rootForTarget(deps, target), homedir(), process.env);
             const server = await runServerVerify(deps, cloud, sessionId, requested);
             if (server !== null)
                 return server;
@@ -629,7 +646,11 @@ export const FLOW_TOOLS = [
                     const start = deps.now();
                     const lease = await acquireLeasedSession(pool, deps.sessions, appUrl, projectId, seed);
                     try {
-                        const replay = await replayAndLearn(deps, { flowName, sessionId: lease.sessionId });
+                        const replay = await replayAndLearn(deps, {
+                            flowName,
+                            sessionId: lease.sessionId,
+                            ...confirmed,
+                        });
                         return { replay, durationMs: deps.now() - start };
                     }
                     finally {
@@ -639,7 +660,7 @@ export const FLOW_TOOLS = [
                 const parallelRuns = await Promise.all(outcomes.map(async (o, i) => {
                     const name = requested[i] ?? '';
                     const replay = o.ok && o.value !== undefined ? o.value.replay : leaseFailureReplay(name, o.error);
-                    const loaded = await flowsForSession(deps, projectId)
+                    const loaded = await flowsForSession(deps, target)
                         .flows.load(name, projectId)
                         .catch(() => null);
                     const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
@@ -649,13 +670,15 @@ export const FLOW_TOOLS = [
                     ...(parallelRuns[i] ?? { replay: leaseFailureReplay(requested[i] ?? '', o.error) }),
                     durationMs: o.ok && o.value !== undefined ? o.value.durationMs : 0,
                 }));
-                const flaky = await recordSuiteFlakes(deps.fs, rootForProjectId(deps, projectId), parallelRuns);
-                await persistAndSyncVerificationRun(deps, timed, projectId);
+                const flaky = await recordSuiteFlakes(deps.fs, rootForTarget(deps, target), parallelRuns);
+                const runId = await persistAndSyncVerificationRun(deps, timed, target);
                 const verdict = buildSuiteVerdict(parallelRuns, selected.knownRoutes, SuiteIsolation.PER_FLOW_LEASE);
                 return {
                     ...verdict,
+                    ...(runId === undefined ? {} : { runId }),
                     ...(flaky.length > 0 ? { flaky: [...flaky] } : {}),
                     ...heldBack,
+                    ...resultField(() => suiteResult(rootForTarget(deps, target), verdict, timed, runId)),
                 };
             }
             // The flow FILE travels with each replay so the verdict can tell a green that verified
@@ -673,8 +696,8 @@ export const FLOW_TOOLS = [
             // (1 of 2 flows). Restoring two thirds of a session is worse than restoring none.
             for (const flowName of requested) {
                 const start = deps.now();
-                const replay = await replayAndLearn(deps, { flowName, sessionId });
-                const loaded = await flowsForSession(deps, projectId)
+                const replay = await replayAndLearn(deps, { flowName, sessionId, ...confirmed });
+                const loaded = await flowsForSession(deps, target)
                     .flows.load(flowName, projectId)
                     .catch(() => null);
                 const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
@@ -689,19 +712,21 @@ export const FLOW_TOOLS = [
             // `reticle flow` on the command line, so an AGENT running this tool a hundred times learned
             // nothing about which flows are intermittent. Same product, same ledger, two surfaces, and the
             // one an agent uses was the blind half.
-            const flaky = await recordSuiteFlakes(deps.fs, rootForProjectId(deps, projectId), runs);
+            const flaky = await recordSuiteFlakes(deps.fs, rootForTarget(deps, target), runs);
             // Emit the consolidated run artifact (Runs tab) + best-effort cloud push. Never blocks the verdict.
-            await persistAndSyncVerificationRun(deps, timed, projectId);
+            const runId = await persistAndSyncVerificationRun(deps, timed, target);
             const verdict = buildSuiteVerdict(runs, selected.knownRoutes, SuiteIsolation.SHARED_SESSION);
             // A flow that has both passed and failed on UNCHANGED code is a different thing from a
             // regression, and an agent that cannot tell them apart either chases a ghost or ignores a real
             // break. Present only when the ledger has seen enough runs to say so.
             return {
                 ...verdict,
+                ...(runId === undefined ? {} : { runId }),
                 ...(flaky.length > 0 ? { flaky: [...flaky] } : {}),
                 ...heldBack,
+                ...resultField(() => suiteResult(rootForTarget(deps, target), verdict, timed, runId)),
             };
-        },
+        }),
     },
     {
         name: ReticleTool.FLOW_SAVE_RECORDED,
@@ -766,12 +791,13 @@ export const FLOW_TOOLS = [
             // Resolved like every other path now. This save used to go to the daemon's root while the
             // recorded-flow save resolved per session, so where a flow landed depended on which tool wrote
             // it — and the pair that disagreed were the two ways to save the same thing.
-            const res = await flowsForSession(deps, session.projectId).flows.saveFlow(flow, session.projectId);
+            const target = { projectId: session.projectId, origin: originOf(session.url) };
+            const res = await flowsForSession(deps, target).flows.saveFlow(flow, session.projectId);
             if (!res.ok)
                 return { error: flowErrorMessage(res.code, res.detail), code: res.code };
             // If logged in to Reticle, mirror the saved flow to the team's regression suite. Best-effort
             // and non-blocking: the flow is already on disk, so a sync failure never fails the save.
-            void syncSavedFlowToCloud(deps, flow, session.projectId);
+            void syncSavedFlowToCloud(deps, flow, target);
             // Return the SaveSummary as-is ({ name, stepCount, degraded, empty }) — the outputSchema
             // declares `name`, so the old `flowName` key was silently stripped by schema-strict clients.
             return res.value;
@@ -795,10 +821,7 @@ export const FLOW_TOOLS = [
                 .describe('Alias for `flowName` (the name reticle_annotate uses).'),
             flowName: z.string().describe('Flow file name to heal (from reticle_flow{action:"list"}).'),
             apply: z.boolean().optional(),
-            confirmDangerous: z
-                .boolean()
-                .optional()
-                .describe('Set true to allow destructive controls during this heal replay only.'),
+            confirmDangerous: confirmDangerousArg('this heal replay'),
             sessionId: z
                 .string()
                 .optional()

package/dist/language/flows/flows.d.ts

@@ -11,6 +11,14 @@ export declare function anchorForStep(args: Record<string, unknown>): {
     anchor: FlowAnchor;
     degraded: boolean;
 };
+/**
+ * The recorded steps as they may be SHOWN: every credential fill carries the placeholder.
+ *
+ * The same rule the saved flow is written by, applied to what a tool hands back. `record stop`
+ * returned the compiled program verbatim, so the password a saved flow never contained went into
+ * the agent's transcript instead. The store keeps the real value — an in-session replay types it.
+ */
+export declare function redactRecordedSteps(steps: readonly RecordedStep[]): RecordedStep[];
 /**
  * What the anchor CALLS the field it points at.
  *
@@ -58,7 +66,14 @@ export interface FlowAnnotations {
 /** Persists anchored flows to .reticle/flows/<name>.json. Filesystem + clock are injected. */
 export declare class FlowStore {
     #private;
-    constructor(fs: FileSystemPort, root: string, clock: Clock);
+    /**
+     * `onWrote` is told after a save lands, so cloud sync cycles on a new flow the way it does on a
+     * new run (`RunStore` takes the same callback). Without it a flow saved with no run behind it
+     * waited for the timer, and a daemon that exited first never sent it.
+     */
+    constructor(fs: FileSystemPort, root: string, clock: Clock, opts?: {
+        onWrote?: () => void;
+    });
     /**
      * Convert a CompiledProgram (testid-normalized) into an anchored, on-disk flow + write it.
      * Optionally fold structured annotations (per-step expect, dynamic[], success) onto