@eyeauras/insight-cli 0.3.2 → 0.4.0

package/dist/src/inline-script.js

@@ -0,0 +1,62 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, writeFile, readFile, open } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { object, fail } from './model.js';
+export const inlineSourceHash = (code) => createHash('sha256').update(code, 'utf8').digest('hex');
+/** Native facts come from the fixed helper's receipt, never from caller console output. */
+export function inlineReceipt(raw, expected) {
+    const r = object(raw), execution = object(r.execution), build = object(r.compilerOutput);
+    if (r.protocol !== 'insight-inline-v1' || r.attemptId !== expected.attemptId || r.requestId !== expected.requestId || r.sourceSha256 !== expected.sourceSha256 ||
+        typeof r.success !== 'boolean' || !['prepare', 'compile', 'load', 'initialize', 'construct', 'execute'].includes(String(execution.stage)) ||
+        !['not_started', 'may_have_started'].includes(String(execution.userCode)) || ![false, null].includes(execution.entrypointInvoked) ||
+        typeof build.text !== 'string' || Buffer.byteLength(build.text) > 32772 || typeof build.truncated !== 'boolean' ||
+        typeof r.console_output !== 'string' || Buffer.byteLength(r.console_output) > 32772 || typeof r.outputTruncated !== 'boolean')
+        fail('partial', 'Native inline-script receipt is absent, malformed or belongs to another attempt.');
+    if (r.success === false) {
+        const d = object(r.diagnostic);
+        if (typeof d.kind !== 'string' || typeof d.message !== 'string' || d.message.length > 2048)
+            fail('partial', 'Native inline-script failure omitted its diagnostic.');
+    }
+    if (r.success === true && (execution.userCode !== 'may_have_started' || execution.stage !== 'execute'))
+        fail('partial', 'Native inline-script completion contradicts its execution facts.');
+    const safe = r.success === false && execution.userCode === 'not_started' && execution.entrypointInvoked === false && ['prepare', 'compile', 'load'].includes(String(execution.stage));
+    if (execution.userCode === 'not_started' && !safe)
+        fail('partial', 'Native inline-script non-execution facts contradict their stage.');
+    return { response: r, safe };
+}
+export async function runInline(http, program, root, parameters, requestId) {
+    if (typeof parameters.code !== 'string' || Buffer.byteLength(parameters.code) > 1048576 || parameters.code.includes('\0'))
+        fail('invalid', 'Inline Java source must contain at most one MiB of UTF-8 text without NUL.');
+    const attemptId = randomUUID(), sourceSha256 = inlineSourceHash(parameters.code), directory = join(root, 'inline-attempts', attemptId);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const request = join(directory, 'request.json');
+    await writeFile(request, JSON.stringify({ attemptId, requestId, sourceSha256, code: parameters.code, args: parameters.args ?? '' }), { mode: 0o600, flag: 'wx' });
+    const name = 'InsightInlineScript_' + randomUUID().replaceAll('-', ''), source = await readFile(new URL('../../references/native/InsightInlineScript.java', import.meta.url), 'utf8');
+    // Only this fixed shim enters the upstream provider. User source is compiled separately.
+    const ack = object(await http.call('/run_script_inline', { program, code: source.replace('public class InsightInlineScript ', 'public class ' + name + ' '), args: Buffer.from(request, 'utf8').toString('base64') }));
+    if (ack.success !== true || typeof ack.console_output !== 'string' || !ack.console_output.includes('INSIGHT_INLINE_COMPLETE'))
+        fail('partial', 'Native inline-script executor did not acknowledge its completed attempt.');
+    const handle = await open(join(directory, 'receipt.json'), constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    let raw;
+    try {
+        const maximum = 1048576, stat = await handle.stat();
+        if (!stat.isFile() || stat.size > maximum)
+            fail('partial', 'Native inline-script receipt exceeds its bound.');
+        const bytes = Buffer.alloc(maximum + 1);
+        let length = 0;
+        while (length < bytes.length) {
+            const next = await handle.read(bytes, length, bytes.length - length, null);
+            if (!next.bytesRead)
+                break;
+            length += next.bytesRead;
+        }
+        if (length > maximum)
+            fail('partial', 'Native inline-script receipt exceeds its bound.');
+        raw = JSON.parse(bytes.subarray(0, length).toString('utf8'));
+    }
+    finally {
+        await handle.close();
+    }
+    return inlineReceipt(raw, { attemptId, requestId, sourceSha256 });
+}

package/dist/src/internal-timing.d.ts

@@ -0,0 +1,3 @@
+/** Internal diagnostics only: fixed operation names, never argv, payloads, paths or errors. */
+export declare function timed<T>(phase: string, operation: string, action: () => Promise<T>): Promise<T>;
+export declare function traceCommand<T>(root: string, command: string, action: () => Promise<T>): Promise<T>;

package/dist/src/internal-timing.js

@@ -0,0 +1,52 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+import { mkdir, appendFile, stat, rename } from 'node:fs/promises';
+import { join } from 'node:path';
+import { performance } from 'node:perf_hooks';
+const current = new AsyncLocalStorage(), writes = new Map();
+/** Internal diagnostics only: fixed operation names, never argv, payloads, paths or errors. */
+export async function timed(phase, operation, action) {
+    const trace = current.getStore();
+    if (!trace)
+        return action();
+    const span = randomUUID(), started = performance.now();
+    let outcome = 'success';
+    try {
+        return await current.run({ ...trace, parent: span }, action);
+    }
+    catch (error) {
+        outcome = 'failure';
+        throw error;
+    }
+    finally {
+        if (trace.rows.length < 1024)
+            trace.rows.push({ trace: trace.id, span, parent: trace.parent ?? null, command: trace.command, phase, operation, startedMs: started - trace.started, durationMs: performance.now() - started, outcome });
+        else
+            trace.overflow.count++;
+    }
+}
+export async function traceCommand(root, command, action) {
+    const trace = { id: randomUUID(), command, started: performance.now(), rows: [], overflow: { count: 0 } }, at = new Date().toISOString();
+    try {
+        return await current.run(trace, () => timed('facade.command', command, action));
+    }
+    finally {
+        const directory = join(root, 'diagnostics'), path = join(directory, 'timings.jsonl'), previous = writes.get(path) ?? Promise.resolve();
+        const pending = previous.catch(() => { }).then(async () => {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            if (await stat(path).then(s => s.size, () => 0) > 8 * 1024 ** 2)
+                await rename(path, path + '.previous');
+            await appendFile(path, trace.rows.map(row => JSON.stringify({ schema: 1, at, ...row, droppedSpans: trace.overflow.count })).join('\n') + '\n', { mode: 0o600 });
+        });
+        writes.set(path, pending);
+        // Telemetry loss cannot change an acknowledged program operation into a failed write.
+        try {
+            await pending;
+        }
+        catch { }
+        finally {
+            if (writes.get(path) === pending)
+                writes.delete(path);
+        }
+    }
+}

package/dist/src/lifecycle.js

@@ -1,4 +1,4 @@
-import { command, Permission } from '@eyeauras/cli-factory';
+import { command, Permission, CliError } from '@eyeauras/cli-factory';
 import { scope } from './research.js';
 import { id, fail, object, digest } from './model.js';
 import { selectedOptions } from './arguments.js';
@@ -24,13 +24,23 @@ export class Lifecycle {
     async change(selected, operation, callerId) {
         const reserved = this.workspace.reserveRequest(selected, 'ghidra.' + operation, {}, callerId);
         return this.research.ordered(selected, async () => {
-            const request = this.workspace.request(reserved.request.id);
+            let request = this.workspace.request(reserved.request.id), backend;
+            if (reserved.replay && ['running', 'unknown'].includes(request.state)) {
+                backend = await this.backend();
+                await this.research.reconcileRequests(selected, backend);
+                request = this.workspace.request(request.id);
+            }
             if (reserved.replay && request.state !== 'accepted') {
                 if (request.state === 'applied')
                     return request.result;
-                fail('unknown', 'This lifecycle outcome is retained; it is not re-executed.', request.result);
+                throw new CliError('This lifecycle outcome remains unresolved; inspect its retained worker before retrieving it again.', {
+                    code: 'coordinator.unknown', result: { ...selected, state: request.state, requestId: request.callerId ?? request.id },
+                    next: [['sessions', 'status', selected.session, '--target', selected.target],
+                        ...(operation === 'close' ? [['tools', 'processes', '--tool', 'ghidra', '--session', selected.session, '--target', selected.target]] : [['ghidra', 'open', '--session', selected.session, '--target', selected.target]])]
+                });
             }
-            const backend = await this.backend(), unresolved = this.workspace.unresolved(selected);
+            backend ??= await this.backend();
+            const unresolved = this.workspace.unresolved(selected);
             const closingExternal = operation === 'close' && unresolved.length > 0 && unresolved.every(intent => ['debugger', 'ui'].includes(String(object(intent.execution ?? {}).kind)));
             const alreadyEnded = closingExternal && backend.closed ? await backend.closed(selected) : false;
             if (!closingExternal)

package/dist/src/native-inputs.d.ts

@@ -11,7 +11,7 @@ export interface NativeInputs {
     extensionRoots?: string[];
     serverClasspath?: string;
 }
-export declare const pinnedMcpJar = "7084e2fda16dc779dd05398e48821ff3f9ace4d32757ea143b257b39689e5fbd";
+export declare const pinnedMcpJar = "f4a9272e911466ed774c8cf73bc1adf1daef6009d895fda57aa0b28522fcdf32";
 export declare const packagedMcpJar: string;
 /** Ghidra has its own cache/settings overrides in addition to Java's home/tmp properties. */
 export declare const nativeJvmDirectories: (root: string) => string[];

package/dist/src/native-inputs.js

@@ -9,7 +9,7 @@ import { promisify } from 'node:util';
 import { fail, stable, text } from './model.js';
 import { managedExtensions, extensionJvmArguments } from './extensions.js';
 import { runtimeValues, runtimeSelection } from './runtime-selection.js';
-export const pinnedMcpJar = '7084e2fda16dc779dd05398e48821ff3f9ace4d32757ea143b257b39689e5fbd';
+export const pinnedMcpJar = 'f4a9272e911466ed774c8cf73bc1adf1daef6009d895fda57aa0b28522fcdf32';
 export const packagedMcpJar = fileURLToPath(new URL('../../runtime/GhidraMCP-7.0.0.jar', import.meta.url));
 /** Ghidra has its own cache/settings overrides in addition to Java's home/tmp properties. */
 export const nativeJvmDirectories = (root) => ['-Duser.home=' + root, '-Djava.io.tmpdir=' + root,

package/dist/src/native-queries.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { object, fail } from './model.js';
 export async function nativeQuery(http, program, operation, parameters, write = false) {
-    const base = operation.startsWith('/sdk/') ? 'InsightSdkScript' : operation.startsWith('/emulate_') ? 'InsightEmulation' : 'InsightResearchQueries';
+    const base = operation === '/code_references' ? 'InsightCodeReferences' : operation.startsWith('/sdk/') ? 'InsightSdkScript' : operation.startsWith('/emulate_') ? 'InsightEmulation' : 'InsightResearchQueries';
     const name = base + '_' + randomUUID().replaceAll('-', '');
     const source = await readFile(new URL('../../references/native/' + base + '.java', import.meta.url), 'utf8');
     const response = object(await http.call('/run_script_inline', { program, code: source.replace('public class ' + base + ' ', 'public class ' + name + ' '),

package/dist/src/persistent-client.d.ts

@@ -0,0 +1,30 @@
+export declare class InsightCommandError extends Error {
+    readonly rpc: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+    constructor(rpc: {
+        code: number;
+        message: string;
+        data?: unknown;
+    });
+}
+export declare class InsightTransportError extends Error {
+    readonly dispatched: boolean;
+    constructor(message: string, dispatched: boolean);
+}
+export interface InsightConnectionOptions {
+    executable: string;
+    /** For example [installedBin] with executable: process.execPath. No shell is used. */
+    arguments?: readonly string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface InsightConnection {
+    execute<T = unknown>(argv: readonly string[]): Promise<T>;
+    /** Drain admitted requests, then end this transport. Does not stop the owner or Ghidra. */
+    close(): Promise<void>;
+}
+/** A thin client of Factory's existing stream, with no reconnect or command replay. */
+export declare function connectInsight(options: InsightConnectionOptions): Promise<InsightConnection>;

package/dist/src/persistent-client.js

@@ -0,0 +1,125 @@
+import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
+export class InsightCommandError extends Error {
+    rpc;
+    constructor(rpc) {
+        super(rpc.message);
+        this.rpc = rpc;
+        this.name = 'InsightCommandError';
+    }
+}
+export class InsightTransportError extends Error {
+    dispatched;
+    constructor(message, dispatched) {
+        super(message);
+        this.dispatched = dispatched;
+        this.name = 'InsightTransportError';
+    }
+}
+/** A thin client of Factory's existing stream, with no reconnect or command replay. */
+export async function connectInsight(options) {
+    const child = spawn(options.executable, [...(options.arguments ?? []), '--json-rpc'], { cwd: options.cwd, env: options.env, stdio: ['pipe', 'pipe', 'pipe'], shell: false });
+    const maximum = 4 * 1024 ** 2, decoder = new StringDecoder('utf8');
+    let buffer = '', bytes = 0, sequence = 0, accepting = true, failed = false, ended = false;
+    let closePromise, tail = Promise.resolve();
+    const pending = new Map();
+    // Drain diagnostics without retaining arbitrary stderr, paths, tokens or unbounded output.
+    child.stderr.resume();
+    const fail = (message) => {
+        if (failed)
+            return;
+        failed = true;
+        accepting = false;
+        for (const p of pending.values())
+            p.reject(new InsightTransportError(message, true));
+        pending.clear();
+        child.stdin.destroy();
+        child.stdout.destroy();
+    };
+    child.on('error', () => fail('Persistent CLI process failed.'));
+    child.stdout.on('error', () => fail('Persistent CLI output was lost.'));
+    child.stderr.on('error', () => fail('Persistent CLI diagnostic stream was lost.'));
+    child.stdin.on('error', () => fail('Persistent CLI input was lost; inspect request/status before retrying a changing command.'));
+    const exited = new Promise((resolve, reject) => {
+        child.once('close', (code, signal) => {
+            ended = true;
+            if (code !== 0 || signal || pending.size || buffer.trim()) {
+                fail('Persistent CLI closed without a complete acknowledged response.');
+                reject(new InsightTransportError('Persistent CLI transport ended unexpectedly.', false));
+            }
+            else if (failed)
+                reject(new InsightTransportError('Persistent CLI transport failed.', false));
+            else
+                resolve();
+        });
+    });
+    void exited.catch(() => { });
+    child.stdout.on('data', (chunk) => {
+        if (failed)
+            return;
+        buffer += decoder.write(chunk);
+        bytes += chunk.length;
+        if (bytes > maximum) {
+            fail('Persistent CLI response exceeded the bounded transport limit.');
+            return;
+        }
+        for (;;) {
+            const newline = buffer.indexOf('\n');
+            if (newline < 0)
+                break;
+            const line = buffer.slice(0, newline);
+            buffer = buffer.slice(newline + 1);
+            bytes = Buffer.byteLength(buffer);
+            if (!line.trim())
+                continue;
+            try {
+                const r = JSON.parse(line);
+                if (!r || r.jsonrpc !== '2.0' || typeof r.id !== 'number' || !pending.has(r.id) || Object.hasOwn(r, 'result') === Object.hasOwn(r, 'error'))
+                    throw Error();
+                const p = pending.get(r.id);
+                if (Object.hasOwn(r, 'error') && (!r.error || typeof r.error !== 'object' || typeof r.error.code !== 'number' || !Number.isInteger(r.error.code) || typeof r.error.message !== 'string'))
+                    throw Error();
+                pending.delete(r.id);
+                if (r.error)
+                    p.reject(new InsightCommandError(r.error));
+                else
+                    p.resolve(r.result);
+            }
+            catch {
+                fail('Persistent CLI returned a malformed or uncorrelated response.');
+                return;
+            }
+        }
+    });
+    await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', () => reject(new InsightTransportError('Could not start persistent CLI.', false))); });
+    return {
+        execute(argv) {
+            if (!Array.isArray(argv) || argv.length > 512 || argv.some(x => typeof x !== 'string' || x.includes('\0')) || Buffer.byteLength(JSON.stringify(argv)) > 1024 ** 2)
+                return Promise.reject(new TypeError('argv must be a bounded array of strings without NUL.'));
+            if (!accepting || failed || ended)
+                return Promise.reject(new InsightTransportError('Persistent CLI connection is closed.', false));
+            const args = [...argv];
+            const request = tail.then(() => {
+                if (failed || ended)
+                    throw new InsightTransportError('Persistent CLI connection was lost before dispatch.', false);
+                const id = ++sequence;
+                return new Promise((resolve, reject) => {
+                    pending.set(id, { resolve, reject });
+                    try {
+                        child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method: 'cli.execute', params: { argv: args } }) + '\n');
+                    }
+                    catch {
+                        fail('Persistent CLI input was lost; inspect request/status before retrying a changing command.');
+                    }
+                });
+            });
+            tail = request.catch(() => { });
+            return request;
+        },
+        close() {
+            accepting = false;
+            return closePromise ??= tail.then(async () => { if (!failed && !ended)
+                child.stdin.end(); await exited; });
+        }
+    };
+}

package/dist/src/queries.js

@@ -51,7 +51,7 @@ export function queryCommands(research) {
                 parameters[p.name] = parsed(p, input);
             }
             if (q.path === '/get_functions')
-                return research(c).inspectFunctions(scope(o), parameters, { limit: number(o.limitChars ?? 16000, 32768, 1), offset: number(o.offsetChars ?? 0, 4 * 1024 ** 2), total: number(o.totalChars ?? 64000, 128000, 1), ...(o.expectView === undefined ? {} : { expectView: String(o.expectView) }), ...(o.saveOwnerDirectory === undefined ? {} : { saveDirectory: String(o.saveOwnerDirectory) }) });
+                return research(c).inspectFunctions(scope(o), parameters, { limit: number(o.limitChars ?? 16000, 32768, 1), offset: number(o.offsetChars ?? 0, 4 * 1024 ** 2), total: number(o.totalChars ?? 64000, 128000, 1), ...(o.expectView === undefined ? {} : { expectView: String(o.expectView) }), ...(o.saveOwnerDirectory === undefined ? {} : { saveDirectory: String(o.saveOwnerDirectory) }), ...(o.resolveAddress === undefined ? {} : { resolveAddress: String(o.resolveAddress) }), ...(o.maxEntryDistance === undefined ? {} : { maxEntryDistance: number(o.maxEntryDistance, 65536, 1) }), ...(o.maxUnwindBytes === undefined ? {} : { maxUnwindBytes: number(o.maxUnwindBytes, 16777216, 1) }) });
             if (nativeQueries.has(q.path)) {
                 if (Number(parameters.timeout_seconds ?? 5) > 30)
                     fail('invalid', 'Native query timeout must be at most 30 seconds.');
@@ -65,6 +65,9 @@ export function queryCommands(research) {
                 await research(c).read(who, q.path, parameters);
             return { ...who, value: value(qualifyQuery(q.path, queryResult(q.path, parameters, value(result)))) };
         }, { permission: Permission.ReadOnly, options: [...selectedOptions, ...q.params.map(option), ...(q.path === '/get_functions' ? [
+                    { flags: '--resolve-address <mode>', description: 'containing-or-preceding or containing-or-pe-runtime; address selectors only' },
+                    { flags: '--max-entry-distance <bytes>', description: 'Required with containing-or-preceding: fallback distance 1–65536 within the same initialized executable block' },
+                    { flags: '--max-unwind-bytes <bytes>', description: 'PE runtime mode: 1–16777216 actual header/table bytes, default 4194304; fixed 5s cooperative lookup deadline' },
                     { flags: '--limit-chars <count>', description: 'Per-function Unicode window, 1–32768', defaultValue: 16000 },
                     { flags: '--offset-chars <count>', description: 'Per-function Unicode offset', defaultValue: 0 },
                     { flags: '--total-chars <count>', description: 'Total returned decompiler characters, 1–128000', defaultValue: 64000 },

package/dist/src/query-policy.js

@@ -1,6 +1,6 @@
 import { fail, object } from './model.js';
 /** These operations have facade-owned, bounded native implementations. */
-export const nativeQueries = new Set(['/research_view', '/decode_instructions', '/find_dead_code', '/detect_crypto_constants', '/get_valid_data_types',
+export const nativeQueries = new Set(['/code_references', '/navigation_diagnostic', '/research_view', '/decode_instructions', '/find_dead_code', '/detect_crypto_constants', '/get_valid_data_types',
     '/validate_data_type', '/validate_function_prototype', '/get_entry_points', '/list_globals',
     '/list_strings', '/search_strings', '/find_data_types', '/search_byte_patterns', '/search_instructions',
     '/emulate_function', '/emulate_hash_batch']);
@@ -25,6 +25,12 @@ const heuristics = Object.fromEntries([
             'Scores and confidence labels are not calibrated probabilities; the agent decides what to accept.',
         ] }]));
 export function queryDescription(path, fallback) {
+    if (path === '/force_decompile')
+        return 'Refresh decompiler output for an existing function entry; does not repair Listing or create functions';
+    if (path === '/disassemble_function')
+        return 'Read stored Listing instructions; for sparse/undefined code use functions decode';
+    if (path === '/get_functions')
+        return 'Inspect 1–20 functions; compact code/call edges: --fields decompiled_code,callees';
     if (path === '/find_dead_code')
         return 'Find blocks unreachable in the bounded static CFG; unresolved flow is reported';
     if (path === '/detect_crypto_constants')
@@ -39,6 +45,8 @@ export function queryDescription(path, fallback) {
         return 'Read external-entry metadata; report name/image-base candidates separately';
     if (path === '/list_globals')
         return 'Read structured global records with bounded symbol/reference scanning';
+    if (path === '/list_strings' || path === '/search_strings')
+        return 'Search defined string data only, with bounded visited-data scan; undefined literals: strings anchors';
     if (path.startsWith('/emulate_'))
         return 'Bounded isolated x86/x64 emulation with explicit ABI and termination reason';
     return heuristics[path] ? fallback + ' (qualified ' + heuristics[path].kind + '; not ground truth)' : fallback;

package/dist/src/research-view.d.ts

@@ -0,0 +1,6 @@
+/** Strip transport versioning from the existing logical observation and its identity digest. */
+export declare function researchView(raw: unknown): {
+    modification: string;
+    language: unknown;
+    compiler: unknown;
+};

package/dist/src/research-view.js

@@ -0,0 +1,9 @@
+import { object, fail } from './model.js';
+/** Strip transport versioning from the existing logical observation and its identity digest. */
+export function researchView(raw) {
+    const r = object(raw);
+    if (r.protocol !== 'insight-research-view-v1' || typeof r.modification !== 'string' || !/^\d{1,20}$/.test(r.modification) ||
+        !['language', 'compiler'].every(k => typeof r[k] === 'string' && r[k].length > 0 && r[k].length <= 256 && !r[k].includes('\0')))
+        fail('partial', 'Native research-view observation is malformed or unsupported.');
+    return { modification: r.modification, language: r.language, compiler: r.compiler };
+}

package/dist/src/research.d.ts

@@ -1,11 +1,18 @@
 import { type FunctionInspectionOptions } from './function-inspection.js';
+import { type AnchorRequest } from './string-anchors.js';
 import type { Artifact } from './artifacts.js';
 import type { GhidraContext, Scope, ScalarChange, Publication, DebuggerState, GhidraLoadSettings } from './workspace.js';
 import { Workspace } from './workspace.js';
 import type { ToolMode } from './contexts.js';
 import type { ScriptPage } from './scripts.js';
+import { type ReferenceRequest } from './code-references.js';
 export interface ResearchBackend {
+    inlineScript?(scope: Scope, parameters: Record<string, unknown>, requestId: string): Promise<{
+        response: Record<string, unknown>;
+        safe: boolean;
+    }>;
     observation?(scope: Scope): Promise<unknown>;
+    inspectObservation?(scope: Scope): Promise<unknown>;
     sdkFile?(operation: string, p: Record<string, unknown>): Promise<Record<string, unknown>>;
     archivePayloads?(scope: Scope, p: Record<string, unknown>): Promise<unknown>;
     debuggerStart?(scope: Scope): Promise<void>;
@@ -166,6 +173,36 @@ export declare class Research {
                 maximumCharacters: number;
                 returnedCharacters: number;
             };
+            boundaryLookup?: Record<string, unknown> | undefined;
+        };
+        session: string;
+        target: string;
+    }>;
+    stringAnchors(selected: Scope, request: AnchorRequest): Promise<{
+        value: {
+            view: {
+                identity: string;
+            };
+            cursor: string | null;
+        };
+        session: string;
+        target: string;
+    }>;
+    codeReferences(selected: Scope, request: ReferenceRequest): Promise<{
+        value: {
+            view: {
+                identity: string;
+            };
+            cursor: string | null;
+        };
+        session: string;
+        target: string;
+    }>;
+    navigation(selected: Scope, maximum: number): Promise<{
+        value: {
+            initialAnalysis: string;
+            priorAnalysis: string;
+            provenance: string;
         };
         session: string;
         target: string;
@@ -210,6 +247,7 @@ export declare class Research {
         expectedShared: string | null;
     }): Promise<unknown>;
     private sharedOrder;
+    reconcileRequests(selected: Scope, backend: ResearchBackend): Promise<void>;
     private reconcile;
     merge(selected: Scope, callerId?: string): Promise<unknown>;
     refresh(selected: Scope, callerId?: string): Promise<unknown>;