@eyeauras/insight-cli 0.2.1 → 0.2.3

package/.cli-package-build.json

@@ -1 +1 @@
-{"version":1,"artifact":"b65915991d87f45608bceba8cc7afa48b2e04f292149acf604aaf91ec2d2d6ba"}
+{"version":1,"artifact":"94653e997ccdf18c2e7cb73ac89fc02e746c119ae6971b374cfcafbda087b493"}

package/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.2.1
+# insight-cli 0.2.3
 
 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/dist/src/budgets.d.ts

@@ -0,0 +1,2 @@
+/** Execution policy, deliberately separate from immutable program load settings. */
+export declare function ghidraBudget(values: Record<string, unknown>, phase: 'import' | 'save'): number;

package/dist/src/budgets.js

@@ -0,0 +1,13 @@
+import { fail } from './model.js';
+/** Execution policy, deliberately separate from immutable program load settings. */
+export function ghidraBudget(values, phase) {
+    const field = phase === 'import' ? 'initialImportSeconds' : 'saveSeconds';
+    const fallback = phase === 'import' ? 3600 : 120;
+    const value = values[field] === undefined ? fallback : values[field];
+    if (typeof value !== 'number' && (typeof value !== 'string' || !/^\d+$/.test(value)))
+        fail('configuration', field + ' must be an integer number of seconds.');
+    const seconds = Number(value), max = phase === 'import' ? 86400 : 3600;
+    if (!Number.isSafeInteger(seconds) || seconds < 1 || seconds > max)
+        fail('configuration', field + ' must be between 1 and ' + max + ' seconds.');
+    return seconds * 1000;
+}

package/dist/src/cli.js

@@ -1,3 +1,4 @@
+import { ghidraBudget } from './budgets.js';
 import { captureCommands } from './capture.js';
 import { binaryCommands } from './binary.js';
 import { skillCommand, toolboxCommands } from './toolbox.js';
@@ -194,6 +195,8 @@ const fields = [
     ['repository', '--repository <name>', 'Repository on the external server'],
     ['readerUser', '--reader-user <name>', 'Read-only external account'],
     ['publisherUser', '--publisher-user <name>', 'External publication account'],
+    ['initialImportSeconds', '--initial-import-seconds <seconds>', 'Initial import/analysis budget (default 3600, range 1–86400 seconds)'],
+    ['saveSeconds', '--save-seconds <seconds>', 'Native save/export budget (default 120, range 1–3600 seconds)'],
     ['maxContexts', '--max-contexts <count>', 'Concurrent contexts (default 4, maximum 16)'],
     ['debuggerPython', '--debugger-python <path>', 'Optional Python executable for a configured debugger offer'],
     ['windbgDir', '--windbg-dir <path>', 'Optional Windows debugger runtime directory'],
@@ -260,7 +263,7 @@ export function createDefinition(options = {}) {
         name: 'insight-cli', applicationId: 'insight-cli', version: packageVersion, description: 'Isolated research contexts and coordinated Ghidra analysis',
         resources: [owner], permissions: { categories: [{ name: 'Destructive', description: 'Explicit deletion or replacement of retained research data', enabledByDefault: false }] }, ...(options.runtime ? { runtime: options.runtime } : {}),
         profile: { fields: fields.map(([name, flags, description]) => ({ name: name, flags: flags, description: description,
-                ...(name === 'maxContexts' ? { normalize: (value) => number(value, 16, 1) } : {}) })) },
+                ...(['maxContexts', 'initialImportSeconds', 'saveSeconds'].includes(name) ? { normalize: (value) => number(value, name === 'maxContexts' ? 16 : name === 'saveSeconds' ? 3600 : 86400, 1) } : {}) })) },
         auth: {
             loginOptions: [{ flags: '--role <role>', description: 'External reader, publisher or archive role', defaultValue: 'reader' },
                 { flags: '--password-stdin', description: 'Read the password from stdin' }],
@@ -351,6 +354,22 @@ export function createDefinition(options = {}) {
                 }, { permission: Permission.ReadOnly, options: [{ flags: '--target <id>', description: 'Inspect one target context' }, ...paged] }),
             ]),
             command('ghidra', 'Research through an isolated saved context', [
+                command('budgets', 'Inspect or configure native execution budgets', [
+                    command('show', 'Read effective per-request native budgets', (_invocation, c) => ({ profile: c.profile.name, initialImportSeconds: ghidraBudget(c.profile.values, 'import') / 1000, saveSeconds: ghidraBudget(c.profile.values, 'save') / 1000 }), { permission: Permission.ReadOnly }),
+                    command('set', 'Configure subsequent native requests without invalidating retained research', async ({ options: o }, c) => {
+                        if (o.initialImportSeconds === undefined && o.saveSeconds === undefined)
+                            fail('invalid', 'Supply at least one native budget.');
+                        const store = options.runtime?.profileStore ?? new ProfileStore({ applicationId: c.appArguments.AppName, appArguments: c.appArguments });
+                        const patch = {
+                            ...(o.initialImportSeconds === undefined ? {} : { initialImportSeconds: number(o.initialImportSeconds, 86400, 1) }),
+                            ...(o.saveSeconds === undefined ? {} : { saveSeconds: number(o.saveSeconds, 3600, 1) })
+                        };
+                        const { values } = await store.set(c.profile.name, patch);
+                        return { profile: c.profile.name, state: 'configured', initialImportSeconds: ghidraBudget(values, 'import') / 1000, saveSeconds: ghidraBudget(values, 'save') / 1000, appliesTo: 'subsequent-requests' };
+                    }, { permission: Permission.Update, options: [{ flags: '--initial-import-seconds <seconds>', description: 'Initial import/analysis: 1–86400 seconds' },
+                            { flags: '--save-seconds <seconds>', description: 'Native save/export: 1–3600 seconds' }] })
+                ]),
+                command('abandon', 'Retain an uncertain program attempt and resume its previous saved view', ({ options: o }, c) => owner.selected(c).research.abandon(scope(o), id(o.requestId), Boolean(o.acknowledgeUnknownEffects)), { permission: 'Destructive', options: [...scoped, { flags: '--request-id <id>', description: 'Original unresolved request ID from sessions status', required: true }, { flags: '--acknowledge-unknown-effects', description: 'Acknowledge that the abandoned effect remains unknown; no script is replayed' }] }),
                 command('refresh', 'Receive safe shared changes while retaining local conflicts', ({ options: o }, c) => owner.selected(c).research.refresh(scope(o), o.requestId === undefined ? undefined : id(o.requestId)), { permission: Permission.Update, options: [...scoped, request] }),
                 command('merge', 'Publish the complete selected context or retain every conflict', ({ options: o }, c) => owner.selected(c).research.merge(scope(o), o.requestId === undefined ? undefined : id(o.requestId)), { permission: Permission.Update, options: [...scoped, request] }),
                 command('open [input]', 'Start independent work or continue a context', async ({ args, options: o }, c) => {

package/dist/src/contexts.js

@@ -1,3 +1,4 @@
+import { ghidraBudget } from './budgets.js';
 import { launchProcess, terminateProcess } from './tool-runtime/supervisor.js';
 import { runTool } from './tool-runtime/run.js';
 import { verifyGhidraProcess } from './ghidra-processes.js';
@@ -139,7 +140,7 @@ export class GhidraContexts {
         await log.close();
         if (!child.pid)
             fail('launch', 'Owned Ghidra context could not be launched.');
-        const record = { binding, http: new HttpBridge(binding.endpoint, this.c.fetch, this.c.signal, token), child };
+        const record = { binding, http: new HttpBridge(binding.endpoint, this.c.fetch, this.c.signal, token, undefined, ghidraBudget(this.c.profile.values, 'save')), child };
         this.running.set(root, record);
         const deadline = Date.now() + 90000;
         try {
@@ -172,7 +173,7 @@ export class GhidraContexts {
         if (stable(JSON.parse(await readFile(join(root, 'process.json'), 'utf8'))) !== stable(binding))
             fail('binding', 'Native context receipt changed.');
         const token = await this.c.secrets.require(binding.tokenSecret);
-        const http = new HttpBridge(binding.endpoint, this.c.fetch, this.c.signal, token);
+        const http = new HttpBridge(binding.endpoint, this.c.fetch, this.c.signal, token, undefined, ghidraBudget(this.c.profile.values, 'save'));
         const info = await http.instance();
         if (info.pid !== binding.pid || info.tcp_port !== Number(new URL(binding.endpoint).port) ||
             !String(info.project_path ?? '').startsWith(root + sep))

package/dist/src/lifecycle.d.ts

@@ -37,6 +37,8 @@ export declare class Lifecycle {
                 operation: string;
                 state: import("./workspace.js").RequestState;
                 requestId?: string | undefined;
+                detail?: {} | undefined;
+                id: string;
             }[];
         };
         session: string;

package/dist/src/research.d.ts

@@ -92,11 +92,14 @@ export declare class Research {
                 operation: string;
                 state: import("./workspace.js").RequestState;
                 requestId?: string | undefined;
+                detail?: {} | undefined;
+                id: string;
             }[];
         };
         session: string;
         target: string;
     };
+    abandon(selected: Scope, requestId: string, acknowledged: boolean): Promise<unknown>;
     open(target: string, session: string | 'new', settings: GhidraLoadSettings, callerId?: string, mode?: ToolMode): Promise<{
         [k: string]: unknown;
     } | {

package/dist/src/research.js

@@ -100,7 +100,29 @@ export class Research {
                 mergeState: model.state === 'unknown' ? 'unknown' : 'idle',
                 conflicts: context.scalars.filter(change => change.conflict).map(change => ({ address: publicAddress(change.address), field: change.field,
                     original: change.original, local: change.local, shared: change.conflict.shared })),
-                unresolvedRequests: unresolved.map(request => ({ ...(request.callerId ? { requestId: request.callerId } : {}), operation: request.operation, state: request.state })) } };
+                unresolvedRequests: unresolved.map(request => ({ id: request.id, ...(request.result ? { detail: request.result } : {}), ...(request.callerId ? { requestId: request.callerId } : {}), operation: request.operation, state: request.state })) } };
+    }
+    async abandon(selected, requestId, acknowledged) {
+        return this.ordered(selected, async () => {
+            if (!acknowledged)
+                fail('invalid', 'Explicit --acknowledge-unknown-effects is required.');
+            const context = this.workspace.context(selected), requests = this.workspace.unresolved(selected);
+            const request = this.workspace.scopedRequest(selected, requestId);
+            if (request?.state === 'failed' && object(request.result ?? {}).state === 'abandoned')
+                return request.result;
+            if (!request || !['running', 'unknown'].includes(request.state) || requests.length !== 1 || object(request.execution ?? {}).kind !== 'program')
+                fail('blocked', 'Abandon requires exactly one unresolved private program operation.');
+            if (this.workspace.activePublication(selected.target) || context.debugger?.connected)
+                fail('blocked', 'Publication or a live debugger prevents private abandonment.');
+            const execution = object(request.execution), snapshot = context.workingSnapshot;
+            if (!snapshot || execution.generation !== context.generation || object(execution.workingSnapshot).id !== snapshot.id)
+                fail('binding', 'The previous saved program view no longer matches the attempt.');
+            await this.workspace.artifacts.verify(snapshot);
+            const backend = await this.backend();
+            if (!backend.closed || !await backend.closed(selected))
+                fail('busy', 'The original native worker must be stopped before abandoning its uncertain program attempt.');
+            return this.workspace.abandonProgramRequest(selected, request.id, context.generation);
+        });
     }
     async open(target, session, settings, callerId, mode) {
         // Mode belongs to the request's effective intent. It does not alter target load identity.
@@ -777,6 +799,7 @@ export class Research {
             const context = this.workspace.context(selected);
             this.workspace.startRequest(request.id, { kind: 'program', operation, generation: context.generation, workingSnapshot: context.workingSnapshot,
                 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 };
                 if (['rejected', 'partial', 'failed', 'error'].includes(String(response.status)) || response.success === false)
@@ -784,7 +807,10 @@ export class Research {
                 if (!verifySaved && response.success !== true && response.status !== 'success')
                     fail('partial', 'Program operation did not acknowledge its effect.');
                 let value = await verify(backend, response);
+                phase = 'save';
                 const snapshot = await backend.saved(selected);
+                savedSnapshot = snapshot;
+                phase = 'verification';
                 if (verifySaved)
                     value = await verifySaved(backend, snapshot, response);
                 const scalars = await this.savedScalars(context, backend, snapshot), complexChanges = [...context.complexChanges, request.id], result = { ...selected, state: 'applied', sharedState: 'pending',
@@ -797,12 +823,16 @@ export class Research {
                     this.workspace.recordRequest(request.id, 'failed', { ...selected, state: 'rejected', reason: 'native_transaction_rolled_back' });
                     throw error;
                 }
-                let savedSnapshot;
-                try {
-                    savedSnapshot = await backend.saved(selected);
+                // Retain supported structural candidates after a lost operation reply. Never
+                // dispatch another save after a save deadline or an arbitrary script failure.
+                if (phase === 'operation' && verifySaved && !['/run_script_inline', '/run_ghidra_script'].includes(operation)) {
+                    try {
+                        savedSnapshot = await backend.saved(selected);
+                    }
+                    catch { /* Native evidence stays retained. */ }
                 }
-                catch { /* A failed/dead backend retains its native stage and the last acknowledged snapshot. */ }
-                this.workspace.recordRequest(request.id, 'unknown', { ...selected, state: 'unknown', ...(savedSnapshot ? { savedSnapshot } : {}) });
+                const detail = error instanceof CliError ? { code: error.code, ...(error.result ? { result: error.result } : {}) } : {};
+                this.workspace.recordRequest(request.id, 'unknown', { ...selected, state: 'unknown', phase, ...detail, ...(savedSnapshot ? { savedSnapshot } : {}) });
                 throw error;
             }
         });

package/dist/src/server.js

@@ -1,3 +1,5 @@
+import { ghidraBudget } from './budgets.js';
+import { CliError } from '@eyeauras/cli-factory';
 import { launchProcess, terminateProcess } from './tool-runtime/supervisor.js';
 import { runTool } from './tool-runtime/run.js';
 import { randomUUID, randomBytes, createHash } from 'node:crypto';
@@ -199,7 +201,17 @@ export class GhidraServer {
     async programStatus(binding, path) {
         return this.run('program-status', 'InsightRepositoryProbe', [binding.repository, path, 'reader'], await this.credentials(binding, 'reader'));
     }
-    async initialImport(root) { return this.run('initial-import', 'InsightInitialImport', [root], {}, undefined, [0], 600000); }
+    async initialImport(root) {
+        const timeoutMilliseconds = ghidraBudget(this.c.profile.values, 'import');
+        try {
+            return await this.run('initial-import', 'InsightInitialImport', [root], {}, undefined, [0], timeoutMilliseconds);
+        }
+        catch (error) {
+            if (error instanceof CliError)
+                throw new CliError(error.message + ' Initial import remains unproved. Increase profile initialImportSeconds and continue the original scope; incomplete private analysis restarts from the retained input.', { code: error.code, result: { phase: 'initial-import', timeoutMilliseconds, budgetSetting: 'initialImportSeconds', outcome: 'unknown', diagnostics: error.result } });
+            throw error;
+        }
+    }
     async initialPublication(binding, root, operation = 'stage') {
         return this.run('initial-publication', 'db.InsightInitialPublication', [root, operation], await this.credentials(binding, operation.startsWith('verify') ? 'reader' : 'publisher'));
     }

package/dist/src/tool-runtime/java-arguments.d.ts

@@ -0,0 +1,6 @@
+/** The Windows java launcher uses ACP, while Java 21 javac reads UTF-8 @files. */
+export declare function encodeJavaLauncherFile(value: string): Promise<Buffer>;
+/** Java's quoted argument-file grammar (not JSON: it has no \u escapes). */
+export declare function quoteJavaArgument(value: string): string;
+/** Keep all other argv entries in place, including JVM flags and application arguments. */
+export declare function javaClasspathArguments(root: string, tool: string, executable: string, args: string[], platform?: string): Promise<string[]>;

package/dist/src/tool-runtime/java-arguments.js

@@ -0,0 +1,44 @@
+import { writeFile } from 'node:fs/promises';
+import { join, win32 } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+/** The Windows java launcher uses ACP, while Java 21 javac reads UTF-8 @files. */
+export async function encodeJavaLauncherFile(value) {
+    if (!/[^\x00-\x7f]/.test(value))
+        return Buffer.from(value, 'ascii');
+    // Fixed script; text travels over stdin, never through PowerShell's command parser.
+    // Match the native launcher without silently replacing unmappable path characters.
+    const script = '[Console]::InputEncoding=[Text.UTF8Encoding]::new($false,$true);$s=[Console]::In.ReadToEnd();$e=[Text.Encoding]::GetEncoding([Text.Encoding]::Default.CodePage,[Text.EncoderExceptionFallback]::new(),[Text.DecoderExceptionFallback]::new());[Console]::Out.Write([Convert]::ToBase64String($e.GetBytes($s)))';
+    const pending = exec(join(process.env.SystemRoot ?? 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe'), ['-NoProfile', '-NonInteractive', '-Command', script], { windowsHide: true, timeout: 15000, maxBuffer: Math.max(4096, Buffer.byteLength(value) * 4) });
+    pending.child.stdin?.on('error', () => { });
+    pending.child.stdin?.end(value, 'utf8');
+    try {
+        return Buffer.from((await pending).stdout.trim(), 'base64');
+    }
+    catch {
+        throw new Error('Java classpath cannot be encoded for the Windows launcher; no process was started. Inspect the retained run and the JDK system-code-page path restrictions.');
+    }
+}
+/** Java's quoted argument-file grammar (not JSON: it has no \u escapes). */
+export function quoteJavaArgument(value) {
+    if (value.includes('\0'))
+        throw new Error('Java argument contains NUL');
+    return '"' + value.replace(/[\\"\n\r\t\f]/g, c => ({ '\\': '\\\\', '"': '\\"', '\n': '\\n', '\r': '\\r', '\t': '\\t', '\f': '\\f' }[c])) + '"';
+}
+/** Keep all other argv entries in place, including JVM flags and application arguments. */
+export async function javaClasspathArguments(root, tool, executable, args, platform = process.platform) {
+    if (platform !== 'win32' || tool !== 'ghidra' || !/^(java|javac)\.exe$/i.test(win32.basename(executable)))
+        return args;
+    // Conservative upper bound for Windows quoting, with room below CreateProcess's 32767 limit.
+    if (executable.length * 2 + args.reduce((n, arg) => n + arg.length * 2 + 3, 3) <= 28000)
+        return args;
+    const index = args.findIndex(arg => arg === '-cp' || arg === '-classpath' || arg === '--class-path');
+    if (index < 0 || args[index + 1] === undefined)
+        return args;
+    const path = join(root, 'java-classpath.args');
+    const content = '-classpath\n' + quoteJavaArgument(args[index + 1]) + '\n';
+    const bytes = /^java\.exe$/i.test(win32.basename(executable)) && process.platform === 'win32' ? await encodeJavaLauncherFile(content) : Buffer.from(content, 'utf8');
+    await writeFile(path, bytes, { flag: 'wx', mode: 0o600 });
+    return [...args.slice(0, index), '@' + path, ...args.slice(index + 2)];
+}

package/dist/src/tool-runtime/supervisor.js

@@ -8,6 +8,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { CliError } from '@eyeauras/cli-factory';
 import { atomicWrite, readJson, toolRoot, withToolLock } from './store.js';
 import { processIdentity } from './identity.js';
+import { javaClasspathArguments } from './java-arguments.js';
 import { digest } from '../model.js';
 const owned = new Map();
 const ownedKey = (directory, id) => resolve(directory) + '\0' + id;
@@ -70,6 +71,8 @@ export async function launchProcess(directory, spec, executable, args, options =
             stdio.push('pipe');
         let child;
         try {
+            args = await javaClasspathArguments(root, spec.tool, executable, args);
+            control.signal?.throwIfAborted();
             child = spawn(gated ? process.execPath : executable, gated ? ['--no-warnings', fileURLToPath(new URL('./launch-worker.js', import.meta.url)), directory, id, String(fd)] : args, { cwd: root, ...options, stdio, windowsHide: true, env: gated ? { PATH: environment.PATH, HOME: root, TMPDIR: root } : environment });
         }
         catch (error) {

package/dist/src/transport.d.ts

@@ -13,8 +13,9 @@ export declare class HttpBridge {
     private signal?;
     private token?;
     private timeoutMilliseconds?;
+    private saveTimeoutMilliseconds;
     private schema?;
-    constructor(endpoint: string, fetch?: typeof globalThis.fetch, signal?: AbortSignal | undefined, token?: string | undefined, timeoutMilliseconds?: number | undefined);
+    constructor(endpoint: string, fetch?: typeof globalThis.fetch, signal?: AbortSignal | undefined, token?: string | undefined, timeoutMilliseconds?: number | undefined, saveTimeoutMilliseconds?: number);
     private request;
     instance(): Promise<Record<string, unknown>>;
     descriptor(path: string): Promise<Descriptor>;

package/dist/src/transport.js

@@ -8,16 +8,20 @@ export class HttpBridge {
     signal;
     token;
     timeoutMilliseconds;
+    saveTimeoutMilliseconds;
     schema;
-    constructor(endpoint, fetch = globalThis.fetch, signal, token, timeoutMilliseconds) {
+    constructor(endpoint, fetch = globalThis.fetch, signal, token, timeoutMilliseconds, saveTimeoutMilliseconds = 120000) {
         this.endpoint = endpoint;
         this.fetch = fetch;
         this.signal = signal;
         this.token = token;
         this.timeoutMilliseconds = timeoutMilliseconds;
+        this.saveTimeoutMilliseconds = saveTimeoutMilliseconds;
         const url = new URL(endpoint);
         if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !url.port || url.username || url.password || url.pathname !== '/')
             fail('binding', 'Worker bridge must use an explicit loopback HTTP port.');
+        if (!Number.isSafeInteger(saveTimeoutMilliseconds) || saveTimeoutMilliseconds < 1000 || saveTimeoutMilliseconds > 3600000)
+            fail('invalid', 'Save timeout is outside the supported bound.');
         if (timeoutMilliseconds !== undefined && (!Number.isSafeInteger(timeoutMilliseconds) || timeoutMilliseconds < 1 || timeoutMilliseconds > 1800000))
             fail('invalid', 'Bridge timeout is outside the supported bound.');
     }
@@ -25,13 +29,14 @@ export class HttpBridge {
         const url = new URL(path, this.endpoint);
         // Import includes synchronous auto-analysis. Keep discovery/ordinary requests short,
         // while allowing a real executable to finish its first analysis without losing the reply.
-        const timeoutMilliseconds = this.timeoutMilliseconds ?? (path === '/import_file' ? 600000 : 30000);
+        const saving = path === '/save_program' || path === '/export_program';
+        const timeoutMilliseconds = this.timeoutMilliseconds ?? (saving ? this.saveTimeoutMilliseconds : path === '/import_file' ? 600000 : 30000);
         const signal = this.signal ? AbortSignal.any([this.signal, AbortSignal.timeout(timeoutMilliseconds)]) : AbortSignal.timeout(timeoutMilliseconds);
         const transportFailure = () => {
             if (this.signal?.aborted)
                 fail('cancelled', `Ghidra request ${path} was cancelled; its outcome may require reconciliation.`, { operation: path });
             if (signal.aborted)
-                fail('timeout', `Ghidra request ${path} exceeded ${timeoutMilliseconds / 1000} seconds; its outcome may require reconciliation.`, { operation: path, timeoutMilliseconds });
+                fail('timeout', `Ghidra request ${path} exceeded ${timeoutMilliseconds / 1000} seconds; its outcome may require reconciliation.${saving ? ' Configure profile saveSeconds before future work; inspect sessions status and never replay an uncertain script.' : ''}`, { operation: path, timeoutMilliseconds, ...(saving ? { phase: 'save', budgetSetting: 'saveSeconds', outcome: 'unknown' } : {}) });
             fail('transport', `Ghidra request ${path} did not complete; its outcome may require reconciliation.`, { operation: path });
         };
         for (const [name, value] of Object.entries(query))

package/dist/src/workspace.d.ts

@@ -147,6 +147,7 @@ export declare class Workspace {
         request: ResearchRequest;
         replay: boolean;
     };
+    scopedRequest(scope: Scope, identity: string): ResearchRequest | undefined;
     request(request: string): ResearchRequest;
     reserveAdministration(operation: string, parameters: unknown, callerId?: string): {
         request: AdministrationRequest;
@@ -190,6 +191,16 @@ export declare class Workspace {
     rejectPublication(publication: string, result: unknown): Publication;
     publishedSince(target: string, revision: number): Publication[];
     saveContext(scope: Scope, expectedGeneration: number, patch: ContextPatch): GhidraContext;
+    /** Terminal abandonment retains the previous outcome and saved view atomically. */
+    abandonProgramRequest(scope: Scope, request: string, generation: number): {
+        state: string;
+        outcome: string;
+        requestId: string;
+        previousResult: {} | null;
+        retainedSnapshot: Artifact;
+        session: string;
+        target: string;
+    };
     /** Snapshot and successful request acknowledgment enter the same durable transaction. */
     completeSavedRequest(scope: Scope, request: string, expectedGeneration: number, patch: ContextPatch, result: unknown): {
         context: GhidraContext;

package/dist/src/workspace.js

@@ -3,7 +3,7 @@ import { chmodSync, mkdirSync, realpathSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { Artifacts } from './artifacts.js';
-import { digest, fail, id, stable, text, version } from './model.js';
+import { digest, fail, id, stable, text, version, object } from './model.js';
 const now = () => new Date().toISOString();
 function loadSettings(value) {
     if (typeof value.autoAnalyze !== 'boolean' || Object.keys(value).some(key => !['autoAnalyze', 'language', 'compilerSpec', 'imageBase', 'loader', 'loaderOptions'].includes(key)))
@@ -260,6 +260,10 @@ export class Workspace {
             return previous ? { request: previous, replay: true } : { request: this.insertRequest(context.id, operation, intent, callerId, hash), replay: false };
         });
     }
+    scopedRequest(scope, identity) {
+        const row = this.db.prepare('SELECT data FROM requests WHERE context=? AND (id=? OR caller_id=?)').get(this.context(scope).id, id(identity), id(identity));
+        return row ? JSON.parse(String(row.data)) : undefined;
+    }
     request(request) {
         const row = this.db.prepare('SELECT data FROM requests WHERE id=?').get(id(request));
         if (!row)
@@ -483,6 +487,19 @@ export class Workspace {
     saveContext(scope, expectedGeneration, patch) {
         return this.transaction(() => this.writeContext(scope, expectedGeneration, patch));
     }
+    /** Terminal abandonment retains the previous outcome and saved view atomically. */
+    abandonProgramRequest(scope, request, generation) {
+        return this.transaction(() => {
+            const previous = this.request(request), context = this.context(scope), execution = object(previous.execution ?? {});
+            if (previous.context !== context.id || !['running', 'unknown'].includes(previous.state) || execution.kind !== 'program' || execution.generation !== generation ||
+                this.unresolved(scope).length !== 1 || this.activePublication(scope.target) || !context.workingSnapshot || object(execution.workingSnapshot).id !== context.workingSnapshot.id)
+                fail('binding', 'Uncertain attempt changed before abandonment.');
+            const result = { ...scope, state: 'abandoned', outcome: 'unknown', requestId: previous.callerId ?? previous.id, previousResult: previous.result ?? null, retainedSnapshot: context.workingSnapshot };
+            this.writeContext(scope, generation, { state: 'stopped', viewEpoch: (context.viewEpoch ?? 0) + 1 });
+            this.writeRequest(request, 'failed', result);
+            return result;
+        });
+    }
     /** Snapshot and successful request acknowledgment enter the same durable transaction. */
     completeSavedRequest(scope, request, expectedGeneration, patch, result) {
         return this.transaction(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeauras/insight-cli",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "Agent-facing durable sessions and isolated Ghidra research contexts",
   "main": "./dist/src/index.js",

package/references/managed-runtime.md

@@ -22,6 +22,11 @@ A failed install preserves its stage/diagnostics and the old selection. Retrying
 completed cached archives are reused. A later install/doctor/uninstall authenticates and stops
 any leftover disposable probe server before proceeding; an unverified live identity blocks recovery. Interrupted partial downloads are never used as complete files.
 
+On Windows, long Ghidra Java classpaths use an owned per-execution argument file, retained with
+the process diagnostics. `javac` files use UTF-8; `java` launcher files use the Windows system
+code page. Java 21's launcher still requires paths representable in that code page. Unmappable
+characters fail before launch rather than selecting different files through lossy conversion.
+
 `status` without scope is passive: selection, paths, missing components, installations, retained
 stages, recorded checks and live process receipts. It works before installation. It does not start
 Java or create a research workspace. `status --session S --target T` retains the scoped live health

package/references/native-workflows.md

@@ -44,6 +44,16 @@ loader IDs, supported language/compiler specifications and native option definit
 selects a loader explicitly. Primitive options, native address and HexLong options are converted
 and validated; unsupported complex option classes fail explicitly. One program belongs to a target.
 
+For a mixed managed/native or protected PE, first inspect the installed loader options. If the
+task needs its native view and CLI metadata parsing emits repeated warnings or prevents import,
+an explicit PE import may select `--loader <PE-loader-ID-from-discovery>` together with
+`--loader-options '{"Parse CLI headers (if present)":false}'`.
+This is a per-target analysis choice: record it with the findings. For an alternative managed
+import of the same bytes, use a separate disposable profile; targets within one profile reuse
+the same immutable input identity. An output-limit failure means import/analysis is incomplete; inspect
+the retained diagnostics and first-import recovery state before continuing. Do not treat warnings,
+a killed worker or a partial snapshot as a successful analysis or blindly repeat publication.
+
 `formats exporters` lists compatible native exporters and their options. `formats export
 --exporter 'Raw Bytes' --ranges '[{"start":"0x10001","end":"0x10003"}]'
 --output-directory <new-directory>` requires a format supporting restricted address sets.

package/references/recovery.md

@@ -51,3 +51,29 @@ goto. If its original owned GUI process has exited, continuation reports the unc
 as disconnected and retains saved program work. It does not recreate the old cursor or re-enable
 a previous prompt policy. Other unproved live UI effects remain retained until their outcome is
 established or the original process is known to have ended.
+
+## Abandon an uncertain private program attempt
+
+A post-mutation save timeout does not repeat the script or issue another save in the
+error handler. Status exposes the original request identity and retained phase/budget.
+Arbitrary script effects are never inferred from metadata or from an unverified DB.
+After inspecting the retained attempt, explicitly stop only its verified owned worker
+(`tools processes`, then `tools processes kill <process>` if required). Resume the
+last acknowledged private snapshot with:
+
+```sh
+insight-cli permissions grant Destructive
+insight-cli ghidra abandon --session <session> --target <target> \
+  --request-id <original-request> --acknowledge-unknown-effects --json
+insight-cli ghidra open --session <session> --target <target> --json
+```
+
+Abandon requires exactly one unresolved private program operation, an unchanged verified
+previous snapshot/generation, a stopped original worker and no active publication or live
+debugger. It retains the native project, candidate artifacts, original intent/execution and
+previous diagnostic result. Its terminal request is `failed` / `state: abandoned` with
+`outcome: unknown`; no effect is marked applied. Repeating abandonment retrieves the same
+result. Earlier saved private edits remain pending. The original changing request ID cannot
+execute again. Abandoning never undoes external effects or establishes what an arbitrary
+script did; the acknowledgement explicitly accepts that uncertainty. Publication recovery,
+initial import, UI and debugger attempts use their own protocols and cannot use this command.

package/references/setup.md

@@ -48,3 +48,20 @@ debugger runtime directory when relevant. These are runtime profile settings, no
 
 Archive exchange is opt-in through `archiveUrl`; its optional token uses Factory secrets.
 See [archive](archive.md) for the service contract and submission recovery behavior.
+
+## Native operation budgets
+
+Profile `initialImportSeconds` defaults to 3600 (1–86400 seconds); `saveSeconds`
+defaults to 120 (1–3600 seconds). Configure them with `ghidra budgets set
+--initial-import-seconds 7200 --save-seconds 300`; `ghidra budgets show` reads effective values.
+This uses Factory ProfileStore without invalidating research or stopping native contexts.
+Active requests retain their original budget. Generic `profile set` remains guarded for
+profiles containing research; initial profile creation also accepts these fields. Both are execution policy, independent
+of immutable target/load identity. Save and packed snapshot export use the save budget;
+discovery and ordinary HTTP queries keep their 30-second budget. Each native request has
+its own budget, not a total command deadline. Cancellation remains independent.
+
+After an import timeout, wait for the original worker to end, raise its budget and continue
+the original scope. Incomplete private analysis restarts; a completed receipt is reused.
+A save timeout reports `phase: save`, the effective budget and `saveSeconds`. Inspect
+`sessions status`; a native log or broken response stream cannot prove a saved snapshot.

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.2.1
+# Insight Artifacts 0.2.3
 
 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-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.2.1
+# Insight Binary 0.2.3
 
 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.2.1
+# Insight Capture 0.2.3
 
 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.2.1
+# insight-cli 0.2.3
 
 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-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.2.1
+# Insight Detect It Easy 0.2.3
 
 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.2.1
+# Insight dnSpyEx 0.2.3
 
 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.2.1
+# Insight .NET Dump 0.2.3
 
 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.2.1
+# Insight .NET Stack 0.2.3
 
 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.2.1
+# Insight .NET Trace 0.2.3
 
 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