@eyeauras/insight-cli 0.3.1 → 0.4.0

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>;

package/dist/src/research.js

@@ -1,11 +1,16 @@
 import { textWindow } from './text-window.js';
 import { functionResult, functionFailure } from './function-results.js';
 import { inspectFunctions } from './function-inspection.js';
+import { entryRequest } from './function-entries.js';
+import { inspectAnchors } from './string-anchors.js';
 import { fail, id, object, text, digest } from './model.js';
 import { fieldKey, scalarMerge, scalarRefresh } from './merge.js';
 import { verifyMutation } from './mutation-effects.js';
 import { transferResult } from './cross-results.js';
 import { CliError } from '@eyeauras/cli-factory';
+import { timed } from './internal-timing.js';
+import { navigationResult } from './context-diagnostics.js';
+import { inspectCodeReferences } from './code-references.js';
 export function address(value) {
     const input = text(value, 128);
     const match = /^(?:([A-Za-z0-9_]+):)?(?:0x)?([a-fA-F0-9]+)$/.exec(input);
@@ -66,7 +71,7 @@ export class Research {
     }
     async ordered(selected, action) {
         const key = this.workspace.context(selected).id, previous = this.tasks.get(key);
-        const task = (previous ? previous.catch(() => { }) : Promise.resolve()).then(action);
+        const task = timed('facade.queue', 'research', async () => { await previous?.catch(() => { }); }).then(action);
         this.tasks.set(key, task);
         try {
             return await task;
@@ -77,7 +82,7 @@ export class Research {
         }
     }
     async boundary(selected, action) {
-        const key = 'command:' + this.workspace.context(selected).id, previous = this.tasks.get(key), task = (previous ? previous.catch(() => { }) : Promise.resolve()).then(action);
+        const key = 'command:' + this.workspace.context(selected).id, previous = this.tasks.get(key), task = timed('facade.queue', 'command', async () => { await previous?.catch(() => { }); }).then(action);
         this.tasks.set(key, task);
         try {
             return await task;
@@ -147,10 +152,14 @@ export class Research {
                 return opened(request.result);
             if (reserved.replay && request.state !== 'accepted')
                 throw new CliError('This open retains an unproved outcome; inspect the retained context before continuing.', { code: 'coordinator.unknown', result: retained(request.state), next });
-            if (this.workspace.unresolved(reserved.context).some(other => other.id !== request.id)) {
+            const unresolved = this.workspace.unresolved(reserved.context).filter(other => other.id !== request.id);
+            if (unresolved.length) {
                 const result = { session: reserved.context.session, target, state: 'blocked' };
                 this.workspace.recordRequest(request.id, 'failed', result);
-                fail('blocked', 'This context retains an unproved effect; continuation did not start a second operation.', result);
+                const close = unresolved.find(other => other.operation === 'ghidra.close');
+                throw new CliError('This context retains an unproved effect; continuation did not start a second operation.', {
+                    code: 'coordinator.blocked', result, next: close ? [['ghidra', 'close', '--session', reserved.context.session, '--target', target, '--request-id', close.callerId ?? close.id]] : next
+                });
             }
             this.workspace.startRequest(request.id);
             try {
@@ -292,13 +301,48 @@ export class Research {
         });
     }
     async inspectFunctions(selected, parameters, options) {
+        const lookup = entryRequest(parameters, options);
         return this.ordered(selected, async () => {
             const backend = await this.backend();
             await backend.open(selected);
             const context = this.workspace.context(selected);
-            const observation = await backend.observation?.(selected);
+            const observe = backend.inspectObservation ? () => backend.inspectObservation(selected) : backend.observation ? () => backend.observation(selected) : undefined;
+            if (lookup && !observe)
+                fail('unsupported', 'Address resolution requires guarded native observations.');
+            const observation = await observe?.();
             const view = { revision: revision(context.baseRevision), identity: digest({ target: selected.target, context: context.id, generation: context.generation, snapshot: context.workingSnapshot, epoch: context.viewEpoch ?? 0, observation }) };
-            return inspectFunctions(backend, selected, parameters, options, view, observation);
+            return inspectFunctions(backend, selected, parameters, options, view, observation, observe);
+        });
+    }
+    async stringAnchors(selected, request) {
+        return this.ordered(selected, async () => {
+            const backend = await this.backend();
+            await backend.open(selected);
+            const observe = backend.inspectObservation ? () => backend.inspectObservation(selected) : backend.observation ? () => backend.observation(selected) : undefined;
+            if (!observe)
+                fail('unsupported', 'String anchors require guarded native observations.');
+            const context = this.workspace.context(selected), observation = await observe();
+            const view = digest({ target: selected.target, context: context.id, generation: context.generation, snapshot: context.workingSnapshot, epoch: context.viewEpoch ?? 0, observation });
+            return inspectAnchors(backend, selected, request, view, observation, observe);
+        });
+    }
+    async codeReferences(selected, request) {
+        return this.ordered(selected, async () => {
+            const backend = await this.backend();
+            await backend.open(selected);
+            if (!backend.observation)
+                fail('unsupported', 'Code-reference continuation requires native view observation.');
+            const context = this.workspace.context(selected), observation = await backend.observation(selected);
+            const view = digest({ target: selected.target, context: context.id, generation: context.generation, snapshot: context.workingSnapshot, epoch: context.viewEpoch ?? 0, observation });
+            return inspectCodeReferences(backend, selected, request, view, observation);
+        });
+    }
+    async navigation(selected, maximum) {
+        return this.ordered(selected, async () => {
+            const backend = await this.backend();
+            await backend.open(selected);
+            const value = navigationResult(await backend.call(selected, '/navigation_diagnostic', { max_scan: maximum }), maximum);
+            return { ...selected, value: { ...value, initialAnalysis: this.workspace.model(selected.target).settings.autoAnalyze ? 'requested' : 'none', priorAnalysis: 'unknown', provenance: 'Initial facade policy only; imported/saved metadata may have an unknown analysis history.' } };
         });
     }
     async xrefs(selected, at, limit, offset) {
@@ -428,6 +472,9 @@ export class Research {
                 this.tasks.delete(key);
         }
     }
+    async reconcileRequests(selected, backend) {
+        return this.sharedOrder(selected.target, () => this.reconcile(selected, backend));
+    }
     async reconcile(selected, backend) {
         const active = this.workspace.activePublication(selected.target);
         if (active) {
@@ -541,7 +588,7 @@ export class Research {
                     if (!await backend.closed(selected))
                         continue;
                     const current = this.workspace.context(selected);
-                    this.workspace.completeSavedRequest(selected, request.id, current.generation, {}, { ...selected, state: 'closed', pendingChanges: count(current) });
+                    this.workspace.completeSavedRequest(selected, request.id, current.generation, { state: 'stopped' }, { ...selected, state: 'closed', pendingChanges: count(current) });
                 }
                 catch { /* A stopped metadata flag alone never proves process release. */ }
                 continue;
@@ -794,6 +841,10 @@ export class Research {
             if (reserved.replay && request.state !== 'accepted') {
                 if (request.state === 'applied')
                     return request.result;
+                if (operation === '/run_script_inline' && request.state === 'failed' && object(request.result ?? {}).reason === 'script_not_executed') {
+                    const result = object(request.result), execution = object(result.execution);
+                    fail('script.' + String(execution.stage), String(object(result.diagnostic).message), result);
+                }
                 if (operation.startsWith('/sdk/') && request.state === 'failed' && object(request.result ?? {}).state === 'rejected')
                     fail('rejected', 'This SDK transaction was rolled back and is not repeated.', request.result);
                 fail('unknown', 'This saved-state operation retains an unresolved outcome; it is not re-executed.', request.result);
@@ -807,7 +858,24 @@ export class Research {
                 savedVerification: !!verifySaved });
             let savedSnapshot, phase = 'operation';
             try {
-                const raw = await backend.call(selected, operation, parameters), response = raw && typeof raw === 'object' && !Array.isArray(raw) ? object(raw) : { output: raw };
+                let raw;
+                if (operation === '/run_script_inline' && backend.inlineScript) {
+                    const attempt = await backend.inlineScript(selected, parameters, request.id);
+                    raw = attempt.response;
+                    if (attempt.response.success === false) {
+                        const result = { ...selected, requestId: request.callerId ?? request.id, state: attempt.safe ? 'rejected' : 'unknown',
+                            contextState: attempt.safe ? 'ready' : 'needs_recovery', reason: attempt.safe ? 'script_not_executed' : 'script_execution_not_proven_complete',
+                            execution: attempt.response.execution, diagnostic: attempt.response.diagnostic, diagnostics: attempt.response.diagnostics,
+                            diagnosticsTruncated: attempt.response.diagnosticsTruncated, compilerOutput: attempt.response.compilerOutput,
+                            output: attempt.response.console_output, outputTruncated: attempt.response.outputTruncated };
+                        if (attempt.safe)
+                            this.workspace.recordRequest(request.id, 'failed', result);
+                        fail('script.' + String(object(attempt.response.execution).stage), String(object(attempt.response.diagnostic).message), result);
+                    }
+                }
+                else
+                    raw = await backend.call(selected, operation, parameters);
+                const response = raw && typeof raw === 'object' && !Array.isArray(raw) ? object(raw) : { output: raw };
                 if (['rejected', 'partial', 'failed', 'error'].includes(String(response.status)) || response.success === false)
                     fail('partial', 'Program operation reported a rejected or incomplete effect.');
                 if (!verifySaved && response.success !== true && response.status !== 'success')
@@ -825,6 +893,8 @@ export class Research {
                 return result;
             }
             catch (error) {
+                if (operation === '/run_script_inline' && this.workspace.request(request.id).state === 'failed' && object(this.workspace.request(request.id).result ?? {}).reason === 'script_not_executed')
+                    throw error;
                 if (operation.startsWith('/sdk/') && String(error.code).endsWith('.rejected')) {
                     this.workspace.recordRequest(request.id, 'failed', { ...selected, state: 'rejected', reason: 'native_transaction_rolled_back' });
                     throw error;

package/dist/src/string-anchors.d.ts

@@ -0,0 +1,43 @@
+import { type CommandContext } from '@eyeauras/cli-factory';
+import { type Research, type ResearchBackend } from './research.js';
+import type { Scope } from './workspace.js';
+export declare const anchorAlgorithm = "raw-string-anchors-v1";
+export declare const anchorEncodings: readonly ["ascii", "utf16le"];
+type Encoding = typeof anchorEncodings[number];
+interface Frontier {
+    address: string;
+    encoding: Encoding;
+}
+interface Query {
+    text: string;
+    encodings: Encoding[];
+    start: string;
+    end: string;
+    cap: number;
+}
+interface Budgets {
+    max_bytes: number;
+    max_candidates: number;
+    timeout_seconds: number;
+    limit: number;
+}
+export interface AnchorRequest {
+    query: Query;
+    from: Frontier;
+    budgets: Budgets;
+    expectedView?: string;
+}
+export declare function anchorRequest(o: Record<string, unknown>, who: Scope): AnchorRequest;
+export declare function anchorResult(raw: unknown, r: AnchorRequest, modification: string): Record<string, unknown>;
+export declare function inspectAnchors(backend: ResearchBackend, who: Scope, r: AnchorRequest, view: string, observation: unknown, observe: () => Promise<unknown>): Promise<{
+    value: {
+        view: {
+            identity: string;
+        };
+        cursor: string | null;
+    };
+    session: string;
+    target: string;
+}>;
+export declare function stringAnchorCommands(research: (c: CommandContext) => Research): import("@eyeauras/cli-factory").CommandDefinition[];
+export {};