@reticlehq/server 3.8.2 → 3.10.0

package/dist/judgement/runs/run-ledger.js

@@ -1,142 +1,171 @@
 /**
- * The run ledger: what one agent run checked, saved and read, kept until its report is taken.
+ * The run ledger: what each agent run checked, saved and read, kept until its report is taken.
  *
- * A run is the agent's calls from its first Reticle call to the call that ends it (a session end, a
+ * A run is one agent's calls from its first Reticle call to the call that ends it (a session end, a
  * yield, a released tab). The verdicts come from the journal records the agent's own calls wrote;
- * the Harness's are never counted. Taking the report empties the ledger, so the next run starts at
- * zero.
+ * the Harness's are never counted. Taking the report ends that run, so the agent's next run starts
+ * at zero.
  *
- * A call from another agent (another MCP attach id) starts a new run. An agent that stops without a
- * call that ends its run then does not leak its claims into the next agent's report.
+ * The ledger keeps one run for each MCP attach id. Two agents on one daemon (two worktrees of one
+ * project) call in turn. When the ledger kept one run, each call restarted the other agent's run,
+ * and a released lease reported the other agent's claims and none of its own. A record goes to the
+ * run of the connection that wrote it, and a call that ends a run takes the caller's run (#1900).
  *
- * ponytail: one ledger for each daemon, not for each agent. Two agents that call at the same time
- * restart each other's run. Key the ledger by attach id when that happens.
+ * A record from no connection (the HUD, the CLI, an agent record that ends outside its call
+ * context) goes to the run of the agent that called last. An agent that stops without a call that
+ * ends its run leaves its run here. That run is dropped when it is idle for `RUN_IDLE_LIMIT_MS`.
  */
 import { supersededChecks } from '@reticlehq/engine/evidence/superseded-checks.js';
 import { JournalVerdictEffectSchema, ReticleTool, Verified, } from '@reticlehq/core';
+import { callingAttachId } from '../../hooks/coding-agents.js';
 const SAW = 'saw ';
 const FLOW = 'flow ';
+/** A run with no agent call for this long is dropped. A working agent calls much more often. */
+export const RUN_IDLE_LIMIT_MS = 6 * 60 * 60 * 1000;
 /** One piece of evidence for a claim: what the check saw, else the source line it drove. */
 function evidenceOf(effect) {
-    if (effect.observed !== undefined)
+    if (effect.observed !== undefined) {
         return `${SAW}${effect.observed}`;
+    }
     return effect.source;
 }
 /** `no` when anything failed, `yes` only when something held and nothing was undecided. */
 function runVerified(all) {
-    if (all.includes(Verified.NO))
+    if (all.includes(Verified.NO)) {
         return Verified.NO;
-    if (0 === all.length || all.some((v) => Verified.YES !== v))
+    }
+    if (0 === all.length || all.some((v) => Verified.YES !== v)) {
         return Verified.UNKNOWN;
+    }
     return Verified.YES;
 }
+const openRun = (now) => ({
+    startedAt: now,
+    lastAt: now,
+    firstVerdictAt: undefined,
+    verdicts: [],
+    saved: new Set(),
+    replayed: new Map(),
+    written: 0,
+    read: new Set(),
+});
 export class RunLedger {
-    #owner;
-    #startedAt;
-    #firstVerdictAt;
-    #verdicts = [];
-    #saved = new Set();
-    #replayed = new Map();
-    #written = 0;
-    #read = new Set();
-    /** An agent call starts. The first one starts the run, and a call from another agent starts a new one. */
+    #runs = new Map();
+    #last;
+    /** An agent call starts. The agent's first call starts its run. A run idle too long is dropped. */
     begin(now, owner) {
-        if (this.#owner !== owner)
-            this.#reset();
-        this.#owner = owner;
-        this.#startedAt ??= now;
+        for (const [id, run] of this.#runs) {
+            if (now - run.lastAt > RUN_IDLE_LIMIT_MS) {
+                this.#runs.delete(id);
+            }
+        }
+        const run = this.#runs.get(owner) ?? openRun(now);
+        run.lastAt = now;
+        this.#runs.set(owner, run);
+        this.#last = owner;
     }
     /** An agent call ended. The first one that left a verdict sets the time to the first verdict. */
-    after(now) {
-        if (0 < this.#verdicts.length || 0 < this.#replayed.size)
-            this.#firstVerdictAt ??= now;
+    after(now, owner) {
+        const run = this.#run(owner);
+        if (run === undefined) {
+            return;
+        }
+        run.lastAt = Math.max(run.lastAt, now);
+        if (0 < run.verdicts.length || 0 < run.replayed.size) {
+            run.firstVerdictAt ??= now;
+        }
     }
     /** A journal record from the agent's own call. A record with no verdict is not a claim. */
     verdict(action) {
-        if (this.#idle() || action.drivenBy !== undefined)
+        const run = this.#run();
+        if (run === undefined || action.drivenBy !== undefined) {
             return;
+        }
         // A replay is counted once, as a flow, decided as its run decides it (`replayed`). Its journal
         // record said `unknown` where the run said `no`, and one report gave both answers.
-        if (ReticleTool.FLOW_REPLAY === action.tool)
+        if (ReticleTool.FLOW_REPLAY === action.tool) {
             return;
+        }
         const parsed = JournalVerdictEffectSchema.safeParse(action.effect);
-        if (parsed.success)
-            this.#verdicts.push(parsed.data);
+        if (parsed.success) {
+            run.verdicts.push(parsed.data);
+        }
     }
     flowSaved(name) {
-        if (!this.#idle())
-            this.#saved.add(name);
+        this.#run()?.saved.add(name);
     }
     /** The last replay of a flow in this run is its verdict. */
     replayed(name, verified) {
-        if (!this.#idle())
-            this.#replayed.set(name, verified);
+        this.#run()?.replayed.set(name, verified);
     }
     memoryWritten(count = 1) {
-        if (!this.#idle())
-            this.#written += count;
+        const run = this.#run();
+        if (run !== undefined) {
+            run.written += count;
+        }
     }
     /** Notes given to the agent. Each one counts once, however often it is shown. */
     memoryRead(notes) {
-        if (this.#idle())
+        const run = this.#run();
+        if (run === undefined) {
             return;
-        for (const note of notes)
-            this.#read.add(note);
+        }
+        for (const note of notes) {
+            run.read.add(note);
+        }
+    }
+    isEmpty(owner) {
+        return this.#run(owner) === undefined;
     }
-    isEmpty() {
-        return this.#idle();
+    /** The named owner, else the calling connection, else the agent that called last. */
+    #owner(owner) {
+        return owner ?? callingAttachId() ?? this.#last;
     }
     /**
-     * No agent run is open. A CLI `reticle verify` replays through the same code, and what it did is
-     * not the next agent's run, so nothing is kept until an agent call begins one.
+     * The run a record belongs to. None while no agent call has begun one: a CLI `reticle verify`
+     * replays through the same code, and what it did is not the next agent's run.
      */
-    #idle() {
-        return this.#startedAt === undefined;
+    #run(owner) {
+        const id = this.#owner(owner);
+        return id === undefined ? undefined : this.#runs.get(id);
     }
-    /** The report, without the cloud line (the caller knows the project). Empties the ledger. */
-    take(now) {
-        const started = this.#startedAt ?? now;
+    /** The owner's report, without the cloud line (the caller knows the project). Ends that run. */
+    take(now, owner) {
+        const id = this.#owner(owner);
+        const run = this.#run(owner) ?? openRun(now);
+        if (id !== undefined) {
+            this.#runs.delete(id);
+        }
+        const started = run.startedAt;
         // A passive check that read too early is not counted: the rule every fold applies.
-        const superseded = supersededChecks(this.#verdicts.map((v) => ({
+        const superseded = supersededChecks(run.verdicts.map((v) => ({
             key: v.claim,
             passive: false === v.declaredBeforeActing,
             held: Verified.YES === v.verified,
             failed: Verified.NO === v.verified,
         })));
-        const counted = this.#verdicts.filter((_, at) => !superseded.has(at));
+        const counted = run.verdicts.filter((_, at) => !superseded.has(at));
         const claims = counted.map((v) => {
             const evidence = evidenceOf(v);
             return evidence === undefined
                 ? { claim: v.claim, verified: v.verified }
                 : { claim: v.claim, verified: v.verified, evidence };
         });
-        const replayed = [...this.#replayed].map(([name, verified]) => ({ name, verified }));
-        const report = {
+        const replayed = [...run.replayed].map(([name, verified]) => ({ name, verified }));
+        return {
             verified: runVerified([...claims.map((c) => c.verified), ...replayed.map((r) => r.verified)]),
             claims,
             caught: [
                 ...claims.filter((c) => Verified.NO === c.verified).map((c) => c.claim),
                 ...replayed.filter((r) => Verified.NO === r.verified).map((r) => `${FLOW}${r.name}`),
             ],
-            flows: { saved: [...this.#saved], replayed },
-            memory: { written: this.#written, read: this.#read.size },
+            flows: { saved: [...run.saved], replayed },
+            memory: { written: run.written, read: run.read.size },
             wallMs: Math.max(0, now - started),
-            ...(this.#firstVerdictAt === undefined
+            ...(run.firstVerdictAt === undefined
                 ? {}
-                : { firstVerdictMs: Math.max(0, this.#firstVerdictAt - started) }),
+                : { firstVerdictMs: Math.max(0, run.firstVerdictAt - started) }),
         };
-        this.#reset();
-        return report;
-    }
-    #reset() {
-        this.#owner = undefined;
-        this.#startedAt = undefined;
-        this.#firstVerdictAt = undefined;
-        this.#verdicts = [];
-        this.#saved = new Set();
-        this.#replayed = new Map();
-        this.#written = 0;
-        this.#read = new Set();
     }
 }
 /** The daemon's ledger. */

package/dist/judgement/runs/runner-port.d.ts

@@ -12,4 +12,6 @@ export declare function createRunnerPort(deps: ToolDeps, sessionId?: string,
 /** `reticle verify --confirm-dangerous`: this run acknowledges the steps held as destructive. */
 opts?: {
     confirmDangerous?: boolean;
+    requireStartControl?: boolean;
+    sweep?: boolean;
 }): RunnerPort;

package/dist/judgement/runs/runner-port.js

@@ -4,7 +4,10 @@
  * and a uuid generator. The ReticleRunner core (tested with a fake port) holds all the orchestration and
  * verdict logic, so this layer carries no decisions.
  */
+import { ReplayStatus } from '@reticlehq/core';
 import { replayAndLearn } from '../../language/flows/flow-learning.js';
+import { sessionUrlOf } from '../../language/flows/flow-lease.js';
+import { flowStartState } from '../../surface/tools/session-ports.js';
 import { flowsForSession } from '../../language/flows/flow-store-for-session.js';
 import { safeSessionTarget } from '../../memory/project/session-root.js';
 import { defaultRunId } from './default-run-id.js';
@@ -13,17 +16,32 @@ export { defaultRunId } from './default-run-id.js';
 export function createRunnerPort(deps, sessionId, 
 /** `reticle verify --confirm-dangerous`: this run acknowledges the steps held as destructive. */
 opts = {}) {
+    // Each flow starts from the state the run started in, so one that signs out cannot fail the rest.
+    const startState = flowStartState(deps.realInput, () => sessionUrlOf(deps, sessionId));
     return {
         // Resolved as replay resolves it, so every listed name is one replay can load.
         listFlows: () => {
             const target = safeSessionTarget(deps, sessionId);
             return flowsForSession(deps, target).flows.list(target.projectId);
         },
-        replayFlow: (name) => replayAndLearn(deps, {
-            flowName: name,
-            ...(sessionId === undefined ? {} : { sessionId }),
-            ...(true === opts.confirmDangerous ? { confirmDangerous: true } : {}),
-        }),
+        replayFlow: async (name) => {
+            const cannotStart = await startState();
+            if (cannotStart !== undefined) {
+                return {
+                    name,
+                    status: ReplayStatus.UNVERIFIABLE,
+                    steps: [],
+                    unverifiable: { reason: cannotStart },
+                };
+            }
+            return await replayAndLearn(deps, {
+                flowName: name,
+                ...(sessionId === undefined ? {} : { sessionId }),
+                ...(true === opts.confirmDangerous ? { confirmDangerous: true } : {}),
+                ...(true === opts.requireStartControl ? { requireStartControl: true } : {}),
+                ...(true === opts.sweep ? { sweep: true } : {}),
+            });
+        },
         now: () => deps.now(),
         newRunId: defaultRunId,
     };

package/dist/judgement/runs/verification-sync.d.ts

@@ -1,5 +1,6 @@
 import { type FlowFile, type FlowReplayResult } from '@reticlehq/core';
 import { type VerificationRunInput } from './artifact/build-verification-run.js';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 import { type ProjectTarget } from '../../memory/project/session-root.js';
 import type { ToolDeps } from '../../surface/tools/tool-kit.js';
 /** A replay plus the wall-clock time it took — the shape the verify handler already collects. */
@@ -12,8 +13,10 @@ export interface TimedReplay {
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export declare const CLI_CLIENT_NAME = "reticle-cli";
 /**
- * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
- * person who holds the key, so the cloud credits them and the run does not read as CI.
+ * Who ran the command line, and why. Off CI it is the person who holds the key, so the cloud
+ * credits them. On CI the `automation` hint says which kind: a CI vendor runner is the pipeline,
+ * trigger `ci`; a coding-agent sandbox is a coding agent. A container, or `CI` with no vendor,
+ * keeps trigger `oem`, because the cloud has no value for either yet.
  */
-export declare function cliRunAuthor(env: NodeJS.ProcessEnv): Pick<VerificationRunInput, 'agent' | 'trigger'>;
+export declare function cliRunAuthor(env: NodeJS.ProcessEnv, automation?: AutomationHint | undefined): Pick<VerificationRunInput, 'agent' | 'trigger'>;
 export declare function persistAndSyncVerificationRun(deps: ToolDeps, timed: TimedReplay[], target: ProjectTarget): Promise<string | undefined>;

package/dist/judgement/runs/verification-sync.js

@@ -21,26 +21,37 @@ import { RunStore } from './artifact/run-store.js';
 import { cloudFetch, syncRunToCloud, SyncOutcome } from '../../memory/cloud/cloud-sync.js';
 import { resolveProjectCloud } from '../../memory/cloud/cloud-config.js';
 import { log } from '../../log.js';
-import { isCiEnv } from '../../telemetry/automation-hint.js';
+import { currentAutomationHint, isCiEnv } from '../../telemetry/automation-hint.js';
+import { AutomationHint } from '@reticlehq/core/telemetry';
 import { rootForTarget } from '../../memory/project/session-root.js';
 /** The author of record when no MCP peer introduced itself — a CLI run, or a client that skipped the handshake. */
 const RETICLE_MCP_AGENT_ID = 'reticle-mcp';
 /** The MCP client name `reticle verify` (the command line, CI's path) connects to a daemon as. */
 export const CLI_CLIENT_NAME = 'reticle-cli';
 /**
- * Who ran the command line, and why. On a CI runner it is the pipeline; anywhere else it is the
- * person who holds the key, so the cloud credits them and the run does not read as CI.
+ * Who ran the command line, and why. Off CI it is the person who holds the key, so the cloud
+ * credits them. On CI the `automation` hint says which kind: a CI vendor runner is the pipeline,
+ * trigger `ci`; a coding-agent sandbox is a coding agent. A container, or `CI` with no vendor,
+ * keeps trigger `oem`, because the cloud has no value for either yet.
  */
-export function cliRunAuthor(env) {
-    return isCiEnv(env)
-        ? {
-            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.OEM_PIPELINE },
-            trigger: { kind: RunTrigger.OEM },
-        }
-        : {
+export function cliRunAuthor(env, automation = currentAutomationHint(env)) {
+    if (!isCiEnv(env)) {
+        return {
             agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.HUMAN },
             trigger: { kind: RunTrigger.MANUAL },
         };
+    }
+    if (AutomationHint.AGENT_SANDBOX === automation) {
+        return {
+            agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.CODING_AGENT },
+            trigger: { kind: RunTrigger.MANUAL },
+        };
+    }
+    const trigger = AutomationHint.CI_RUNNER === automation ? RunTrigger.CI : RunTrigger.OEM;
+    return {
+        agent: { id: CLI_CLIENT_NAME, kind: RunAgentKind.OEM_PIPELINE },
+        trigger: { kind: trigger },
+    };
 }
 /** Who ran a suite, and why: the command line by `cliRunAuthor`, any other client as a coding agent. */
 function agentAndTrigger(client) {

package/dist/language/flows/affected-tools.d.ts

@@ -1,4 +1,4 @@
-import type { ToolDef } from '../../surface/tools/tool-kit.js';
+import { type ToolDef } from '../../surface/tools/tool-kit.js';
 /**
  * `reticle_affected` — which saved flows must re-verify for a set of changed files.
  *

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

@@ -1,10 +1,40 @@
 import { z } from 'zod';
-import { ReticleTool } from '@reticlehq/core';
-import { loadNamedFlows, resolveChangedFiles } from '../../command/cli/cli-flow-commands.js';
-import { projectDirFor } from '../../memory/project/session-root.js';
-import { sessionRoot, sessionProjectId } from '../../memory/project/session-root.js';
+import { asString, ReticleTool } from '@reticlehq/core';
+import { sessionIdShape } from '../../surface/tools/tool-kit.js';
+import { resolveChangedFiles } from '../../command/cli/cli-flow-commands.js';
+import { namedFlowsForSession } from './flow-store-for-session.js';
 import { affectedSavedFlows } from './change/flow-sources.js';
 import { RECORD_A_FLOW } from './suite/coverage.js';
+/**
+ * Why the answer is empty, when that needs saying.
+ *
+ * Several situations produced the same empty answer: no files changed, no flows saved, and a git
+ * ref that resolved to nothing. Only the first means "nothing to re-verify". The others mean the
+ * question could not be answered, and re-running nothing on that basis is how a regression ships.
+ */
+function emptyAnswerReason(facts) {
+    const { changed, since, fileCount, flowCount, changedCount, unmatchedRoot } = facts;
+    // No folder declares this project, so nothing here is about a checkout (#1550).
+    if (unmatchedRoot !== undefined) {
+        return `no flows here: no folder on disk declares this project, so its evidence goes to ${unmatchedRoot}. Run \`reticle init\` in the app's folder, or lease the tab from there.`;
+    }
+    // A git failure OUTRANKS every other explanation: the others describe a question that was
+    // answered, and this one is a question that was not. Reporting "nothing changed" over a mistyped
+    // ref or a shallow clone is how a regression ships past the tool meant to catch it.
+    if (true === changed.failed) {
+        return `could not read the diff for \`${String(since)}\`, so NOTHING was compared and this result proves nothing: ${changed.reason ?? 'git failed'}`;
+    }
+    if (0 === flowCount) {
+        return `no saved flows exist yet, so nothing COULD be affected. ${RECORD_A_FLOW}`;
+    }
+    if (0 !== changedCount) {
+        return undefined;
+    }
+    if (since === undefined && 0 === fileCount) {
+        return 'no files were given and no `since` ref was passed, so nothing was compared — pass the files you edited, or a git ref';
+    }
+    return 'nothing changed against that input, so no saved flow needs re-verifying';
+}
 /**
  * `reticle_affected` — which saved flows must re-verify for a set of changed files.
  *
@@ -27,6 +57,7 @@ export const AFFECTED_TOOLS = [
         description: 'Which saved flows must re-verify for a set of changed files. Pass the files you edited (and/or `since` for a git ref to diff against). Returns { changedFiles, affected, unknownProvenance } — `affected` is what to re-run, and `unknownProvenance` are flows included only because Reticle cannot tell which sources they cover, so they are re-verified by default rather than silently skipped.',
         example: { files: ['src/App.tsx'] },
         inputSchema: {
+            ...sessionIdShape,
             files: z
                 .array(z.string())
                 .optional()
@@ -46,34 +77,22 @@ export const AFFECTED_TOOLS = [
                 ? args['files'].filter((f) => 'string' === typeof f)
                 : [];
             const since = 'string' === typeof args['since'] ? args['since'] : undefined;
-            // Same address as verify_change, resolved the same way. `deps.reticleRoot` is NOT the project
-            // directory this line used to claim it was — it is the daemon's `.reticle` subdirectory, in
-            // whichever tree the MCP host was started in. `undefined` here resolves the single connected
-            // session, which is the same rule the flow lookup below already follows.
-            const changed = await resolveChangedFiles(files, since, projectDirFor(deps, undefined));
+            // The project of the tab being driven, not the folder the daemon started in (#1550). The flows
+            // come from the store `flows` replays from, so a flow named here can be replayed by that name
+            // (#1996). `git diff` runs in the project directory that holds that store.
+            const { flows, projectDir, unmatchedRoot } = await namedFlowsForSession(deps, asString(args['sessionId']));
+            // A bucket of evidence is not a tree, so a `since` has nothing to diff against.
+            const changed = await resolveChangedFiles(files, unmatchedRoot === undefined ? since : undefined, projectDir);
             const changedFiles = changed.files;
-            // No `sessionId` on this tool's surface, and it does not need one: passing `undefined`
-            // resolves the single connected session, and falls back exactly as before when it cannot.
-            // Adding an argument here would be a surface change to fix an addressing bug.
-            const flows = await loadNamedFlows(deps.fs, sessionRoot(deps, undefined), sessionProjectId(deps, undefined));
             const result = affectedSavedFlows(flows, changedFiles);
-            // Three different situations produced the same empty answer: no files changed, no flows saved,
-            // and a git ref that resolved to nothing. Only the first means "nothing to re-verify"; the
-            // others mean the question could not be answered, and re-running nothing on that basis is how a
-            // regression ships. Say which one it is.
-            const why = 
-            // A git failure OUTRANKS every other explanation: the others describe a question that was
-            // answered, and this one is a question that was not. Reporting "nothing changed" over a
-            // mistyped ref or a shallow clone is how a regression ships past the tool meant to catch it.
-            changed.failed
-                ? `could not read the diff for \`${String(since)}\`, so NOTHING was compared and this result proves nothing: ${changed.reason ?? 'git failed'}`
-                : 0 === flows.length
-                    ? `no saved flows exist yet, so nothing COULD be affected. ${RECORD_A_FLOW}`
-                    : 0 === changedFiles.length
-                        ? since === undefined && 0 === files.length
-                            ? 'no files were given and no `since` ref was passed, so nothing was compared — pass the files you edited, or a git ref'
-                            : 'nothing changed against that input, so no saved flow needs re-verifying'
-                        : undefined;
+            const why = emptyAnswerReason({
+                changed,
+                since,
+                fileCount: files.length,
+                flowCount: flows.length,
+                changedCount: changedFiles.length,
+                unmatchedRoot,
+            });
             return {
                 changedFiles,
                 ...result,

package/dist/language/flows/change/git-changed.d.ts

@@ -17,7 +17,8 @@ export interface ChangedFiles {
 }
 /**
  * Files changed since a git ref (`git diff --name-only <ref>`), so `reticle gate --since main` works
- * from the real diff instead of hand-listed files.
+ * from the real diff instead of hand-listed files. Files under Reticle's own directory are left
+ * out: a replay writes them, and they are not a change to the app's code.
  *
  * Never throws, and never pretends. The CLI gate may still degrade to "no changes" and pass rather
  * than crash CI — that reasoning was right and is unchanged — but it now has to opt into doing so by

package/dist/language/flows/change/git-changed.js

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { ReticleDir } from '@reticlehq/core';
 const run = promisify(execFile);
 /** Parse `git diff --name-only` output into a clean file list. Pure; exported for testing. */
 export function parseGitFiles(output) {
@@ -19,9 +20,22 @@ export function parseGitFiles(output) {
 function refIsOptionLike(ref) {
     return ref.startsWith('-');
 }
+/**
+ * True when a diff path sits under Reticle's own project directory.
+ *
+ * A replay writes intent, impact and episode files into that directory. Those writes are
+ * Reticle's output, not a change to the app's code. A flow with no source stamps reads any
+ * change as "affected", so counting them marked flows the gate had just proved as uncovered
+ * (#2050). The directory can sit below the repo root, so any path segment counts. `git diff`
+ * prints paths with `/` on every platform.
+ */
+function isReticleOwnPath(path) {
+    return path.split('/').includes(ReticleDir.ROOT);
+}
 /**
  * Files changed since a git ref (`git diff --name-only <ref>`), so `reticle gate --since main` works
- * from the real diff instead of hand-listed files.
+ * from the real diff instead of hand-listed files. Files under Reticle's own directory are left
+ * out: a replay writes them, and they are not a change to the app's code.
  *
  * Never throws, and never pretends. The CLI gate may still degrade to "no changes" and pass rather
  * than crash CI — that reasoning was right and is unchanged — but it now has to opt into doing so by
@@ -38,7 +52,10 @@ export async function changedFilesSince(ref, cwd) {
     }
     try {
         const { stdout } = await run('git', ['diff', '--name-only', ref], { cwd });
-        return { files: parseGitFiles(stdout), failed: false };
+        return {
+            files: parseGitFiles(stdout).filter((file) => !isReticleOwnPath(file)),
+            failed: false,
+        };
     }
     catch (error) {
         return {

package/dist/language/flows/fields/flow-secret-field.d.ts

@@ -41,7 +41,7 @@ export declare const SECRET_FIELD_ARG = "secretField";
  * rules must not be able to drift. It used to sit in `replay.ts`, one import away from the sentence
  * saying it had to stay together.
  */
-export declare const secretEnvKey: (field: string) => string;
+export declare function secretEnvKey(field: string): string;
 /** The schema of that argument, shared by every tool that replays a flow. */
 export { CALL_SECRETS_ARG };
 export declare const callSecretsArg: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -59,16 +59,4 @@ export interface UnsuppliedSecret {
     field: string;
     envKey: string;
 }
-/**
- * Every credential this flow will replay as the literal placeholder.
- *
- * Checked BEFORE a step runs, because the alternative is what shipped: the placeholder is typed
- * into the password box, sign-in fails, and the flow reports that an element further down the
- * journey has gone missing -- a `drift` verdict naming a component nobody touched, with an
- * invitation to update a flow that was correct.
- *
- * The emptiness rule matches `replayActionArgs` exactly: it substitutes only for a value of
- * non-zero length, so an empty variable leaves the placeholder and must count as unsupplied here.
- * Two different answers to "is this supplied" is how the gate would pass and the replay still fail.
- */
 export declare function unsuppliedSecrets(flow: FlowFile, env: Record<string, string | undefined>): UnsuppliedSecret[];