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(process): bound retained trace ordering state
morluto63e796d50ea3
diff --git a/experiments/analysis-efficiency/process-trace-validation.md b/experiments/analysis-efficiency/process-trace-validation.mdindex 0a4f9b0f6..a32848596 100644--- a/experiments/analysis-efficiency/process-trace-validation.md+++ b/experiments/analysis-efficiency/process-trace-validation.md@@ -2,13 +2,19 @@A 6,000-event directed cycle previously overflowed the JavaScript stack insidethe schema refinement. Cycle detection now uses iterative topological traversal.-Reachability is computed once per queried origin; cyclic inputs retain-independent declaration diagnostics without expanding all event pairs. Unordered-declarations retain group membership, with one diagnostic per overlapping group,-instead of allocating a pair set and repeating the same error for every pair.-Valid partial orders still receive complete pair validation.+Cyclic inputs retain independent declaration diagnostics without expanding all+event pairs. Unordered declarations retain group membership, with one diagnostic+per overlapping or conflicting group, instead of allocating a pair set and+repeating the same error for every pair.-## Bounded comparison+A unique topological order proves that every event pair is ordered, allowing+rank comparisons without retaining transitive closure. Other acyclic graphs+retain only one origin's forward and backward reachability sets at a time.+Complete pair validation preserves the missing count and first declaration-order+missing pair. General partial orders still require quadratic pair examination+and repeated graph traversal; they trade CPU time for bounded retained state.++## Initial cycle fix comparisonFlameox ran three randomized paired blocks (seed 917), each limited to 20 secondsand 512 MiB. Node 24.18.0 used a 384-MiB old-space limit on macOS arm64. Each@@ -17,7 +23,8 @@ known 6,000-event cycle failure with per-event not-before constraints and oneunordered group containing every event. All six executions passed the embedded answerdigest and expected rejection checks.-The baseline source is from `bb540826d`; the candidate includes this trace fix.+The baseline source is from `bb540826d`; the candidate is the initial cycle fix+in `10935b7b1`, which still memoized reachability sets for every queried origin.Both modules had TypeScript annotations removed with Node's identical built-intransform and used the same copied runtime dependencies. This isolates schemavalidation rather than comparing complete packaged CLI/MCP processes.@@ -44,8 +51,8 @@ the process but create fresh per-validation graph state. Whole-process elapsedincludes startup, imports, all four validations, the cyclic-input check, tokenestimation and reporting. CPU includes startup through metrics publication;peak RSS covers the complete single-process workload, with no children. Host-caches were not flushed. Peak memory increased in this cohort. The remaining-valid-order closure and pair validation can still require quadratic resources.+caches were not flushed. Peak memory increased in this cohort. Its retained+valid-order closure still required quadratic memory, prompting the follow-up.Three pairs describe this fixture only.Preserved Flameox evidence:@@ -57,3 +64,50 @@ isolated runtime copy. Source-module SHA-256 values are`a7729faa2183b0e493b9ac4fc55f6feaee5b2e5294be13d1b29b57a44b899788`(baseline) and `725409ce84902125941251037a8a214ccc3c1eec577e484c164c361ca580d693`(candidate).++## Bounded retention follow-up++Flameox compared `10935b7b1` with the rank/streaming implementation in three+randomized paired blocks (seed 624), under the same host, Node, heap, memory and+20-second execution bounds. Each execution validated the chain above four times,+then a 1,200-event partial order with 600 unordered two-event layers and all four+edges between consecutive layers four times, then the same cyclic failure.+All six executions passed both parsed-answer digests and the cycle diagnostic.+Runtime dependencies were copied and isolated from concurrent checkout builds.++| Median measurement | Memoized closure | Rank/streaming |+| ---------------------------------------- | ---------------: | -------------: |+| Chain first elapsed milliseconds | 166.11 | 11.37 |+| Chain warm elapsed milliseconds | 154.25 | 5.32 |+| Chain first CPU milliseconds | 210.13 | 24.38 |+| Chain warm CPU milliseconds | 184.76 | 16.84 |+| Partial order first elapsed milliseconds | 49.44 | 116.54 |+| Partial order warm elapsed milliseconds | 50.67 | 110.29 |+| Partial order first CPU milliseconds | 72.47 | 137.69 |+| Partial order warm CPU milliseconds | 70.65 | 121.77 |+| Capture process elapsed milliseconds | 901.24 | 557.30 |+| Process CPU milliseconds before report | 1,101.12 | 665.03 |+| Peak process-family MiB | 391.13 | 127.72 |++First samples exclude module import and fixture preparation. Partial-order first+samples follow four chain validations, so they are first use of that fixture+within an already running process. Warm medians pool the three subsequent samples+from each of three processes. CPU and peak RSS cover the combined workload;+capture elapsed additionally includes Flameox capture startup and overhead.+Host caches were not flushed. The partial-order fixture is slower after this+change; these results establish a retention tradeoff, not universal acceleration.++The partial-order input is 165,590 JSON bytes, estimated at 52,783 tokens by tokenx+1.3.0; its parsed-answer SHA-256 is+`41d06e593813e497221c36793bf00d5fece7055081895b5f6c123ba6ad9a8227`.+Chain bytes, token estimate and answer digest remain unchanged. Actual agent+tokens, transport, catalog injection, model reasoning and provider costs remain+unmeasured. Both cohorts are component measurements, not complete investigations.++Preserved evidence:+`e29086af99afd8e67cbbd92e43d960ea40f73b4d318ea0cbca60f493575462b8`;+analysis `086133516f2acf031032d357a3ddb1ac611ce4f12556a24065a2becd567c5f7b`.+The baseline module SHA-256 is+`725409ce84902125941251037a8a214ccc3c1eec577e484c164c361ca580d693`;+the candidate module SHA-256 is+`2109f1096406e9ecac8bbf4f7ae8abb5113404790a9382487285d2831fcddf26`.diff --git a/src/domain/process/processTraceSpecification.test.ts b/src/domain/process/processTraceSpecification.test.tsindex 9484e9075..ab649d2aa 100644--- a/src/domain/process/processTraceSpecification.test.ts+++ b/src/domain/process/processTraceSpecification.test.ts@@ -95,8 +95,54 @@ describe("process trace specification", () => {});expect(result.language.kind).toBe("partial_order");});+});- it("counts only undeclared pairs after transitive, not-before and unordered relations", () => {+describe("process trace ordering validation", () => {+ it("uses a unique topological order for transitive declarations and conflicts", () => {+ const events = ["a", "b", "c"].map((id) => ({+ id,+ source: "lifecycle" as const,+ exact: { marker: id },+ cardinality: { kind: "optional" as const },+ }));+ const accepted = processTraceSpecificationSchema.safeParse({+ events,+ language: {+ kind: "partial_order",+ happens_before: [+ { before: "a", after: "b" },+ { before: "b", after: "c" },+ ],+ },+ });+ expect(accepted.success).toBe(true);++ const rejected = processTraceSpecificationSchema.safeParse({+ events,+ language: {+ kind: "partial_order",+ happens_before: [+ { before: "a", after: "b" },+ { before: "b", after: "c" },+ ],+ not_before: [{ event: "a", anchor: "c" }],+ unordered_groups: [{ events: ["a", "b", "c"] }],+ },+ });+ if (rejected.success) throw new Error("Expected ordered pair conflicts");+ expect(rejected.error.issues).toEqual([+ expect.objectContaining({+ path: ["language", "not_before", 0],+ message: "not-before constraint conflicts with happens-before order",+ }),+ expect.objectContaining({+ path: ["language", "unordered_groups", 0],+ message: "ordered events cannot also be declared unordered",+ }),+ ]);+ });++ it("counts only undeclared pairs across transitive and disconnected relations", () => {const events = ["a", "b", "c", "d"].map((id) => ({id,source: "lifecycle" as const,@@ -150,7 +196,82 @@ describe("process trace specification", () => {}),]);});+});++describe("malformed process trace declarations", () => {+ it("preserves independent diagnostics when event ids are duplicated", () => {+ const result = processTraceSpecificationSchema.safeParse({+ events: [+ {+ id: "a",+ source: "lifecycle",+ exact: { fixture: "first" },+ cardinality: { kind: "optional" },+ },+ {+ id: "a",+ source: "lifecycle",+ exact: { fixture: "second" },+ cardinality: { kind: "optional" },+ },+ ],+ language: {+ kind: "partial_order",+ unordered_groups: [{ events: ["a", "b"] }],+ },+ });+ expect(result.success).toBe(false);+ if (result.success) throw new Error("Expected a duplicate event id");+ expect(result.error.issues).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ path: ["events", 1, "id"],+ message: "event ids must be unique",+ }),+ expect.objectContaining({+ path: ["language", "unordered_groups", 0, "events", 1],+ message: "unknown event id: b",+ }),+ ]),+ );+ });++ it("keeps reachability diagnostics for unknown referenced successors", () => {+ const result = processTraceSpecificationSchema.safeParse({+ events: ["a", "b"].map((id) => ({+ id,+ source: "lifecycle",+ exact: { fixture: id },+ cardinality: { kind: "optional" },+ })),+ language: {+ kind: "partial_order",+ happens_before: [{ before: "a", after: "missing" }],+ not_before: [{ event: "a", anchor: "missing" }],+ },+ });+ expect(result.success).toBe(false);+ if (result.success) throw new Error("Expected an unknown event reference");+ expect(result.error.issues).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ path: ["language", "happens_before", 0, "after"],+ message: "unknown event id: missing",+ }),+ expect.objectContaining({+ path: ["language", "not_before", 0, "anchor"],+ message: "unknown event id: missing",+ }),+ expect.objectContaining({+ path: ["language", "not_before", 0],+ message: "not-before constraint conflicts with happens-before order",+ }),+ ]),+ );+ });+});+describe("finite trace specification validation", () => {it("rejects invalid ignores and unsatisfiable variants", () => {const base = specification();expect(diff --git a/src/domain/process/processTraceSpecification.ts b/src/domain/process/processTraceSpecification.tsindex 8e4e6fca6..09c14cf10 100644--- a/src/domain/process/processTraceSpecification.ts+++ b/src/domain/process/processTraceSpecification.ts@@ -105,7 +105,17 @@ export type ProcessTraceSpecification = z.infer<typeof specificationShapeSchema>;type PartialOrderLanguage = z.infer<typeof partialOrderLanguageSchema>;-type Reachability = (origin: string) => ReadonlySet<string>;++type AcyclicGraphFacts =+ | {+ readonly kind: "total-order";+ readonly rank: ReadonlyMap<string, number>;+ }+ | {+ readonly kind: "partial-order";+ readonly reverseAdjacency: ReadonlyMap<string, ReadonlySet<string>>;+ };+type GraphFacts = { readonly kind: "cyclic" } | AcyclicGraphFacts;export const canonicalTraceJson = (value: unknown): string => {const serialized = canonicalize(value);@@ -195,38 +205,28 @@ const validateNotBefore = (return pairs;};-const validateNotBeforeOrder = (- language: PartialOrderLanguage,- context: z.RefinementCtx,- reachable: Reachability,-): void => {- for (const [index, constraint] of language.not_before.entries())- if (reachable(constraint.event).has(constraint.anchor))- context.addIssue({- code: "custom",- message: "not-before constraint conflicts with happens-before order",- path: ["language", "not_before", index],- });-};--const graphHasCycle = (+const classifyGraph = (ids: readonly string[],adjacency: ReadonlyMap<string, ReadonlySet<string>>,-): boolean => {+): GraphFacts => {const incoming = new Map(ids.map((id) => [id, 0]));+ let hasUnknownSuccessor = false;for (const successors of adjacency.values())for (const successor of successors) {const count = incoming.get(successor);- if (count !== undefined) incoming.set(successor, count + 1);+ if (count === undefined) hasUnknownSuccessor = true;+ else incoming.set(successor, count + 1);}const ready = [...incoming].flatMap(([id, count]) =>count === 0 ? [id] : [],);- let examined = 0;+ const order: string[] = [];+ let unique = true;while (ready.length > 0) {+ if (ready.length !== 1) unique = false;const current = ready.pop();- if (current === undefined) break;- examined++;+ if (current === undefined) continue;+ order.push(current);for (const successor of adjacency.get(current) ?? []) {const count = incoming.get(successor);if (count === undefined) continue;@@ -234,50 +234,67 @@ const graphHasCycle = (if (count === 1) ready.push(successor);}}- return examined !== incoming.size;+ if (order.length !== incoming.size) return { kind: "cyclic" };+ if (unique && order.length === ids.length && !hasUnknownSuccessor) {+ return {+ kind: "total-order",+ rank: new Map(order.map((id, index) => [id, index])),+ };+ }+ const reverseAdjacency = new Map(+ [...incoming.keys()].map((id) => [id, new Set<string>()]),+ );+ for (const [before, successors] of adjacency)+ for (const after of successors) reverseAdjacency.get(after)?.add(before);+ return { kind: "partial-order", reverseAdjacency };};-const createReachability = (+const collectReachable = (+ origin: string,adjacency: ReadonlyMap<string, ReadonlySet<string>>,-): Reachability => {- const reachable = new Map<string, Set<string>>();- return (origin) => {- const cached = reachable.get(origin);- if (cached !== undefined) return cached;- const seen = new Set<string>();- const pending = [...(adjacency.get(origin) ?? [])];- while (pending.length > 0) {- const current = pending.pop();- if (current === undefined || seen.has(current)) continue;- seen.add(current);- for (const successor of adjacency.get(current) ?? [])- pending.push(successor);- }- reachable.set(origin, seen);- return seen;- };-};--const isOrdered = (- reachable: Reachability,- left: string,- right: string,-): boolean => reachable(left).has(right) || reachable(right).has(left);--type OrderingRelations = {- readonly reachable: Reachability;- readonly notBeforePairs: ReadonlySet<string>;+): ReadonlySet<string> => {+ const seen = new Set<string>();+ const pending = [...(adjacency.get(origin) ?? [])];+ while (pending.length > 0) {+ const current = pending.pop();+ if (current === undefined || seen.has(current)) continue;+ seen.add(current);+ for (const successor of adjacency.get(current) ?? [])+ pending.push(successor);+ }+ return seen;};const validateUnorderedGroups = (language: PartialOrderLanguage,context: z.RefinementCtx,known: ReadonlySet<string>,-): ((left: string, right: string) => boolean) => {+): {+ readonly groups: readonly ReadonlySet<string>[];+ hasPair(left: string, right: string): boolean;+ markDeclaredPairConflicts(+ pairs: ReadonlySet<string>,+ conflicts: boolean[],+ ): void;+ markSharedGroups(left: string, right: string, conflicts: boolean[]): void;+} => {const memberships = new Map<string, Set<number>>();+ const groups: Set<string>[] = [];+ const repeatedMemberships = new Map<string, Set<number>>();for (const [groupIndex, group] of language.unordered_groups.entries()) {const path = ["language", "unordered_groups", groupIndex];- const uniqueIds = new Set(group.events);+ const uniqueIds = new Set<string>();+ const repeatedIds = new Set<string>();+ for (const id of group.events) {+ if (uniqueIds.has(id)) repeatedIds.add(id);+ else uniqueIds.add(id);+ }+ groups.push(uniqueIds);+ for (const id of repeatedIds) {+ const groupIndexes = repeatedMemberships.get(id) ?? new Set<number>();+ groupIndexes.add(groupIndex);+ repeatedMemberships.set(id, groupIndexes);+ }if (uniqueIds.size !== group.events.length)context.addIssue({code: "custom",@@ -301,51 +318,121 @@ const validateUnorderedGroups = (path,});}- return (left, right) => {+ const markSharedGroups = (+ left: string,+ right: string,+ conflicts: boolean[],+ ): void => {+ if (left === right) {+ for (const groupIndex of repeatedMemberships.get(left) ?? [])+ conflicts[groupIndex] = true;+ return;+ }const rightGroups = memberships.get(right);for (const group of memberships.get(left) ?? [])- if (rightGroups?.has(group) === true) return true;- return false;+ if (rightGroups?.has(group) === true) conflicts[group] = true;+ };+ return {+ groups,+ hasPair(left, right) {+ if (left === right) return memberships.has(left);+ const rightGroups = memberships.get(right);+ for (const group of memberships.get(left) ?? [])+ if (rightGroups?.has(group) === true) return true;+ return false;+ },+ markDeclaredPairConflicts(pairs, conflicts) {+ for (const key of pairs) {+ const separator = key.indexOf("\0");+ const left = key.slice(0, separator);+ const right = key.slice(separator + 1);+ markSharedGroups(left, right, conflicts);+ }+ },+ markSharedGroups,};};-const validateUnorderedOrder = (+const validateTotalOrderRelations = (language: PartialOrderLanguage,+ graph: Extract<GraphFacts, { kind: "total-order" }>,+ unorderedGroups: ReturnType<typeof validateUnorderedGroups>,+ notBeforePairs: ReadonlySet<string>,context: z.RefinementCtx,- relations: OrderingRelations,): void => {- for (const [groupIndex, group] of language.unordered_groups.entries())- for (const [leftIndex, leftId] of group.events.entries()) {- for (- let rightIndex = leftIndex + 1;- rightIndex < group.events.length;- rightIndex++- ) {- const rightId = group.events[rightIndex];- if (rightId === undefined) continue;- const key = pairKey(leftId, rightId);- if (- isOrdered(relations.reachable, leftId, rightId) ||- relations.notBeforePairs.has(key)- )- context.addIssue({- code: "custom",- message: "ordered events cannot also be declared unordered",- path: ["language", "unordered_groups", groupIndex],- });+ for (const [index, constraint] of language.not_before.entries()) {+ const before = graph.rank.get(constraint.event);+ const after = graph.rank.get(constraint.anchor);+ if (before !== undefined && after !== undefined && before < after)+ context.addIssue({+ code: "custom",+ message: "not-before constraint conflicts with happens-before order",+ path: ["language", "not_before", index],+ });+ }++ const conflicts = new Array<boolean>(language.unordered_groups.length).fill(+ false,+ );+ for (const [groupIndex, group] of unorderedGroups.groups.entries()) {+ let comparableEvents = 0;+ for (const id of group)+ if (graph.rank.has(id) && ++comparableEvents === 2) {+ conflicts[groupIndex] = true;+ break;}- }+ }+ unorderedGroups.markDeclaredPairConflicts(notBeforePairs, conflicts);+ addUnorderedConflictIssues(conflicts, context);+};++const addUnorderedConflictIssues = (+ conflicts: readonly boolean[],+ context: z.RefinementCtx,+): void => {+ for (const [groupIndex, conflict] of conflicts.entries())+ if (conflict)+ context.addIssue({+ code: "custom",+ message: "ordered events cannot also be declared unordered",+ path: ["language", "unordered_groups", groupIndex],+ });};-const validateCompletePairDeclarations = (+const validatePartialOrderRelations = (ids: readonly string[],- relations: OrderingRelations,- unorderedPair: (left: string, right: string) => boolean,+ language: PartialOrderLanguage,+ adjacency: ReadonlyMap<string, ReadonlySet<string>>,+ graph: Extract<GraphFacts, { kind: "partial-order" }>,+ unorderedGroups: ReturnType<typeof validateUnorderedGroups>,+ notBeforePairs: ReadonlySet<string>,context: z.RefinementCtx,): void => {let missingPairCount = 0;let firstMissingPair = "";+ const groupConflicts = new Array<boolean>(+ language.unordered_groups.length,+ ).fill(false);+ unorderedGroups.markDeclaredPairConflicts(notBeforePairs, groupConflicts);+ const notBeforeConflictFlags = new Uint8Array(language.not_before.length);+ const constraintsBySource = new Map<string, number[]>();+ for (const [index, constraint] of language.not_before.entries()) {+ const indexes = constraintsBySource.get(constraint.event) ?? [];+ indexes.push(index);+ constraintsBySource.set(constraint.event, indexes);+ }++ // Keep only one origin's forward and backward closure live at a time. Pair+ // iteration stays in declaration order so the count and first missing pair+ // retain the established diagnostic semantics.for (const [leftIndex, leftId] of ids.entries()) {+ const forward = collectReachable(leftId, adjacency);+ const backward = collectReachable(leftId, graph.reverseAdjacency);+ for (const constraintIndex of constraintsBySource.get(leftId) ?? []) {+ const constraint = language.not_before[constraintIndex];+ if (constraint !== undefined && forward.has(constraint.anchor))+ notBeforeConflictFlags[constraintIndex] = 1;+ }for (let rightIndex = leftIndex + 1;rightIndex < ids.length;@@ -353,17 +440,32 @@ const validateCompletePairDeclarations = () {const rightId = ids[rightIndex];if (rightId === undefined) continue;- if (isOrdered(relations.reachable, leftId, rightId)) continue;+ const sameEvent = leftId === rightId;+ const ordered =+ !sameEvent && (forward.has(rightId) || backward.has(rightId));const key = pairKey(leftId, rightId);- if (- !relations.notBeforePairs.has(key) &&- !unorderedPair(leftId, rightId)- ) {+ const notBefore = notBeforePairs.has(key);+ const unordered = unorderedGroups.hasPair(leftId, rightId);+ if (ordered || notBefore) {+ if (!sameEvent)+ unorderedGroups.markSharedGroups(leftId, rightId, groupConflicts);+ }+ if (!ordered && !notBefore && !unordered) {if (missingPairCount === 0) firstMissingPair = `${leftId}/${rightId}`;missingPairCount++;}}}++ for (const [index, conflict] of notBeforeConflictFlags.entries())+ if (conflict === 1)+ context.addIssue({+ code: "custom",+ message: "not-before constraint conflicts with happens-before order",+ path: ["language", "not_before", index],+ });+ addUnorderedConflictIssues(groupConflicts, context);+if (missingPairCount > 0)context.addIssue({code: "custom",@@ -383,31 +485,43 @@ const validatePartialOrder = (const ids = specification.events.map(({ id }) => id);const known = new Set(ids);const adjacency = buildAdjacency(specification.language, context, known);- const cyclic = graphHasCycle(ids, adjacency);- if (cyclic)+ const graph = classifyGraph(ids, adjacency);+ if (graph.kind === "cyclic")context.addIssue({code: "custom",message: "happens-before graph must be acyclic",path: ["language"],});- const reachable = createReachability(adjacency);const notBeforePairs = validateNotBefore(specification.language,context,known,);- const relations = { reachable, notBeforePairs };- const unorderedPair = validateUnorderedGroups(+ const unorderedGroups = validateUnorderedGroups(specification.language,context,known,);// Preserve independent declaration diagnostics on cyclic input. Computing// all pair relations cannot establish a valid partial order in that case.- if (!cyclic) {- validateNotBeforeOrder(specification.language, context, reachable);- validateUnorderedOrder(specification.language, context, relations);- validateCompletePairDeclarations(ids, relations, unorderedPair, context);+ if (graph.kind === "total-order") {+ validateTotalOrderRelations(+ specification.language,+ graph,+ unorderedGroups,+ notBeforePairs,+ context,+ );+ } else if (graph.kind === "partial-order") {+ validatePartialOrderRelations(+ ids,+ specification.language,+ adjacency,+ graph,+ unorderedGroups,+ notBeforePairs,+ context,+ );}for (const [kind, values] of [["prefix", specification.language.prefix],