morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #3333] [Bug] Distinct unresolved MCP workflows collide in the unknown registry #1202

New issue

Closed

opened 2026-10-15 18:31:58 +00:00 by bsakaguchi · 2 comments

bsakaguchi commented

2026-10-15 18:31:58 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 14, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/3333

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

MCP or agent integration

Observed behavior

A second unresolved build_call_path request on the same ordinary stdio MCP connection fails with revision_conflict instead of returning its own unknown result. Changing only the goal address from 0x3000 to 0x4000 triggers the failure after the earlier unresolved path succeeds. Both requests use the same authenticated function Evidence and missing-callee frontier.

The first goal returns status: "unknown". The second returns isError: true with no structured result. Replaying 0x3000 succeeds again, and list_unknowns reports only one call-path unknown. After close_binary and reimport of the original function-only bundle, the previously blocked 0x4000 request succeeds with status: "unknown". The server remains connected throughout.

A second executed stdio MCP probe used the canonical managed/native verification example with a complete empty native-export inventory. verify_managed_native_boundaries returned summary.unresolved: 1 for missing_one, then the same revision_conflict diagnostic for a distinct declaration named missing_two. Both adapters exhibit the same fixed-question registration pattern.

Reproduction

Start from a clean checkout and prepare the locked dependencies and compiled runtime:

git clone https://github.com/morluto/rea.git rea-repro
cd rea-repro
git checkout 8dde6370d0809ad04cda3342d4e6f290f48aa063
npm ci
npm run build:cached

Run the following command from the checkout root. It creates every input inline, starts the ordinary stdio MCP server, and imports a canonical Evidence bundle. It derives the bundle from the repository's complete function example, adding a direct callee at 0x2000 for which no dossier is supplied. No binary or analysis engine is executed.

REA_REPRO_DIR="$(mktemp -d)"
env REA_REPRO_DIR="$REA_REPRO_DIR" node --input-type=module <<'JS'
import { mkdir, writeFile } from 'node:fs/promises';
import { resolve } from 'node:path';
import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
import { FUNCTION_COMPARISON_EXAMPLE } from './dist/contracts/functionComparisonExample.js';
import { createEvidence } from './dist/domain/evidence.js';
import { createEvidenceBundle } from './dist/domain/evidenceBundle.js';
const root = process.env.REA_REPRO_DIR;
await mkdir(resolve(root, 'home'), { recursive: true });
const base = FUNCTION_COMPARISON_EXAMPLE.left;
const dossier = createEvidence({
  path: 'sample.bin', sha256: '0'.repeat(64), format: 'mach-o'
}, base.provider, {
  operation: 'analyze_function', parameters: base.parameters,
  result: { ...base.normalized_result, callees: [{
    address: '0x2000', name: 'helper', classification: null,
    body: { available: false, reason: 'No body extent observation.' }
  }] },
  confidence: base.confidence, authority: base.authority,
  relationshipCoverage: { status: 'complete' }
});
const bundlePath = resolve(root, 'bundle.json');
await writeFile(bundlePath, JSON.stringify(createEvidenceBundle([dossier])));
const transport = new StdioClientTransport({
  command: process.execPath, args: ['scripts/rea.mjs', '--mcp'], cwd: process.cwd(),
  env: { PATH: process.env.PATH, HOME: resolve(root, 'home'), REA_LOG_LEVEL: 'silent' },
  stderr: 'pipe'
});
const client = new Client({ name: 'call-path-reproduction', version: '1' });
const request = goal => client.callTool({
  name: 'build_call_path', arguments: {
    functions: [dossier], start: { address: '0x1000' }, goal: { address: goal }
  }
});
const show = (label, reply) => console.log(JSON.stringify({
  label, isError: reply.isError === true,
  status: reply.structuredContent?.normalized_result?.status ?? null,
  error: reply.isError ? JSON.parse(reply.content[0].text).error : null
}));
try {
  await client.connect(transport);
  await client.callTool({ name: 'import_evidence_bundle', arguments: { path: bundlePath } });
  for (const goal of ['0x3000', '0x4000', '0x3000']) show(goal, await request(goal));
  const unknowns = await client.callTool({ name: 'list_unknowns', arguments: { domain: 'call-path' } });
  console.log('unknown count:', unknowns.structuredContent.result.total);
  await client.callTool({ name: 'close_binary', arguments: {} });
  await client.callTool({ name: 'import_evidence_bundle', arguments: { path: bundlePath } });
  show('0x4000 after close/reimport', await request('0x4000'));
} finally {
  await client.close();
  await transport.close();
}
JS
rm -rf "$REA_REPRO_DIR"

Compare the two distinct goal requests with the repeated original goal, which controls for valid input and replay. The final close/reimport demonstrates recovery using only the original source Evidence bundle.
To reproduce the second affected adapter, rerun the same command with the following inline JavaScript inserted after import_evidence_bundle and before the call-path loop. It creates authenticated managed declarations and a complete empty native-export inventory from the canonical repository example:

const { MANAGED_NATIVE_VERIFICATION_EXAMPLE: example } = await import('./dist/contracts/managed/managedWorkflowExamples.js');
const native = example.native_observations[0];
const emptyNative = createEvidence({
  path: 'native.bin', sha256: native.subject.digest.sha256,
  format: 'mach-o', architecture: 'x86_64'
}, native.provider, {
  operation: 'inspect_macho', parameters: {},
  result: { ...native.normalized_result, exports: {
    items: [], total: 0, exhaustive: true, limitations: []
  } }
});
for (const name of ['missing_one', 'missing_two']) {
  const base = example.managed_boundaries;
  const managed = createEvidence(undefined, base.provider, {
    operation: base.operation, parameters: {},
    result: { ...base.normalized_result, pinvoke_imports:
      base.normalized_result.pinvoke_imports.map(item => ({ ...item, import_name: name }))
    }
  });
  const reply = await client.callTool({ name: 'verify_managed_native_boundaries', arguments: {
    managed_boundaries: managed, native_observations: [emptyNative]
  } });
  console.log(name, reply.isError === true,
    reply.structuredContent?.normalized_result?.summary?.unresolved ?? null);
}

The recorded reproduction used dependencies and the compiled runtime already present. The clean-checkout installation and build commands above are preparation instructions.

Expected behavior

Both goal requests should return complete call-path Evidence with status: "unknown" and the missing callee limitation. An unresolved result from an earlier, distinct request must not prevent recording and returning a later result. Repeating the original request should remain supported. Both distinct unresolved managed imports should return their verification results.

src/contracts/sessionToolContracts.ts:125 advertises missing call-path dossiers as unknown. src/contracts/managed/managedWorkflowToolContracts.ts:116 promises preservation of unresolved managed/native states. docs/tool-design.md:57 requires unresolved relationships and partial facts to remain visible.

Impact and scope

Impact level: P2, supported. Distinct valid investigations that retain unresolved results fail after the first result on a connection, and the failed call does not return its requested Evidence. This was observed in both call-path reconstruction and managed/native verification. Other tools using the same pattern were not executed.

Workaround status: available. The previously blocked request succeeds after closing and reimporting only the source Evidence. Closing clears the retained investigation, so export useful results first and keep unresolved workflows on separate fresh connections when their session history must remain available.

REA version

6.4.0 (main at 8dde6370d0)

Runtime and platform

Node.js v26.10.0 on macOS 27.0.1. Host architecture was not recorded in the reproduction evidence. The managed/native fixture declares an x86_64 Mach-O subject; that is target metadata, not an observation of host architecture.

Target and artifact context

Portable authenticated Evidence fixtures, with a function-only canonical Evidence bundle for sample.bin, Mach-O format, an all-zero 64-character SHA-256 fixture digest, a start function at 0x1000, and a missing direct callee at 0x2000. The additional managed/native probe uses native.bin, Mach-O x86_64, the example's native subject digest, and a complete empty export inventory. All bundle content is generated inline; no physical target binary or analysis engine is required or executed.

Interface

MCP

Earliest failure stage

Artifact or evidence registration

Relevant output or evidence

The second distinct goal returned this observed error instead of structured call-path Evidence:

{"error":{"code":"revision_conflict","category":"execution_failure","message":"Evidence state changed before the update completed. Refresh the current state and try again.","retryable":true,"remediation":{"action":"Evidence state changed before the update completed. Refresh the current state and try again."},"details":{"reason":"already-exists"}}}

The first goal and its replay returned status: "unknown"; list_unknowns reported one call-path unknown. Closing and reimporting the original bundle restored status: "unknown" for the previously blocked goal. The managed/native probe returned summary.unresolved: 1 for missing_one, followed by the same error for missing_two. These results came from executed stdio MCP calls; the reproduction was complete and locally reproduced.

Typed outcome or recovery expected

On one connection, run both distinct unresolved call paths and require both to return their complete unknown Evidence without a registry conflict. Repeat the original request and verify that the retained records and unknown references remain consistent. Run both distinct unresolved managed imports and require both verification results to remain available. Preserve rejection of an explicit record_unknown request that duplicates an existing stable identity; successful automatic recording must preserve that separate contract.

The repeated original goal is the discriminating valid-input/replay control. Close/reimport is the demonstrated recovery control, not a replacement for successful retention of both distinct results in one investigation.

Analysis or suspected cause

Source-derived reasoning: src/server/registerInvestigationTools.ts:147 records different call-path results with the same question and domain, and src/server/registerInvestigationTools/helpers.ts:49 passes that question to derived Evidence recording. src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts:87 uses the same pattern for the second observed tool. src/application/investigation/EvidenceLedger.ts:280 rejects a later differing unknown revision with already-exists. This source reasoning explains the observed failures but does not establish execution of other tools that use a similar pattern.

Additional context

#719 reported the same retained-session collision pattern in process comparisons and was closed as completed by #732, which scopes automatic comparison questions to their immutable Evidence identity. This report concerns the corresponding failure still present in call-path and managed/native verification; that completed repair was limited to process comparisons.
#1723 concerned edge-whitespace normalization causing an unknown revision digest failure, rather than a second distinct result colliding with an existing identity.
#1724 concerned omitted caller-selected intent in successful manual unknown-update mutation Evidence, rather than failed automatic registration.
#2621 concerned an extra duplicate-ID diagnostic for an invalid managed/native request, rather than registration failure for valid unresolved requests.
#3201 concerns false managed/native module contradictions when module identity is missing; this report concerns distinct unresolved results failing automatic retention.
#2322 and #2550 concerned forward-search coverage preventing not_found; the current inputs genuinely lack a callee dossier and should retain separate unknown results.

Originally created by @coygeek on GitHub (Oct 14, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/3333 ### Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area MCP or agent integration ### Observed behavior A second unresolved `build_call_path` request on the same ordinary stdio MCP connection fails with `revision_conflict` instead of returning its own `unknown` result. Changing only the goal address from `0x3000` to `0x4000` triggers the failure after the earlier unresolved path succeeds. Both requests use the same authenticated function Evidence and missing-callee frontier. The first goal returns `status: "unknown"`. The second returns `isError: true` with no structured result. Replaying `0x3000` succeeds again, and `list_unknowns` reports only one call-path unknown. After `close_binary` and reimport of the original function-only bundle, the previously blocked `0x4000` request succeeds with `status: "unknown"`. The server remains connected throughout. A second executed stdio MCP probe used the canonical managed/native verification example with a complete empty native-export inventory. `verify_managed_native_boundaries` returned `summary.unresolved: 1` for `missing_one`, then the same `revision_conflict` diagnostic for a distinct declaration named `missing_two`. Both adapters exhibit the same fixed-question registration pattern. ### Reproduction 1. Start from a clean checkout and prepare the locked dependencies and compiled runtime: ```sh git clone https://github.com/morluto/rea.git rea-repro cd rea-repro git checkout 8dde6370d0809ad04cda3342d4e6f290f48aa063 npm ci npm run build:cached ``` 2. Run the following command from the checkout root. It creates every input inline, starts the ordinary stdio MCP server, and imports a canonical Evidence bundle. It derives the bundle from the repository's complete function example, adding a direct callee at `0x2000` for which no dossier is supplied. No binary or analysis engine is executed. ```sh REA_REPRO_DIR="$(mktemp -d)" env REA_REPRO_DIR="$REA_REPRO_DIR" node --input-type=module <<'JS' import { mkdir, writeFile } from 'node:fs/promises'; import { resolve } from 'node:path'; import { Client } from '@modelcontextprotocol/client'; import { StdioClientTransport } from '@modelcontextprotocol/client/stdio'; import { FUNCTION_COMPARISON_EXAMPLE } from './dist/contracts/functionComparisonExample.js'; import { createEvidence } from './dist/domain/evidence.js'; import { createEvidenceBundle } from './dist/domain/evidenceBundle.js'; const root = process.env.REA_REPRO_DIR; await mkdir(resolve(root, 'home'), { recursive: true }); const base = FUNCTION_COMPARISON_EXAMPLE.left; const dossier = createEvidence({ path: 'sample.bin', sha256: '0'.repeat(64), format: 'mach-o' }, base.provider, { operation: 'analyze_function', parameters: base.parameters, result: { ...base.normalized_result, callees: [{ address: '0x2000', name: 'helper', classification: null, body: { available: false, reason: 'No body extent observation.' } }] }, confidence: base.confidence, authority: base.authority, relationshipCoverage: { status: 'complete' } }); const bundlePath = resolve(root, 'bundle.json'); await writeFile(bundlePath, JSON.stringify(createEvidenceBundle([dossier]))); const transport = new StdioClientTransport({ command: process.execPath, args: ['scripts/rea.mjs', '--mcp'], cwd: process.cwd(), env: { PATH: process.env.PATH, HOME: resolve(root, 'home'), REA_LOG_LEVEL: 'silent' }, stderr: 'pipe' }); const client = new Client({ name: 'call-path-reproduction', version: '1' }); const request = goal => client.callTool({ name: 'build_call_path', arguments: { functions: [dossier], start: { address: '0x1000' }, goal: { address: goal } } }); const show = (label, reply) => console.log(JSON.stringify({ label, isError: reply.isError === true, status: reply.structuredContent?.normalized_result?.status ?? null, error: reply.isError ? JSON.parse(reply.content[0].text).error : null })); try { await client.connect(transport); await client.callTool({ name: 'import_evidence_bundle', arguments: { path: bundlePath } }); for (const goal of ['0x3000', '0x4000', '0x3000']) show(goal, await request(goal)); const unknowns = await client.callTool({ name: 'list_unknowns', arguments: { domain: 'call-path' } }); console.log('unknown count:', unknowns.structuredContent.result.total); await client.callTool({ name: 'close_binary', arguments: {} }); await client.callTool({ name: 'import_evidence_bundle', arguments: { path: bundlePath } }); show('0x4000 after close/reimport', await request('0x4000')); } finally { await client.close(); await transport.close(); } JS rm -rf "$REA_REPRO_DIR" ``` 3. Compare the two distinct goal requests with the repeated original goal, which controls for valid input and replay. The final close/reimport demonstrates recovery using only the original source Evidence bundle. 4. To reproduce the second affected adapter, rerun the same command with the following inline JavaScript inserted after `import_evidence_bundle` and before the call-path loop. It creates authenticated managed declarations and a complete empty native-export inventory from the canonical repository example: ```js const { MANAGED_NATIVE_VERIFICATION_EXAMPLE: example } = await import('./dist/contracts/managed/managedWorkflowExamples.js'); const native = example.native_observations[0]; const emptyNative = createEvidence({ path: 'native.bin', sha256: native.subject.digest.sha256, format: 'mach-o', architecture: 'x86_64' }, native.provider, { operation: 'inspect_macho', parameters: {}, result: { ...native.normalized_result, exports: { items: [], total: 0, exhaustive: true, limitations: [] } } }); for (const name of ['missing_one', 'missing_two']) { const base = example.managed_boundaries; const managed = createEvidence(undefined, base.provider, { operation: base.operation, parameters: {}, result: { ...base.normalized_result, pinvoke_imports: base.normalized_result.pinvoke_imports.map(item => ({ ...item, import_name: name })) } }); const reply = await client.callTool({ name: 'verify_managed_native_boundaries', arguments: { managed_boundaries: managed, native_observations: [emptyNative] } }); console.log(name, reply.isError === true, reply.structuredContent?.normalized_result?.summary?.unresolved ?? null); } ``` The recorded reproduction used dependencies and the compiled runtime already present. The clean-checkout installation and build commands above are preparation instructions. ### Expected behavior Both goal requests should return complete call-path Evidence with `status: "unknown"` and the missing callee limitation. An unresolved result from an earlier, distinct request must not prevent recording and returning a later result. Repeating the original request should remain supported. Both distinct unresolved managed imports should return their verification results. `src/contracts/sessionToolContracts.ts:125` advertises missing call-path dossiers as unknown. `src/contracts/managed/managedWorkflowToolContracts.ts:116` promises preservation of unresolved managed/native states. `docs/tool-design.md:57` requires unresolved relationships and partial facts to remain visible. ### Impact and scope Impact level: P2, supported. Distinct valid investigations that retain unresolved results fail after the first result on a connection, and the failed call does not return its requested Evidence. This was observed in both call-path reconstruction and managed/native verification. Other tools using the same pattern were not executed. Workaround status: available. The previously blocked request succeeds after closing and reimporting only the source Evidence. Closing clears the retained investigation, so export useful results first and keep unresolved workflows on separate fresh connections when their session history must remain available. ### REA version 6.4.0 (main at 8dde6370d0809ad04cda3342d4e6f290f48aa063) ### Runtime and platform Node.js v26.10.0 on macOS 27.0.1. Host architecture was not recorded in the reproduction evidence. The managed/native fixture declares an `x86_64` Mach-O subject; that is target metadata, not an observation of host architecture. ### Target and artifact context Portable authenticated Evidence fixtures, with a function-only canonical Evidence bundle for `sample.bin`, Mach-O format, an all-zero 64-character SHA-256 fixture digest, a start function at `0x1000`, and a missing direct callee at `0x2000`. The additional managed/native probe uses `native.bin`, Mach-O `x86_64`, the example's native subject digest, and a complete empty export inventory. All bundle content is generated inline; no physical target binary or analysis engine is required or executed. ### Interface MCP ### Earliest failure stage Artifact or evidence registration ### Relevant output or evidence The second distinct goal returned this observed error instead of structured call-path Evidence: ```text {"error":{"code":"revision_conflict","category":"execution_failure","message":"Evidence state changed before the update completed. Refresh the current state and try again.","retryable":true,"remediation":{"action":"Evidence state changed before the update completed. Refresh the current state and try again."},"details":{"reason":"already-exists"}}} ``` The first goal and its replay returned `status: "unknown"`; `list_unknowns` reported one call-path unknown. Closing and reimporting the original bundle restored `status: "unknown"` for the previously blocked goal. The managed/native probe returned `summary.unresolved: 1` for `missing_one`, followed by the same error for `missing_two`. These results came from executed stdio MCP calls; the reproduction was complete and locally reproduced. ### Typed outcome or recovery expected On one connection, run both distinct unresolved call paths and require both to return their complete unknown Evidence without a registry conflict. Repeat the original request and verify that the retained records and unknown references remain consistent. Run both distinct unresolved managed imports and require both verification results to remain available. Preserve rejection of an explicit `record_unknown` request that duplicates an existing stable identity; successful automatic recording must preserve that separate contract. The repeated original goal is the discriminating valid-input/replay control. Close/reimport is the demonstrated recovery control, not a replacement for successful retention of both distinct results in one investigation. ### Analysis or suspected cause Source-derived reasoning: `src/server/registerInvestigationTools.ts:147` records different call-path results with the same question and domain, and `src/server/registerInvestigationTools/helpers.ts:49` passes that question to derived Evidence recording. `src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts:87` uses the same pattern for the second observed tool. `src/application/investigation/EvidenceLedger.ts:280` rejects a later differing unknown revision with `already-exists`. This source reasoning explains the observed failures but does not establish execution of other tools that use a similar pattern. ### Additional context - [#719](https://github.com/morluto/rea/issues/719) reported the same retained-session collision pattern in process comparisons and was closed as completed by [#732](https://github.com/morluto/rea/pull/732), which scopes automatic comparison questions to their immutable Evidence identity. This report concerns the corresponding failure still present in call-path and managed/native verification; that completed repair was limited to process comparisons. - [#1723](https://github.com/morluto/rea/issues/1723) concerned edge-whitespace normalization causing an unknown revision digest failure, rather than a second distinct result colliding with an existing identity. - [#1724](https://github.com/morluto/rea/issues/1724) concerned omitted caller-selected intent in successful manual unknown-update mutation Evidence, rather than failed automatic registration. - [#2621](https://github.com/morluto/rea/issues/2621) concerned an extra duplicate-ID diagnostic for an invalid managed/native request, rather than registration failure for valid unresolved requests. - [#3201](https://github.com/morluto/rea/issues/3201) concerns false managed/native module contradictions when module identity is missing; this report concerns distinct unresolved results failing automatic retention. - [#2322](https://github.com/morluto/rea/issues/2322) and [#2550](https://github.com/morluto/rea/issues/2550) concerned forward-search coverage preventing `not_found`; the current inputs genuinely lack a callee dossier and should retain separate `unknown` results.

bsakaguchi commented

2026-10-15 18:31:58 +00:00

Author

Owner

@xu91102 commented on GitHub (Oct 14, 2026):

Confirmed on clean main 322506d0c0d39d3cd1e2e1c285c2cc23cfa73ee7, with the locked dependencies, Node 24.18.0 and the production stdio MCP server on macOS arm64.

On one connection, goal 0x3000 returns unknown, goal 0x4000 returns revision_conflict / already-exists with no structured result, and replaying 0x3000 still succeeds. Only one call-path unknown is retained. Closing and reimporting the original function bundle lets 0x4000 succeed. The managed/native example also reproduces: missing_one returns one unresolved declaration, while missing_two fails. Both use canonical, self-owned Evidence; no target binary or external analysis engine runs.

The registry is correctly rejecting different revisions of the same unknown identity. The automatic workflow record uses a fixed question/domain while its supporting derived Evidence changes. I am preparing a correction at their shared record owner so distinct derived results coexist, with same-result replay, source/Evidence closure, bundle retention, atomic rollback and genuine manual/optimistic conflict controls preserved. I will link the PR after verification; this comment records current reproduction rather than a completed fix.

@xu91102 commented on GitHub (Oct 14, 2026): Confirmed on clean main `322506d0c0d39d3cd1e2e1c285c2cc23cfa73ee7`, with the locked dependencies, Node 24.18.0 and the production stdio MCP server on macOS arm64. On one connection, goal `0x3000` returns `unknown`, goal `0x4000` returns `revision_conflict` / `already-exists` with no structured result, and replaying `0x3000` still succeeds. Only one call-path unknown is retained. Closing and reimporting the original function bundle lets `0x4000` succeed. The managed/native example also reproduces: `missing_one` returns one unresolved declaration, while `missing_two` fails. Both use canonical, self-owned Evidence; no target binary or external analysis engine runs. The registry is correctly rejecting different revisions of the same unknown identity. The automatic workflow record uses a fixed question/domain while its supporting derived Evidence changes. I am preparing a correction at their shared record owner so distinct derived results coexist, with same-result replay, source/Evidence closure, bundle retention, atomic rollback and genuine manual/optimistic conflict controls preserved. I will link the PR after verification; this comment records current reproduction rather than a completed fix.

bsakaguchi referenced this issue

2026-10-17 21:09:25 +00:00

[PR #1202] [MERGED] fix(cli): complete cleanup after relayed interrupts #2716

bsakaguchi closed this issue

2026-10-31 00:30:05 +00:00

bsakaguchi commented

2026-10-31 00:30:05 +00:00

Author

Owner

@morluto commented on GitHub (Oct 19, 2026):

Fixed on main in 95c8f57aa.

Root cause: automatic producers reused fixed question/domain identities while putting the result Evidence ID only in supporting links. Supporting links do not scope Unknown identity. Distinct derived workflows therefore conflicted; composed-workflow and process-capture producers instead caught the duplicate and silently retained only the earlier Evidence link.

A shared application constructor now scopes automatic questions to immutable result Evidence, validates the original question before adding that scope, and returns tagged failures. Investigation workflows, both managed workflows, composed CLI/MCP workflow residuals and process-capture residuals consume it. Explicit/manual creation, guarded updates, existing retained records and their identities are preserved. The superseded single-result call-path test was removed. PR #3503 at exact head 28726f8af was reviewed and its author Dragolone credited; the PR was not merged. The broader producer scan and shared owner also address cases beyond that proposal.

Executed validation: 86 focused tests across 14 files; 3 existing process-consumer tests; final 9-test native-API rerun; full static/type/format/module/architecture checks, docs checks (5 conformance tests), discovery of all 1,601 files and hooks/pre-push checks. Public regressions cover distinct unresolved call paths, reconstruction, managed member comparisons, managed/native verification, unavailable native API observations and process captures, with source-link and same-immutable-Evidence replay controls. Manual duplicate creation still rejects. Baseline REDs and whitespace/blank-question/error regressions were retained. Process coverage uses existing controlled Node fixture captures; Ghidra responses are controlled wire fixtures, not execution of Ghidra/Hopper/IDA.

Snapshot replay can add meaningful provenance and yield a different Evidence ID even when normalized facts match. Both immutable results retain independent linked questions; an exact warm Evidence replay is idempotent. No implicit support merging or inference that distinct provenance is equivalent was introduced.

Six final compiled SDK control workflows (plus six retained preliminary measurements and one smoke run) compared discovery, bundle import, unresolved call-path creation, exact repeat and list_unknowns. Normalized path, result Evidence ID, exact-repeat retained bundle and 207-tool catalog hash matched. Repeated-process medians: elapsed 2.549→2.566 s, CPU 3.318→3.339 s, sampled process-family RSS 735.3→739.0 MB. Serialized request estimate stayed 883 cl100k tokens; SDK replies including the entire catalog were 809,304→809,374. These are descriptive tiny-task measurements, not actual model-context, true cold-cache, speedup, large/fault-cost or cross-platform/provider qualification claims. Existing exported unknowns remain valid; old sessions are not backfilled with links already discarded before the fix.

DeepWiki was checked for navigation; its suggestion that mutation Evidence IDs inherently scope Unknown identity, and that ignoring duplicate errors prevents loss, was rejected against the current identity owner and the executed regressions.

@morluto commented on GitHub (Oct 19, 2026): Fixed on main in [95c8f57aa](https://github.com/morluto/rea/commit/95c8f57aa). Root cause: automatic producers reused fixed question/domain identities while putting the result Evidence ID only in supporting links. Supporting links do not scope Unknown identity. Distinct derived workflows therefore conflicted; composed-workflow and process-capture producers instead caught the duplicate and silently retained only the earlier Evidence link. A shared application constructor now scopes automatic questions to immutable result Evidence, validates the original question before adding that scope, and returns tagged failures. Investigation workflows, both managed workflows, composed CLI/MCP workflow residuals and process-capture residuals consume it. Explicit/manual creation, guarded updates, existing retained records and their identities are preserved. The superseded single-result call-path test was removed. PR #3503 at exact head 28726f8af was reviewed and its author Dragolone credited; the PR was not merged. The broader producer scan and shared owner also address cases beyond that proposal. Executed validation: 86 focused tests across 14 files; 3 existing process-consumer tests; final 9-test native-API rerun; full static/type/format/module/architecture checks, docs checks (5 conformance tests), discovery of all 1,601 files and hooks/pre-push checks. Public regressions cover distinct unresolved call paths, reconstruction, managed member comparisons, managed/native verification, unavailable native API observations and process captures, with source-link and same-immutable-Evidence replay controls. Manual duplicate creation still rejects. Baseline REDs and whitespace/blank-question/error regressions were retained. Process coverage uses existing controlled Node fixture captures; Ghidra responses are controlled wire fixtures, not execution of Ghidra/Hopper/IDA. Snapshot replay can add meaningful provenance and yield a different Evidence ID even when normalized facts match. Both immutable results retain independent linked questions; an exact warm Evidence replay is idempotent. No implicit support merging or inference that distinct provenance is equivalent was introduced. Six final compiled SDK control workflows (plus six retained preliminary measurements and one smoke run) compared discovery, bundle import, unresolved call-path creation, exact repeat and list_unknowns. Normalized path, result Evidence ID, exact-repeat retained bundle and 207-tool catalog hash matched. Repeated-process medians: elapsed 2.549→2.566 s, CPU 3.318→3.339 s, sampled process-family RSS 735.3→739.0 MB. Serialized request estimate stayed 883 cl100k tokens; SDK replies including the entire catalog were 809,304→809,374. These are descriptive tiny-task measurements, not actual model-context, true cold-cache, speedup, large/fault-cost or cross-platform/provider qualification claims. Existing exported unknowns remain valid; old sessions are not backfilled with links already discarded before the fix. [DeepWiki was checked for navigation](https://deepwiki.com/search/in-current-source-how-is-stabl_05ed12c8-0890-4436-b7bf-71df301d7622); its suggestion that mutation Evidence IDs inherently scope Unknown identity, and that ignoring duplicate errors prevents loss, was rejected against the current identity owner and the executed regressions.

No milestone

No project

No assignees

1 participant

Notifications

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

morluto/rea#1202

No description provided.

Rows
Columns