Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(session): invalidate snapshots before metadata write dispatch
morluto1c64fe3eff48
diff --git a/docs/cli.md b/docs/cli.mdindex 16afe0f56..48e061c66 100644--- a/docs/cli.md+++ b/docs/cli.md@@ -150,6 +150,10 @@ an exact result when the target bytes, operation, parameters, provider andsettings match. Mutations and cursor-dependent calls are excluded from thecache. Snapshot files are local and use owner-only permissions.+Dispatching a metadata write invalidates the active session's snapshot cache,+even if its reply fails: the provider may already have applied the write.+Close and reopen the target before importing or saving another snapshot.+Snapshots retain eligible target-scoped question histories in full, includingmutation Evidence recorded while another target was active. Observations andrelated questions must still belong to the saved target. If those dependenciesdiff --git a/src/application/binary/BinarySession.ts b/src/application/binary/BinarySession.tsindex da8d8e679..9eff0e0b8 100644--- a/src/application/binary/BinarySession.ts+++ b/src/application/binary/BinarySession.ts@@ -588,6 +588,9 @@ export class BinarySessionif (!prepared.ok) return prepared;const { active, capability, profile, cacheable, cached } = prepared.value;if (cached !== undefined) return ok(cached);+ // A failed reply cannot prove that a dispatched metadata write rolled back.+ // Stop replay before dispatch, including reads overlapping the write.+ if (capability.effects.mutatesArtifact) this.invalidateSnapshot();const call = active.client.execute(name, arguments_, options);const result = await call;const profiled = bindExecutionTarget(@@ -645,8 +648,6 @@ export class BinarySessionparameters: arguments_,execution: execution.value,});- } else if (profiled.ok && capability.effects.mutatesArtifact) {- this.invalidateSnapshot();}return execution;}diff --git a/src/application/binary/BinarySessionRecords.ts b/src/application/binary/BinarySessionRecords.tsindex 182d5892f..cfa0fa3b2 100644--- a/src/application/binary/BinarySessionRecords.ts+++ b/src/application/binary/BinarySessionRecords.ts@@ -144,9 +144,9 @@ export abstract class BinarySessionRecords {if (this.#snapshotInvalidated)return err(new EvidenceIntegrityError(- "Analysis snapshots are unavailable after analysis metadata mutations",+ "Analysis snapshots are unavailable because analysis metadata may have changed",{- userMessage: `Analysis snapshots are unavailable after analysis metadata mutations. ${SNAPSHOT_MUTATION_RECOVERY}`,+ userMessage: `Analysis snapshots are unavailable because analysis metadata may have changed. ${SNAPSHOT_MUTATION_RECOVERY}`,},),);@@ -177,9 +177,9 @@ export abstract class BinarySessionRecords {if (active !== undefined && this.#snapshotInvalidated)return err(new EvidenceIntegrityError(- "Analysis snapshots cannot be imported after analysis metadata mutations",+ "Analysis snapshots cannot be imported because analysis metadata may have changed",{- userMessage: `Analysis snapshots cannot be imported after analysis metadata mutations. ${SNAPSHOT_MUTATION_RECOVERY}`,+ userMessage: `Analysis snapshots cannot be imported because analysis metadata may have changed. ${SNAPSHOT_MUTATION_RECOVERY}`,},),);diff --git a/tests/composition/analysis-sessions/binarySession.test.ts b/tests/composition/analysis-sessions/binarySession.test.tsindex 302d51d50..27e591a17 100644--- a/tests/composition/analysis-sessions/binarySession.test.ts+++ b/tests/composition/analysis-sessions/binarySession.test.ts@@ -1,6 +1,7 @@-import type {- AnalysisClient,- AnalysisProvider,+import {+ createAnalysisExecution,+ type AnalysisClient,+ type AnalysisProvider,} from "../../../src/application/AnalysisProvider.js";import type { BinarySession } from "../../../src/application/binary/BinarySession.js";import { parseBinaryTarget } from "../../../src/application/BinaryTargetResolver.js";@@ -374,7 +375,7 @@ describe("evidence metadata imports and snapshot cache", () => {ok: false,error: {message: expect.stringContaining(- "Analysis snapshots are unavailable after analysis metadata mutations",+ "Analysis snapshots are unavailable because analysis metadata may have changed",),},});@@ -408,6 +409,108 @@ describe("evidence metadata imports and snapshot cache", () => {});});+describe("snapshot invalidation at mutation dispatch", () => {+ it.each(["provider failure", "invalid reply identity"] as const)(+ "does not replay metadata after a write followed by %s",+ async (failure) => {+ const [target] = await createBinarySessionTargets();+ const provider = createCacheProvider([]);+ let name = "before";+ provider.createClient = () => ({+ execute: (operation) => {+ if (operation === "health") return Promise.resolve(ok(null));+ if (operation === "address_name") return Promise.resolve(ok(name));+ if (operation !== "set_address_name")+ throw new Error(`Unexpected operation: ${operation}`);+ name = "after";+ return Promise.resolve(+ failure === "provider failure"+ ? err(new ProviderAdapterError("fixture", operation))+ : resultOk(+ createAnalysisExecution(true, {+ id: "wrong",+ name: "Wrong",+ version: "1",+ }),+ ),+ );+ },+ close: () => Promise.resolve(resultOk(null)),+ });+ const session = createTestBinarySession(provider);+ try {+ const opened = await session.open(target);+ if (!opened.ok) throw opened.error;+ const parameters = { address: "0x1000", document: "first" };+ const before = await session.execute("address_name", parameters);+ if (!before.ok) throw before.error;+ expect(before.value.result).toBe("before");+ const baseline = session.exportAnalysisSnapshot();+ if (!baseline.ok) throw baseline.error;++ const written = await session.execute("set_address_name", {+ ...parameters,+ name: "after",+ });+ expect(written).toMatchObject({ ok: false });+ const after = await session.execute("address_name", parameters);+ if (!after.ok) throw after.error;+ expect(after.value.result).toBe("after");+ expect(session.exportAnalysisSnapshot()).toMatchObject({ ok: false });+ expect(session.importAnalysisSnapshot(baseline.value)).toMatchObject({+ ok: false,+ });+ } finally {+ expect(await session.close()).toEqual({ ok: true, value: null });+ }+ },+ );++ it("stops replay while a dispatched write is still awaiting its reply", async () => {+ const [target] = await createBinarySessionTargets();+ const provider = createCacheProvider([]);+ const started = createDeferred<void>();+ const reply = createDeferred<ReturnType<typeof ok>>();+ let name = "before";+ provider.createClient = () => ({+ execute: (operation) => {+ if (operation === "health") return Promise.resolve(ok(null));+ if (operation === "address_name") return Promise.resolve(ok(name));+ if (operation !== "set_address_name")+ throw new Error(`Unexpected operation: ${operation}`);+ name = "after";+ started.resolve();+ return reply.promise;+ },+ close: () => Promise.resolve(resultOk(null)),+ });+ const session = createTestBinarySession(provider);+ try {+ const opened = await session.open(target);+ if (!opened.ok) throw opened.error;+ const parameters = { address: "0x1000", document: "first" };+ const before = await session.execute("address_name", parameters);+ if (!before.ok) throw before.error;+ const writing = session.execute("set_address_name", {+ ...parameters,+ name: "after",+ });+ await started.promise;+ try {+ const during = await session.execute("address_name", parameters);+ if (!during.ok) throw during.error;+ expect(during.value.result).toBe("after");+ expect(session.exportAnalysisSnapshot()).toMatchObject({ ok: false });+ } finally {+ reply.resolve(ok(true));+ expect(await writing).toMatchObject({ ok: true });+ }+ } finally {+ expect(await session.close()).toEqual({ ok: true, value: null });+ }+ });+});+describe("replay of exact immutable calls", () => {it("replays exact immutable calls from a matching provider-neutral snapshot", async () => {const [first, second] = await createBinarySessionTargets();