@eyeauras/insight-cli 0.3.2 → 0.4.0

package/runtime/research-view.provenance.json

@@ -0,0 +1,28 @@
+{
+  "schema": 1,
+  "upstreamSha256": "7084e2fda16dc779dd05398e48821ff3f9ace4d32757ea143b257b39689e5fbd",
+  "upstreamGitArtifact": "6e4bfc9:skills/ghidra-coordinator/runtime/GhidraMCP-7.0.0.jar",
+  "sha256": "f4a9272e911466ed774c8cf73bc1adf1daef6009d895fda57aa0b28522fcdf32",
+  "inputs": {
+    "skills/ghidra-coordinator/references/native/InsightResearchView.java": "78bd25f8a3d7a1bc640938d8497cd581c2c178915ae6003b19dceda507c34df2",
+    "skills/ghidra-coordinator/references/native/InsightStringAnchors.java": "e496ec2a28a57eb1447b11e3d0ec6d918f2d543857643b0e6c9f6c2a905b7f9d",
+    "skills/ghidra-coordinator/references/native/InsightAnchorScan.java": "2197d6dedd133d229a58876f8d164faaf178902646dea7bb4540197bacfcf105",
+    "skills/ghidra-coordinator/references/native/InsightFunctionBoundaries.java": "61eab3948186597ad22396eb029d61d2ddeb89a77d3969ea41ead55a38deb651",
+    "skills/ghidra-coordinator/references/native/InsightPeRanges.java": "2e82a7b2e908f29f6e68f6491549981cc709012186096a60ce10d5b15f29712b",
+    "scripts/native/InstallResearchView.java": "bf0a3e54f789eb14319cc14ce89d8fb78459be500fe53576eddb4b9d02c02f12",
+    "scripts/build-research-view-bridge.mjs": "490c6b3628be07da5afb3d7ae9efc6d216d139bf779ec38aa32233b2b563cfb8"
+  },
+  "asm": {
+    "version": "9.7.1",
+    "sha256": "8cadd43ac5eb6d09de05faecca38b917a040bb9139c7edeb4cc81c740b713281"
+  },
+  "jdk": "openjdk 21.0.11 2026-04-21\nOpenJDK Runtime Environment Homebrew (build 21.0.11)\nOpenJDK 64-Bit Server VM Homebrew (build 21.0.11, mixed mode, sharing)",
+  "change": "Add annotated ReadOnly services for research-view, indexed function entries raw string anchors and PE runtime boundaries to the pinned AnnotationScanner constructor; all other upstream class bytes unchanged except ZIP container metadata",
+  "endpoint": "/insight/research-view/v1",
+  "endpoints": [
+    "/insight/research-view/v1",
+    "/insight/function-entries/v1",
+    "/insight/string-anchors/v1",
+    "/insight/function-boundaries/v1"
+  ]
+}

package/runtime/toolbox.json

@@ -8,7 +8,9 @@
       "resources": {
         "references/agent-execution.md": "references/agent-execution.md",
         "references/storage.md": "references/storage.md",
-        "references/recovery.md": "references/recovery.md"
+        "references/recovery.md": "references/recovery.md",
+        "references/persistent.md": "references/persistent.md",
+        "references/persistent-client.mjs": "dist/src/persistent-client.js"
       }
     },
     {
@@ -19,7 +21,9 @@
         "references/recovery.md": "references/recovery.md",
         "references/artifacts.md": "references/artifacts.md",
         "references/agent-execution.md": "references/agent-execution.md",
-        "references/storage.md": "references/storage.md"
+        "references/storage.md": "references/storage.md",
+        "references/persistent.md": "references/persistent.md",
+        "references/persistent-client.mjs": "dist/src/persistent-client.js"
       }
     },
     {
@@ -29,6 +33,7 @@
       "resources": {
         "references/setup.md": "references/setup.md",
         "references/research.md": "references/research.md",
+        "references/sparse-navigation.md": "references/sparse-navigation.md",
         "references/query-semantics.md": "references/query-semantics.md",
         "references/native-workflows.md": "references/native-workflows.md",
         "references/recovery.md": "references/recovery.md",
@@ -39,7 +44,9 @@
         "references/extensions-and-sync.md": "references/extensions-and-sync.md",
         "references/artifacts.md": "references/artifacts.md",
         "references/agent-execution.md": "references/agent-execution.md",
-        "references/storage.md": "references/storage.md"
+        "references/storage.md": "references/storage.md",
+        "references/persistent.md": "references/persistent.md",
+        "references/persistent-client.mjs": "dist/src/persistent-client.js"
       }
     },
     {

package/skill-bundle/insight-artifacts/SKILL.md

@@ -3,7 +3,7 @@ name: insight-artifacts
 description: Retain a completed reverse-engineering evidence file or directory as an ordinary checkpoint using insight-cli artifacts save. Use after Ghidra or any external tool; preserve existing project formats and source of truth.
 ---
 
-# Insight Artifacts 0.3.2
+# Insight Artifacts 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-artifacts/references/recovery.md

@@ -24,11 +24,47 @@ establishes that the old owned bootstrap worker has ended, then uses an authorit
 probe. An absent canonical item permits private preparation; an existing first version requires
 independent readback. The old project, intent and original session/target remain preserved.
 
+## Interrupted save or close
+
+After restoring profile storage, inspect the selected session and target with
+`sessions status <session> --target <target>`. Retry the original save/close with the
+same `--request-id`. If the original command had no caller ID, use the generated
+`unresolvedRequests[].id` from status. This retrieves the original intent instead of
+creating another close. A verified stopped worker lets close report `state: closed`
+and retain the acknowledged private snapshot and pending changes; it sends no new save,
+open, close or publication. Reopen the same session/target afterward.
+
+If release cannot be proved, the command still fails with `coordinator.unknown`
+and gives scoped status/process inspection commands. An authenticated live worker is not
+closed again automatically. Retain its project and journals. After inspecting its retained
+work, an operator may terminate that exact owned headless worker through
+`tools processes kill <process>` with Destructive permission, accepting loss of any
+unacknowledged in-memory work. Do not kill by guessed PID/port or stop the shared server.
+Retrieve the same close request after that worker has ended. An unavailable endpoint or
+changed process receipt is not proof of release; preserve the binding for investigation.
+
 If a response was lost, inspect `sessions status <session> --target <target>`. Never infer
 `applied` from a connection failure. A changing command's optional request ID binds one effective
 intent inside the profile. Repeating the same ID/input retrieves its recorded outcome or
 unresolved state; changing input under that ID fails. Without an ID, calls are new intentions.
 
+For Java `scripts run-inline`, a versioned native executor records compilation, non-initializing
+class resolution, initialization, construction and framework execution separately. A correlated
+receipt proving `userCode: not_started` and `entrypointInvoked: false` before initialization
+produces `state: rejected` with a terminal failed request. The context remains available and
+its prior saved/pending work is unchanged. The CLI exits nonzero; the error result retains
+bounded compiler/load diagnostics. Repeating that request ID retrieves the same rejection;
+corrected source requires a new ID. Each attempt has isolated source/classes under profile
+analysis storage, with annotation processing disabled and no reuse of older inline classes.
+
+Initialization or constructor failure can have effects even when `run()` was never called.
+These failures, framework/runtime failures and missing/malformed/lost acknowledgements remain
+unknown. During framework execution `entrypointInvoked: null` means actual `run()` entry was
+not independently observed. Console text cannot establish non-execution. This is not a sandbox
+for adversarial same-JVM Java, and existing unknown script attempts are not reclassified from
+their exception strings or an unchanged program snapshot. File/Python scripts retain their
+existing conservative recovery semantics.
+
 An unknown or partial effect retains its request intent, snapshots and native stage. Open the
 same tuple to reconcile supported outcomes. A committed merge is verified against its recorded
 server version and complete saved buffers through independent read authority; it is never

package/skill-bundle/insight-binary/SKILL.md

@@ -3,7 +3,7 @@ name: insight-binary
 description: Query structured PE, ELF and thin Mach-O headers, sections, imports and exports, or make an explicitly guarded new PE subsystem copy through insight-cli binary. Use for scoped binary structure, linkage and copy-only header edits without target execution.
 ---
 
-# Insight Binary 0.3.2
+# Insight Binary 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-capture/SKILL.md

@@ -3,7 +3,7 @@ name: insight-capture
 description: Capture one explicitly authorized native program run, exact stdout/stderr and declared file snapshots through insight-cli capture, then inspect or compare retained reports without replay. Use for controlled input/output research, preserving original files and interrupted or unknown outcomes.
 ---
 
-# Insight Capture 0.3.2
+# Insight Capture 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-cli/SKILL.md

@@ -3,7 +3,7 @@ name: insight-cli
 description: Choose and prepare reverse-engineering capabilities from the insight-cli toolbox for binary, managed-code and runtime investigations. Use to discover the appropriate tool or its packaged skill before installing native runtimes.
 ---
 
-# insight-cli 0.3.2
+# insight-cli 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized
@@ -15,6 +15,9 @@ request/status recovery, never blind retry.
 Read the project's RE instructions and existing findings first. They own tool choices,
 evidence layout, formats and source of truth. These skills fill the remaining gaps.
 
+For repeated research calls, retain one [persistent CLI client](references/persistent.md)
+in the agent's long-lived runtime. Reuse it across calls to avoid repeated frontend startup.
+
 1. Run `insight-cli tools list --json` to discover the capabilities shipped in this version.
    The catalog works before profile configuration, downloads or IPC startup. A downloaded
    runtime is not needed to discover what a tool does.

package/skill-bundle/insight-cli/references/persistent-client.mjs

@@ -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/skill-bundle/insight-cli/references/persistent.md

@@ -0,0 +1,50 @@
+# Persistent research calls
+
+For a sequence of CLI research calls, keep one `insight-cli --json-rpc` frontend alive in the
+agent's long-lived JavaScript runtime. The Factory owner and Ghidra processes have their own
+lifetime; retaining only the owner still makes a new frontend validate its installed build.
+
+The package exports a small stdio client, independent of the facade's eager imports:
+
+```js
+import {connectInsight, InsightCommandError, InsightTransportError}
+  from '@eyeauras/insight-cli/persistent';
+
+const cli = await connectInsight({executable: 'insight-cli', cwd: projectDirectory});
+const result = await cli.execute([
+  'ghidra', 'functions', 'inspect', '--session', session, '--target', target,
+  '--function', 'main', '--fields', 'entry_point', '--include-call-context', 'false'
+]);
+// Keep cli for subsequent calls in this investigation.
+```
+
+When package-name resolution is unavailable in the agent host, dynamically import the
+[`persistent-client.mjs`](persistent-client.mjs) beside this reference by its absolute file URL.
+It is generated from the same canonical package module. In a persistent REPL retain `cli` as a
+binding across tool invocations. A new Node process per query does not retain this connection.
+For an explicit installed bin, use `{executable: process.execPath, arguments: [installedBin], cwd}`.
+`env` optionally supplies the child environment. There is no shell or separate profile/config.
+Use existing `--profile` argv flags when selecting a profile explicitly.
+
+`execute(argv)` returns the CLI result unchanged, without a JSON-RPC envelope. Calls are queued
+in admission order. Native work can be long: await the original promise through the agent host's
+existing wait facility. This V1 client deliberately has no per-request timeout or automatic
+reconnect/retry. Factory permissions, command validation, IDs and native budgets remain authoritative.
+
+* `InsightCommandError.rpc` preserves the JSON-RPC error code, message and data, including typed
+  CLI error results. A command failure leaves a healthy connection usable for the next command.
+* `InsightTransportError.dispatched === true` means the request was handed to the stream and its
+  acknowledgment is unavailable; it does not prove execution. Changing commands require their
+  existing request-ID/status recovery. The client never resends them.
+* `dispatched === false` means this client did not send that request, including queued requests
+  after a transport failure. Reconnection is an explicit new connection, not an implicit replay.
+
+The client bounds each response line to four MiB, validates IDs and envelopes, and fails the
+connection on malformed, uncorrelated or oversized replies. It drains stderr without retaining
+arbitrary native diagnostics in memory. Read command-level diagnostics from their typed results
+and the existing profile diagnostic locations.
+
+Finish owned Ghidra contexts with the normal scoped commands, following the project's shared
+server policy. Then `await cli.close()` drains already admitted requests and ends this stdio
+connection. It does not issue `ipc-server stop`, close another agent's context or stop a server.
+Do not call close while expecting to admit more requests.

package/skill-bundle/insight-cli/references/recovery.md

@@ -24,11 +24,47 @@ establishes that the old owned bootstrap worker has ended, then uses an authorit
 probe. An absent canonical item permits private preparation; an existing first version requires
 independent readback. The old project, intent and original session/target remain preserved.
 
+## Interrupted save or close
+
+After restoring profile storage, inspect the selected session and target with
+`sessions status <session> --target <target>`. Retry the original save/close with the
+same `--request-id`. If the original command had no caller ID, use the generated
+`unresolvedRequests[].id` from status. This retrieves the original intent instead of
+creating another close. A verified stopped worker lets close report `state: closed`
+and retain the acknowledged private snapshot and pending changes; it sends no new save,
+open, close or publication. Reopen the same session/target afterward.
+
+If release cannot be proved, the command still fails with `coordinator.unknown`
+and gives scoped status/process inspection commands. An authenticated live worker is not
+closed again automatically. Retain its project and journals. After inspecting its retained
+work, an operator may terminate that exact owned headless worker through
+`tools processes kill <process>` with Destructive permission, accepting loss of any
+unacknowledged in-memory work. Do not kill by guessed PID/port or stop the shared server.
+Retrieve the same close request after that worker has ended. An unavailable endpoint or
+changed process receipt is not proof of release; preserve the binding for investigation.
+
 If a response was lost, inspect `sessions status <session> --target <target>`. Never infer
 `applied` from a connection failure. A changing command's optional request ID binds one effective
 intent inside the profile. Repeating the same ID/input retrieves its recorded outcome or
 unresolved state; changing input under that ID fails. Without an ID, calls are new intentions.
 
+For Java `scripts run-inline`, a versioned native executor records compilation, non-initializing
+class resolution, initialization, construction and framework execution separately. A correlated
+receipt proving `userCode: not_started` and `entrypointInvoked: false` before initialization
+produces `state: rejected` with a terminal failed request. The context remains available and
+its prior saved/pending work is unchanged. The CLI exits nonzero; the error result retains
+bounded compiler/load diagnostics. Repeating that request ID retrieves the same rejection;
+corrected source requires a new ID. Each attempt has isolated source/classes under profile
+analysis storage, with annotation processing disabled and no reuse of older inline classes.
+
+Initialization or constructor failure can have effects even when `run()` was never called.
+These failures, framework/runtime failures and missing/malformed/lost acknowledgements remain
+unknown. During framework execution `entrypointInvoked: null` means actual `run()` entry was
+not independently observed. Console text cannot establish non-execution. This is not a sandbox
+for adversarial same-JVM Java, and existing unknown script attempts are not reclassified from
+their exception strings or an unchanged program snapshot. File/Python scripts retain their
+existing conservative recovery semantics.
+
 An unknown or partial effect retains its request intent, snapshots and native stage. Open the
 same tuple to reconcile supported outcomes. A committed merge is verified against its recorded
 server version and complete saved buffers through independent read authority; it is never

package/skill-bundle/insight-cli/references/setup.md

@@ -11,7 +11,7 @@ external executable paths, status/doctor and safe removal. Existing Factory prof
 The package contains the verified GhidraMCP 7.0.0 bridge, its Apache-2.0 license/notice and
 artifact provenance. Its pinned functionality catalog is from source
 `57e37a8bf388b1279cff46378f85be1554548f61`, with SHA256
-`7084e2fda16dc779dd05398e48821ff3f9ace4d32757ea143b257b39689e5fbd`.
+`f4a9272e911466ed774c8cf73bc1adf1daef6009d895fda57aa0b28522fcdf32`.
 `mcpJar` optionally selects another copy of those exact verified bytes. Runtime startup needs no
 bridge/Factory source checkout or Python MCP bridge. Packaged native helper sources compile
 against the installed Ghidra/JDK.

package/skill-bundle/insight-die/SKILL.md

@@ -3,7 +3,7 @@ name: insight-die
 description: Classify unknown executable or container inputs by format, architecture and compiler/runtime/packer signatures with Detect It Easy before choosing managed or native analysis. Use insight-cli die for static triage and preserve scan uncertainty.
 ---
 
-# Insight Detect It Easy 0.3.2
+# Insight Detect It Easy 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-dnspy/SKILL.md

@@ -3,7 +3,7 @@ name: insight-dnspy
 description: Debug a managed Windows EXE at an IL breakpoint and read primitive arguments, or change one expected IL Int32 constant in a new assembly copy through insight-cli dnspy. Use when C# decompilation needs observed execution or a controlled binary edit.
 ---
 
-# Insight dnSpyEx 0.3.2
+# Insight dnSpyEx 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-dotnet-dump/SKILL.md

@@ -3,7 +3,7 @@ name: insight-dotnet-dump
 description: Capture a managed heap dump or inspect compatible .NET dumps with SOS to recover waiting stacks, objects, fields and retention evidence.
 ---
 
-# Insight .NET Dump 0.3.2
+# Insight .NET Dump 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-dotnet-stack/SKILL.md

@@ -3,7 +3,7 @@ name: insight-dotnet-stack
 description: Inspect live managed thread stacks to identify active or waiting work in an explicitly selected .NET process without taking a dump.
 ---
 
-# Insight .NET Stack 0.3.2
+# Insight .NET Stack 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-dotnet-trace/SKILL.md

@@ -3,7 +3,7 @@ name: insight-dotnet-trace
 description: Collect and inspect bounded .NET EventPipe traces to identify sampled thread work, waits or runtime activity; distinguish wall-clock samples from CPU consumption.
 ---
 
-# Insight .NET Trace 0.3.2
+# Insight .NET Trace 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-frida/SKILL.md

@@ -3,7 +3,7 @@ name: insight-frida
 description: Observe native call arguments/results or inspect runtime modules and exports in an explicitly selected authorized process with bounded Frida scripts. Use insight-cli frida to corroborate static findings with actual execution on macOS ARM64.
 ---
 
-# Insight Frida 0.3.2
+# Insight Frida 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized

package/skill-bundle/insight-ghidra/SKILL.md

@@ -3,7 +3,7 @@ name: insight-ghidra
 description: Inspect or edit native binaries with Ghidra through insight-cli; use isolated contexts, multi-agent merge/refresh, server, GUI or debugger workflows. Choose this for static native behavior and references, not C# recovery from managed IL.
 ---
 
-# Insight Ghidra 0.3.2
+# Insight Ghidra 0.4.0
 
 If local help/status reports AppData or IPC access denied, retry that **read-only probe**
 with the agent host's normal permission escalation, then use that route for later authorized
@@ -17,6 +17,9 @@ session/cell ID, await that same execution with the host's wait/poll facility un
 status and read its stdout/stderr. An empty first chunk is not a lost CLI response. Do not
 start another open or repeat a CPU mutation while the original command is still running.
 
+For research loops, use the packaged [persistent client](references/persistent.md) and keep
+one connection across queries. It uses the existing CLI transport and preserves typed errors;
+lost mutation replies still require request/status recovery.
 
 New targets import **without automatic analysis**. Reuse existing selectors/projects before
 opening another copy; `ghidra open --session <session> --target <target>` preserves its bound
@@ -68,6 +71,13 @@ ordinary saved copy and its receipt. Neither operation requires a Ghidra install
    function addresses, then inspect/decompile. Decompilation defaults to a 16000-character
    window; page with `--limit-chars`/`--offset-chars` and retain `textSha256`. Native
    truncation remains explicit even at the end of the observed text. See [research](references/research.md).
+   If strings/xrefs are empty or function bodies are one byte, run `analysis navigation`
+   and follow [sparse navigation](references/sparse-navigation.md). Try compact `functions inspect`
+   at known entries before writing reconstruction scripts. `force-decompile` refreshes an
+   existing entry; `decode` handles known bytes without an entry. Neither repairs stored xrefs.
+   `analysis code-references` scans explicit RIP/CALL byte forms for exact targets with bounded
+   coverage and a stateless cursor. Its decoded candidates retain boundary uncertainty; see the
+   sparse-navigation reference before treating a candidate as an actual code reference.
 4. Rename functions or set/clear comments through ordinary commands. An `applied` result means
    verified saved private work. Other sessions keep their own views; local edits remain unpublished in the default manual mode.
 5. By default, publish explicitly with `ghidra merge`; receive safe shared changes with `ghidra refresh`.
@@ -76,6 +86,9 @@ ordinary saved copy and its receipt. Neither operation requires a Ghidra install
 6. Continue with `ghidra open --session <id> --target <id>`. For uncertain outcomes inspect
    `sessions status <id> --target <id>` and [recovery](references/recovery.md). Supplying a stable
    optional `--request-id` lets a repeated changing intent retrieve its outcome without rerunning.
+   Java `scripts run-inline` returns bounded compile/load diagnostics. Only proven rejection
+   before user-code initialization leaves the context available; constructor/static initializer
+   failures and lost responses remain unknown. See the recovery reference for execution fields.
 7. Finish by closing each context you own with scoped `ghidra close`, preserving private work.
    If this profile's local server belongs exclusively to your investigation and all its contexts
    are closed, use `ghidra server stop`, then verify `ghidra status` has no remaining processes.

package/skill-bundle/insight-ghidra/references/persistent-client.mjs

@@ -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; });
+        }
+    };
+}