@eyeauras/insight-cli 0.5.4 → 0.5.5

package/.cli-package-build.json

@@ -1 +1 @@
-{"version":1,"artifact":"7bea52ce544d1aaddb45588523b18cd693135aaaea9d4e02564623ad8f2b127e"}
+{"version":1,"artifact":"338d2246eeab5c3a4de372ad6e77d505601a39dad11aea43d3627988afd14ba2"}

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.5.4
+# insight-cli 0.5.5
 
 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/analysis-storage.d.ts

@@ -115,7 +115,8 @@ export declare class AnalysisStorage {
     }>;
     private checkCopy;
     private continue;
-    resume(c: CommandContext): Promise<{
+    private repairBinding;
+    resume(c: CommandContext, repairProfile?: boolean): Promise<{
         state: "rolled_back";
         id: string;
         directory: string;

package/dist/src/analysis-storage.js

@@ -251,8 +251,14 @@ export class AnalysisStorage {
             fail('busy', 'Finish active commands before storage migration.');
         this.changing.add(key);
         try {
-            const processes = (await listProcesses(key)).filter(p => !['exited', 'failed'].includes(p.state));
-            const native = await runtimeProcesses(key);
+            let processes, native;
+            try {
+                processes = (await listProcesses(key)).filter(p => !['exited', 'failed'].includes(p.state));
+                native = await runtimeProcesses(key);
+            }
+            catch (error) {
+                throw new CliError('Cannot verify storage process inventory. Inspect storage show and preserve legacy compatibility paths before retrying.', { code: 'storage.inventory', cause: error, next: [['storage', 'show']] });
+            }
             if (processes.length || native.length)
                 throw new CliError('Close the profile contexts and stop its owned server/processes before migration. Unverified lifetimes also block copying.', { code: 'storage.busy', result: { processes, native }, next: [['tools', 'processes']] });
             await this.release(c);
@@ -354,8 +360,14 @@ export class AnalysisStorage {
             return this.restore(c, j);
         if (j.state === 'cleaning')
             return this.finishCleanup(c, j);
-        if (terminal(j.state) && !(j.automatic && j.state === 'committed'))
-            return this.show(c);
+        if (terminal(j.state) && !(j.automatic && j.state === 'committed')) {
+            const selected = { ...c, profile: await this.store(c).get(c.profile.name) };
+            await this.validate(selected);
+            const status = await this.show(selected);
+            if (status.availability !== 'available')
+                throw new CliError('Completed migration storage is unavailable. Inspect storage show before retrying.', { code: 'storage.unavailable', next: [['storage', 'show']] });
+            return status;
+        }
         if (j.makeDefault && !j.defaultApplied) {
             const base = dirname(dirname(j.destination));
             if (await canonicalFuture(base) !== base)
@@ -535,8 +547,60 @@ export class AnalysisStorage {
         }
         return { state: j.state, id: j.id, directory: j.destination, manifest: j.manifest, sourceRetained: true, defaultBaseDirectory: storageDefault(c)?.base ?? null, installationDefault: j.makeDefault ? (j.defaultSuperseded ? 'superseded' : 'configured') : 'unchanged', rollback: 'storage rollback', cleanup: 'storage cleanup' };
     }
-    async resume(c) { return this.exclusive(c, async () => { const j = await this.journal(c, true); if (!j)
-        fail('missing', 'No migration journal exists.'); return this.continue(c, j); }); }
+    async repairBinding(c, j) {
+        if (!['committed', 'cleaned'].includes(j.state))
+            fail('repair', 'Profile repair requires a completed migration. Resume the pending transaction without --repair-profile.');
+        if (await directoryIdentity(j.source) !== j.sourceIdentity || await canonicalFuture(j.destination) !== j.destination || !j.targetIdentity || await directoryIdentity(j.destination) !== j.targetIdentity)
+            fail('binding', 'Migration source or destination identity changed. Preserve both copies; profile repair was refused.');
+        if (await directoryIdentity(j.destinationAnchor) !== j.destinationIdentity)
+            fail('volume', 'Migration destination volume changed. Profile repair was refused.');
+        if (j.defaultBinding)
+            validateStorageDefault(c, j.defaultBinding);
+        if (j.defaultBaseIdentity && await directoryIdentity(dirname(dirname(j.destination))) !== j.defaultBaseIdentity)
+            fail('volume', 'Storage base changed. Profile repair was refused.');
+        const marker = await readJson(join(j.destination, '.insight-analysis.json'));
+        if (marker?.schema !== 1 || marker.id !== j.id || marker.binding !== j.binding || marker.profile !== j.profile)
+            fail('binding', 'Destination ownership does not match the retained migration. Profile repair was refused.');
+        for (const tree of analysisTrees) {
+            const target = join(j.destination, tree), alias = join(j.source, tree);
+            try {
+                if (await canonicalFuture(target) !== target || !(await lstat(target)).isDirectory() || !(await lstat(alias)).isSymbolicLink() || await realpath(alias) !== target)
+                    fail('aliases', 'A migration compatibility path changed. Preserve the conflicting path and restore its recorded destination before profile repair.');
+            }
+            catch (error) {
+                if (error instanceof CliError)
+                    throw error;
+                throw new CliError('Cannot verify a migration compatibility path. Preserve both copies before profile repair.', { code: 'storage.aliases', cause: error });
+            }
+        }
+        const setting = c.profile.values.analysisDirectory;
+        if (setting !== undefined && setting !== null && setting !== j.previous && setting !== j.source && setting !== j.destination)
+            fail('configuration', 'The profile selects a different storage location. Preserve it; automatic profile repair was refused.');
+    }
+    async resume(c, repairProfile = false) {
+        const j = await this.journal(c, true);
+        if (!j)
+            fail('missing', 'No migration journal exists.');
+        // Diagnose a terminal profile mismatch before scanning legacy native paths.
+        if (['committed', 'cleaned'].includes(j.state)) {
+            if (repairProfile)
+                await this.repairBinding(c, j);
+            else if (analysisDirectory(c) !== j.destination)
+                throw new CliError('Factory profile and completed migration differ. Verify and restore the profile with storage resume --repair-profile.', { code: 'storage.configuration', next: [['storage', 'resume', '--repair-profile']] });
+        }
+        else if (repairProfile)
+            fail('repair', 'Profile repair requires a completed migration. Resume without --repair-profile.');
+        return this.exclusive(c, async () => {
+            if (repairProfile) {
+                c = { ...c, profile: await this.store(c).get(c.profile.name) };
+                await this.repairBinding(c, j);
+                await this.store(c).set(c.profile.name, { analysisDirectory: j.destination });
+                await sync(join(c.appArguments.RoamingAppDataDirectory, 'profiles.json'));
+                c = { ...c, profile: await this.store(c).get(c.profile.name) };
+            }
+            return this.continue(c, j);
+        });
+    }
     async rollback(c) {
         return this.exclusive(c, async () => {
             const j = await this.journal(c, true);
@@ -650,7 +714,7 @@ export class AnalysisStorage {
             command('default', 'Set the installation storage base for new profiles; preserve existing data locations', ({ options: o }, c) => this.setDefault(c, o.directory), { permission: Permission.Update, options: [directory] }),
             command('configure', 'Choose storage for an empty profile and subsequent new profiles', ({ options: o }, c) => this.migrate(c, o.directory, false, true, Boolean(o.profileOnly)), { permission: Permission.Update, options: [directory, profileOnly] }),
             command('migrate', 'Copy and verify all analysis data, retain source, then switch storage', ({ options: o }, c) => this.migrate(c, o.directory, Boolean(o.dryRun), false, Boolean(o.profileOnly)), { permission: Permission.Update, options: [directory, profileOnly, { flags: '--dry-run', description: 'Read-only path, capacity and quiescence preflight; create no migration' }] }),
-            command('resume', 'Resume the retained copy/activation or rollback without replaying research', (_i, c) => this.resume(c), { permission: Permission.Update }),
+            command('resume', 'Resume migration, or explicitly repair its completed profile binding', ({ options: o }, c) => this.resume(c, Boolean(o.repairProfile)), { permission: Permission.Update, options: [{ flags: '--repair-profile', description: 'Restore a completed migration setting after verifying destination ownership and compatibility paths' }] }),
             command('rollback', 'Restore retained source; refuse after any destination content changes', (_i, c) => this.rollback(c), { permission: Permission.Update }),
             command('cleanup', 'Delete verified retained source copies; retain compatibility paths permanently', (_i, c) => this.cleanup(c), { permission: 'Destructive' }),
         ]);

package/dist/src/context-diagnostics.d.ts

@@ -1,7 +1,7 @@
 import { type CommandContext, type CommandDefinition } from '@eyeauras/cli-factory';
 import { type Research } from './research.js';
 import type { Workspace, Scope } from './workspace.js';
-export type StopReason = 'explicit_close' | 'view_replaced' | 'mode_changed' | 'owner_dispose' | 'startup_failed' | 'temporary_complete' | 'legacy_cleanup' | 'unknown';
+export type StopReason = 'explicit_close' | 'view_replaced' | 'mode_changed' | 'owner_dispose' | 'startup_failed' | 'temporary_complete' | 'legacy_cleanup' | 'backend_unresponsive' | 'unknown';
 type Event = {
     at: string;
     event: 'start' | 'restore' | 'stop';

package/dist/src/context-diagnostics.js

@@ -7,7 +7,7 @@ import { object, fail, stable } from './model.js';
 import { selectedOptions } from './arguments.js';
 const writes = new Map();
 const journal = (workspace, context) => join(workspace.directory, 'diagnostics', 'lifecycle', context + '.json');
-const reasons = new Set(['explicit_close', 'view_replaced', 'mode_changed', 'owner_dispose', 'startup_failed', 'temporary_complete', 'legacy_cleanup', 'unknown', 'native_launch', 'saved_snapshot']);
+const reasons = new Set(['explicit_close', 'view_replaced', 'mode_changed', 'owner_dispose', 'startup_failed', 'temporary_complete', 'legacy_cleanup', 'unknown', 'native_launch', 'saved_snapshot', 'backend_unresponsive']);
 async function events(path) {
     try {
         const rows = JSON.parse(await readFile(path, 'utf8'));

package/dist/src/contexts.d.ts

@@ -62,6 +62,7 @@ export declare class GhidraContexts {
     private model;
     private privateCopy;
     open(scope: Scope, request?: string): Promise<GhidraContext>;
+    private retireUnresponsive;
     private selected;
     observation(scope: Scope): Promise<{
         incarnation: string;

package/dist/src/contexts.js

@@ -429,7 +429,7 @@ export class GhidraContexts {
     }
     async open(scope, request) {
         const context = this.workspace.context(scope), target = this.workspace.target(scope.target);
-        if (this.workspace.unresolved(scope).some(intent => intent.id !== request))
+        if (this.workspace.unresolved(scope).some(intent => intent.id !== request && intent.operation !== 'ghidra.open'))
             fail('blocked', 'This context retains an unresolved operation; reconcile its recorded outcome before continuing.');
         let binding;
         try {
@@ -458,8 +458,15 @@ export class GhidraContexts {
         if (binding && !stopped && alive(binding.pid)) {
             if (binding.context !== context.id)
                 fail('binding', 'Native process belongs to a different working context.');
-            await this.verified(binding, target);
-            return context;
+            try {
+                await this.verified(binding, target);
+                return context;
+            }
+            catch (error) {
+                if (!await this.retireUnresponsive(scope, binding, error))
+                    throw error;
+                stopped = true;
+            }
         }
         if (binding?.mode === 'gui')
             await this.debuggerReleased(binding);
@@ -486,6 +493,25 @@ export class GhidraContexts {
         return this.workspace.saveContext(scope, context.generation, { state: 'ready', baseRevision: model.sharedRevision,
             baseSnapshot: snapshot, workingSnapshot: snapshot });
     }
+    async retireUnresponsive(scope, binding, error) {
+        const failure = error;
+        if (!['coordinator.timeout', 'coordinator.transport'].includes(failure.code ?? '') || failure.result?.operation !== '/mcp/instance_info' ||
+            binding.mode !== 'headless' || !binding.toolProcessId)
+            return false;
+        const context = this.workspace.context(scope);
+        if (!context.workingSnapshot || context.debugger?.connected || this.workspace.activePublication(scope.target) ||
+            this.workspace.unresolved(scope).some(intent => intent.operation !== 'ghidra.open'))
+            return false;
+        // Verify acknowledged bytes before retiring anything. Unknown mutations stay blocked.
+        await this.workspace.artifacts.verify(context.workingSnapshot);
+        const row = await processStatus(this.c.appArguments.AppDataDirectory, binding.toolProcessId, r => verifyGhidraProcess(r, this.c));
+        if (row.state !== 'running' || row.pid !== binding.pid || row.tool !== 'ghidra' || row.role !== 'context' || row.session !== scope.session ||
+            row.target !== scope.target || row.installation !== binding.runtimeFingerprint || row.metadata?.contextRoot !== binding.root)
+            return false;
+        await terminateProcess(this.c.appArguments.AppDataDirectory, binding.toolProcessId, true, r => verifyGhidraProcess(r, this.c));
+        await this.stopRecord({ binding, http: new HttpBridge(binding.endpoint) }, false, true, 'backend_unresponsive');
+        return true;
+    }
     async selected(scope) {
         const context = this.workspace.context(scope);
         const binding = JSON.parse(await readFile(join(this.directory(), 'context', context.id, 'current.json'), 'utf8'));

package/dist/src/ghidra-processes.js

@@ -1,3 +1,4 @@
+import { nativeProcessProof } from './tool-runtime/native-process-proof.js';
 import { sameDirectory, ownedDirectory, projectPathWithin } from './directory-identity.js';
 import { runtimeSelection } from './runtime-selection.js';
 import { join, resolve, relative, sep, dirname } from 'node:path';
@@ -52,7 +53,11 @@ export async function verifyGhidraProcess(r, c) {
             const root = await ownedPath(c, r.metadata.contextRoot), binding = JSON.parse(await readFile(join(root, 'process.json'), 'utf8'));
             if (!sameDirectory(binding.root, root) || binding.pid !== r.pid || binding.runtimeFingerprint !== r.installation || binding.target !== r.target)
                 return false;
-            const token = await c.secrets.require(binding.tokenSecret), info = await new HttpBridge(binding.endpoint, c.fetch, undefined, token, 1500).instance();
+            const token = await c.secrets.require(binding.tokenSecret);
+            // A headless JVM may be unable to serve HTTP while the kernel still proves its token, executable and private context root.
+            if (binding.mode === 'headless' && await nativeProcessProof(r.pid, r.executable, root, token))
+                return true;
+            const info = await new HttpBridge(binding.endpoint, c.fetch, undefined, token, 1500).instance();
             return info.pid === r.pid && info.tcp_port === Number(new URL(binding.endpoint).port) && projectPathWithin(info.project_path, binding.root);
         }
         return undefined;

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

@@ -1,4 +1,4 @@
-import { writeFile } from 'node:fs/promises';
+import { writeFile, realpath } from 'node:fs/promises';
 import { join, win32 } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -36,7 +36,7 @@ export async function javaClasspathArguments(root, tool, executable, args, platf
     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 path = join(await realpath(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 });

package/dist/src/tool-runtime/native-process-proof.d.ts

@@ -0,0 +1,2 @@
+/** Independent kernel observation; no request enters the possibly wedged JVM. */
+export declare function nativeProcessProof(pid: number, executable: string, cwd: string, token: string): Promise<boolean>;

package/dist/src/tool-runtime/native-process-proof.js

@@ -0,0 +1,26 @@
+import { readFile, realpath } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+const exec = promisify(execFile);
+/** Independent kernel observation; no request enters the possibly wedged JVM. */
+export async function nativeProcessProof(pid, executable, cwd, token) {
+    if (process.platform !== 'darwin' || !Number.isSafeInteger(pid) || pid < 1)
+        return false;
+    try {
+        const base = new URL('../../../runtime/native/', import.meta.url), path = fileURLToPath(new URL('process-identity-darwin-' + process.arch, base));
+        const provenance = JSON.parse(await readFile(new URL('process-identity.provenance.json', base), 'utf8'));
+        if (provenance.platform !== 'darwin' || provenance.architecture !== process.arch || createHash('sha256').update(await readFile(path)).digest('hex') !== provenance.sha256)
+            return false;
+        const result = await exec(path, [String(pid)], { timeout: 3000, maxBuffer: 16384, env: { PATH: '/usr/bin:/bin' } }), row = JSON.parse(result.stdout);
+        if (row.pid !== pid || row.uid !== process.geteuid?.() || !Number.isSafeInteger(row.birthSeconds) || row.birthSeconds <= 0 || !Number.isSafeInteger(row.birthMicroseconds) || row.birthMicroseconds < 0 || row.birthMicroseconds >= 1000000 || typeof row.tokenSha256 !== 'string' || !/^[a-f0-9]{64}$/.test(row.tokenSha256))
+            return false;
+        if (await realpath(row.executable) !== await realpath(executable) || await realpath(row.root) !== await realpath(cwd))
+            return false;
+        return timingSafeEqual(Buffer.from(row.tokenSha256, 'hex'), createHash('sha256').update(token).digest());
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -1,9 +1,9 @@
-import { mkdir, writeFile } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
 import { join, isAbsolute, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { performance } from 'node:perf_hooks';
 import { CliError } from '@eyeauras/cli-factory';
-import { atomicWrite, withToolUse, toolRoot, readJson } from './store.js';
+import { atomicWrite, withToolUse, toolRoot, readJson, prepareRunRoot } from './store.js';
 import { launchProcess } from './supervisor.js';
 import { digest } from '../model.js';
 import { deadlineLaunch } from './deadline.js';
@@ -23,7 +23,7 @@ export async function runTool(c, spec) {
     const started = performance.now(), limit = spec.maxOutputBytes ?? 4 * 1024 ** 2;
     let child, outcome, truncated = false, bytes = 0;
     const stdout = [], stderr = [], record = { schema: 1, id, tool: spec.tool, role: spec.role, installation: spec.installation ?? 'probe', state: 'starting', executable: spec.executable, createdAt: new Date().toISOString(), root, ownerPid: process.pid, profileBinding: digest(resolve(directory)), gated: process.platform !== 'win32' && typeof process.execve === 'function', phase: 'reserved', ...(spec.session ? { session: spec.session } : {}), ...(spec.target ? { target: spec.target } : {}) };
-    const lease = await withToolUse(directory, spec.tool, async () => { await mkdir(root, { recursive: true, mode: 0o700 }); }, c.signal);
+    const lease = await withToolUse(directory, spec.tool, async () => { await prepareRunRoot(directory, id); }, c.signal);
     const environment = { PATH: c.environment.PATH ?? process.env.PATH, HOME: root, TMPDIR: root, ...(process.platform === 'win32' ? { SystemRoot: process.env.SystemRoot, WINDIR: process.env.WINDIR, ComSpec: process.env.ComSpec, TEMP: root, TMP: root, USERPROFILE: root, LOCALAPPDATA: root, APPDATA: root } : {}), ...spec.environment };
     const secrets = Object.entries(environment).filter(([key, value]) => /TOKEN|PASSWORD|SECRET|KEY/i.test(key) && value && value.length >= 4).map(([, v]) => v);
     const redact = (value) => secrets.reduce((text, secret) => text.split(secret).join('[redacted]'), value);

package/dist/src/tool-runtime/store.d.ts

@@ -1,4 +1,6 @@
 export declare function atomicWrite(path: string, value: unknown): Promise<void>;
+/** Create new run folders through the physical runtime, retaining logical receipt identity. */
+export declare function prepareRunRoot(directory: string, id: string): Promise<void>;
 export declare function readJson<T>(path: string): Promise<T | undefined>;
 export declare function toolRoot(directory: string, tool: string): string;
 /** CLI clients already share Factory's elected owner. Do not create another IPC/lease protocol. */

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

@@ -1,13 +1,14 @@
 import { mkdir, open, rename, rm, readFile, readdir, lstat, realpath } from 'node:fs/promises';
-import { createReadStream } from 'node:fs';
-import { dirname, join, resolve, relative, sep } from 'node:path';
+import { createReadStream, existsSync } from 'node:fs';
+import { dirname, basename, join, resolve, relative, sep } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { CliError } from '@eyeauras/cli-factory';
 import { fail } from '../model.js';
 export async function atomicWrite(path, value) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const temporary = path + '.new-' + randomUUID(), file = await open(temporary, 'wx', 0o600);
+    const parent = await physicalDirectory(dirname(path)), target = join(parent, basename(path));
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    const temporary = target + '.new-' + randomUUID(), file = await open(temporary, 'wx', 0o600);
     try {
         await file.writeFile(JSON.stringify(value, null, 2) + '\n');
         await file.sync();
@@ -15,17 +16,34 @@ export async function atomicWrite(path, value) {
     finally {
         await file.close();
     }
-    await rename(temporary, path);
+    await rename(temporary, target);
     if (process.platform !== 'win32') {
-        const parent = await open(dirname(path), 'r');
+        const handle = await open(parent, 'r');
         try {
-            await parent.sync();
+            await handle.sync();
         }
         finally {
-            await parent.close();
+            await handle.close();
         }
     }
 }
+async function physicalDirectory(path) {
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT' || dirname(path) === path)
+            throw error;
+        return join(await physicalDirectory(dirname(path)), basename(path));
+    }
+}
+/** Create new run folders through the physical runtime, retaining logical receipt identity. */
+export async function prepareRunRoot(directory, id) {
+    const runtime = join(directory, 'runtime');
+    if (!existsSync(runtime))
+        await mkdir(runtime, { recursive: true, mode: 0o700 });
+    await mkdir(join(await realpath(runtime), 'runs', id), { recursive: true, mode: 0o700 });
+}
 export async function readJson(path) { try {
     return JSON.parse(await readFile(path, 'utf8'));
 }

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

@@ -1,13 +1,13 @@
 import { sameDirectory } from '../directory-identity.js';
 import { spawn } from 'node:child_process';
-import { access, mkdir, readdir } from 'node:fs/promises';
+import { access, readdir } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import { join, isAbsolute, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { CliError } from '@eyeauras/cli-factory';
-import { atomicWrite, readJson, toolRoot, withToolLock } from './store.js';
+import { atomicWrite, readJson, toolRoot, withToolLock, prepareRunRoot } from './store.js';
 import { processIdentity } from './identity.js';
 import { javaClasspathArguments } from './java-arguments.js';
 import { digest } from '../model.js';
@@ -53,7 +53,7 @@ export async function launchProcess(directory, spec, executable, args, options =
         if (!/^[a-f0-9-]{36}$/.test(id))
             throw Error('Invalid process identity');
         const root = join(directory, 'runtime/runs', id), path = join(directory, 'runtime/processes', id + '.json');
-        await mkdir(root, { recursive: true, mode: 0o700 });
+        await prepareRunRoot(directory, id);
         const gated = process.platform !== 'win32' && typeof process.execve === 'function';
         const record = { schema: 1, id, ...spec, state: 'starting', executable, root, ownerPid: process.pid, profileBinding: digest(resolve(directory)), gated, phase: 'reserved', createdAt: new Date().toISOString() };
         await atomicWrite(path, record);
@@ -273,7 +273,7 @@ export async function registerExistingProcess(directory, spec, executable, pid,
     const previous = await readJson(path);
     if (previous)
         return id;
-    await mkdir(root, { recursive: true, mode: 0o700 });
+    await prepareRunRoot(directory, id);
     await atomicWrite(path, record);
     return id;
 }

package/package.json

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

package/references/recovery.md

@@ -24,6 +24,23 @@ 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.
 
+## Unresponsive headless backend
+
+Continue the same session/target with ordinary `ghidra open` or a research read. When the
+backend fails its identity preflight, the facade verifies the acknowledged private snapshot
+and independently authenticates the exact worker before retiring it and restoring that snapshot.
+This automatic retirement is limited to headless contexts without uncertain mutations, active
+publication or a connected debugger. A failed health preflight is never permission to repeat a
+script, save or publication. Journals, original projects and acknowledged pending edits remain.
+Lifecycle diagnostics record `backend_unresponsive` followed by snapshot restoration.
+
+On macOS ARM64 the packaged read-only kernel helper checks the same-user process, executable,
+private root and digest of its unique context token without entering the JVM. It emits no token,
+argument list or environment values. PID birth and profile bindings remain independently checked.
+A missing/unreadable/mismatched proof stays blocked; never kill by port, basename or guessed PID.
+Other platforms retain their existing ownership authentication; this does not claim equivalent
+hang recovery where no independent proof is available. No compiler is required on installation.
+
 ## Interrupted save or close
 
 After restoring profile storage, inspect the selected session and target with

package/references/storage.md

@@ -84,6 +84,17 @@ those links or their profile/source ancestors manually after migrating.
 
 ## Interruptions, uncertainty and retention
 
+If a completed migration no longer agrees with the Factory profile setting, ordinary
+commands and `storage resume` fail. After inspecting `storage show`, explicitly restore
+the setting with `storage resume --repair-profile --json`. This Update operation verifies
+the journal, source/destination identities, destination ownership and every compatibility
+link before changing only `analysisDirectory`. Later destination research is preserved;
+the old migration manifest is not used to roll it back. A different selected location,
+missing volume or replaced compatibility path blocks repair. Preserve conflicting paths
+and restore the recorded links before retrying; repair never deletes or merges them.
+Process-inventory failures are reported as `storage.inventory` with the original cause
+available under `--verbose`. A terminal unavailable migration is never a successful resume.
+
 ```sh
 insight-cli storage resume --json
 insight-cli storage rollback --json

package/runtime/native/process-identity-darwin.c

@@ -0,0 +1,47 @@
+/* MIT; first-party read-only process proof. Never prints argv or environment values. */
+#include <libproc.h>
+#include <sys/sysctl.h>
+#include <sys/proc_info.h>
+#include <sys/proc.h>
+#include <CommonCrypto/CommonDigest.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+static void json(const char *s) {
+ putchar('"'); for(const unsigned char *p=(const unsigned char *)s;*p;p++) {
+  if(*p=='"'||*p=='\\')printf("\\%c",*p); else if(*p<32)printf("\\u%04x",*p);else putchar(*p);
+ } putchar('"');
+}
+int main(int argc,char **argv) {
+ if(argc==2&&!strcmp(argv[1],"--version")){puts("insight-process-identity 1");return 0;}
+ char *end=NULL;errno=0;long value=argc==2?strtol(argv[1],&end,10):0;
+ if(errno||!end||*end||value<1||value>2147483647)return 64;
+ int pid=(int)value;struct proc_bsdinfo before,after;char executable[PROC_PIDPATHINFO_MAXSIZE];
+ if(proc_pidinfo(pid,PROC_PIDTBSDINFO,0,&before,sizeof before)!=sizeof before||before.pbi_uid!=geteuid()||before.pbi_status==SZOMB)return 11;
+ memset(executable,0,sizeof executable);int has_path=proc_pidpath(pid,executable,sizeof executable)>0;
+ char owned_root[PROC_PIDPATHINFO_MAXSIZE]={0};
+ int mib[3]={CTL_KERN,KERN_PROCARGS2,pid};size_t size=0;
+ if(sysctl(mib,3,NULL,&size,NULL,0)||size<sizeof(int)||size>2*1024*1024)return 13;
+ char *data=calloc(size+1,1);if(!data)return 70;
+ if(sysctl(mib,3,data,&size,NULL,0)){free(data);return 14;}
+ int nargs;memcpy(&nargs,data,sizeof nargs);if(nargs<1||nargs>65536){free(data);return 1;}
+ char *p=data+sizeof(int),*limit=data+size;size_t executable_length=strnlen(p,(size_t)(limit-p));
+ if(executable_length>=sizeof executable||p+executable_length>=limit){free(data);return 1;}
+ if(!has_path)memcpy(executable,p,executable_length+1);
+ while(p<limit&&*p)p++;while(p<limit&&!*p)p++;
+ for(int i=0;i<nargs&&p<limit;i++){while(p<limit&&*p)p++;if(p<limit)p++;}
+ unsigned char digest[CC_SHA256_DIGEST_LENGTH];int found=0;const char key[]="GHIDRA_MCP_AUTH_TOKEN=";
+ while(p<limit&&!*p)p++;
+ while(p<limit&&*p){size_t n=strnlen(p,(size_t)(limit-p));
+  if(n>sizeof(key)-1&&!memcmp(p,key,sizeof(key)-1)){if(found){free(data);return 1;}CC_SHA256(p+sizeof(key)-1,(CC_LONG)(n-sizeof(key)+1),digest);found=1;}
+  const char root_key[]="GHIDRA_MCP_FILE_ROOT=";
+  if(n>sizeof(root_key)-1&&!memcmp(p,root_key,sizeof(root_key)-1)){size_t length=n-sizeof(root_key)+1;if(owned_root[0]||length>=sizeof owned_root){free(data);return 1;}memcpy(owned_root,p+sizeof(root_key)-1,length);}
+  p+=n+1;
+ }
+ memset(data,0,size);free(data);
+ if(!found||!owned_root[0]||proc_pidinfo(pid,PROC_PIDTBSDINFO,0,&after,sizeof after)!=sizeof after||before.pbi_start_tvsec!=after.pbi_start_tvsec||before.pbi_start_tvusec!=after.pbi_start_tvusec||before.pbi_uid!=after.pbi_uid)return 15;
+ printf("{\"pid\":%d,\"uid\":%u,\"birthSeconds\":%llu,\"birthMicroseconds\":%llu,\"executable\":",pid,before.pbi_uid,before.pbi_start_tvsec,before.pbi_start_tvusec);json(executable);
+ printf(",\"root\":");json(owned_root);printf(",\"tokenSha256\":\"");for(size_t i=0;i<sizeof digest;i++)printf("%02x",digest[i]);puts("\"}");return 0;
+}

package/runtime/native/process-identity.provenance.json

@@ -0,0 +1,18 @@
+{
+  "schema": 1,
+  "license": "MIT",
+  "platform": "darwin",
+  "architecture": "arm64",
+  "compiler": "Apple clang version 17.0.0 (clang-1700.3.19.1)\nTarget: arm64-apple-darwin25.6.0\nThread model: posix\nInstalledDir: /Library/Developer/CommandLineTools/usr/bin",
+  "sourceSha256": "f147da90168123783593f06461c78aea9e4b6ac326b7bdd003da1b0765a06265",
+  "sha256": "8d7a15c925ba49b8bea5280c94c03c5a9e39ac33f408ad6dcc068af095e796f4",
+  "flags": [
+    "-arch",
+    "arm64",
+    "-mmacosx-version-min=13.0",
+    "-O2",
+    "-g0",
+    "-Werror",
+    "-Wno-deprecated-declarations"
+  ]
+}

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.5.4
+# Insight Artifacts 0.5.5
 
 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,6 +24,23 @@ 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.
 
+## Unresponsive headless backend
+
+Continue the same session/target with ordinary `ghidra open` or a research read. When the
+backend fails its identity preflight, the facade verifies the acknowledged private snapshot
+and independently authenticates the exact worker before retiring it and restoring that snapshot.
+This automatic retirement is limited to headless contexts without uncertain mutations, active
+publication or a connected debugger. A failed health preflight is never permission to repeat a
+script, save or publication. Journals, original projects and acknowledged pending edits remain.
+Lifecycle diagnostics record `backend_unresponsive` followed by snapshot restoration.
+
+On macOS ARM64 the packaged read-only kernel helper checks the same-user process, executable,
+private root and digest of its unique context token without entering the JVM. It emits no token,
+argument list or environment values. PID birth and profile bindings remain independently checked.
+A missing/unreadable/mismatched proof stays blocked; never kill by port, basename or guessed PID.
+Other platforms retain their existing ownership authentication; this does not claim equivalent
+hang recovery where no independent proof is available. No compiler is required on installation.
+
 ## Interrupted save or close
 
 After restoring profile storage, inspect the selected session and target with

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

@@ -84,6 +84,17 @@ those links or their profile/source ancestors manually after migrating.
 
 ## Interruptions, uncertainty and retention
 
+If a completed migration no longer agrees with the Factory profile setting, ordinary
+commands and `storage resume` fail. After inspecting `storage show`, explicitly restore
+the setting with `storage resume --repair-profile --json`. This Update operation verifies
+the journal, source/destination identities, destination ownership and every compatibility
+link before changing only `analysisDirectory`. Later destination research is preserved;
+the old migration manifest is not used to roll it back. A different selected location,
+missing volume or replaced compatibility path blocks repair. Preserve conflicting paths
+and restore the recorded links before retrying; repair never deletes or merges them.
+Process-inventory failures are reported as `storage.inventory` with the original cause
+available under `--verbose`. A terminal unavailable migration is never a successful resume.
+
 ```sh
 insight-cli storage resume --json
 insight-cli storage rollback --json

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.5.4
+# Insight Binary 0.5.5
 
 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.5.4
+# Insight Capture 0.5.5
 
 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.5.4
+# insight-cli 0.5.5
 
 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