pikiloom 0.4.68 → 0.4.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.68",
+  "version": "0.4.69",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {

package/packages/kernel/dist/contracts/ports.d.ts

@@ -14,6 +14,8 @@ export interface CoreSessionRecord {
     effort?: string | null;
     runState?: 'running' | 'completed' | 'incomplete';
     runDetail?: string | null;
+    runPid?: number | null;
+    runStartedAt?: number | null;
 }
 export interface SessionStore {
     ensure(agent: string, opts: {
@@ -30,6 +32,11 @@ export interface SessionStore {
         limit?: number;
     }): Promise<CoreSessionRecord[]>;
     recordResult(agent: string, sessionId: string, result: DriverResult): Promise<void>;
+    markRunning?(agent: string, sessionId: string, owner: {
+        pid: number;
+        startedAt: number;
+    }): Promise<void>;
+    reconcileRunning?(isAlive: (pid: number) => boolean): Promise<number>;
     appendTurn?(agent: string, sessionId: string, turn: UniversalSnapshot): Promise<void>;
     history?(agent: string, sessionId: string): Promise<UniversalSnapshot[]>;
 }

package/packages/kernel/dist/drivers/codex.js

@@ -263,8 +263,25 @@ export class CodexDriver {
         let steerRegistered = false;
         if (!srv.start())
             return { ok: false, text: '', error: 'failed to start codex app-server', stopReason: 'error' };
-        let settle = () => { };
-        const turnDone = new Promise((res) => { settle = res; });
+        let settled = false;
+        let resolveTurn = () => { };
+        const turnDone = new Promise((res) => { resolveTurn = res; });
+        // Idempotent: turnDone can be settled from three racing sources (turn/completed, abort,
+        // process death); the first wins and the rest are no-ops.
+        const settle = () => { if (settled)
+            return; settled = true; resolveTurn(); };
+        // If the app-server process dies WITHOUT a turn/completed (crash, kill, disconnect), the
+        // `await turnDone` below would otherwise hang forever — run() never resolves, recordResult
+        // never fires, and the session is stranded runState:"running" in the orchestrator even though
+        // the codex process is already dead. Settle it as a failed turn so the orchestrator can
+        // finalize it (mirrors the claude driver's child.on('close') settle).
+        srv.onClose(() => {
+            if (settled)
+                return;
+            state.error = state.error || srv.stderrText().trim().split('\n').pop() || 'codex app-server exited before the turn completed';
+            state.status = 'error';
+            settle();
+        });
         // On abort: gracefully interrupt the running turn, then settle turnDone OURSELVES. A bare
         // srv.kill() (SIGTERM) never produces a turn/completed notification, so without this explicit
         // settle() the `await turnDone` below hangs forever — run() never resolves and the task stays

package/packages/kernel/dist/drivers/rpc.d.ts

@@ -25,12 +25,19 @@ export declare class StdioRpcClient {
     private readonly pending;
     private notifyCb?;
     private requestCb?;
+    private closeCb?;
     private readonly stderrTail;
     private readonly label;
     constructor(opts: StdioRpcOptions);
     onNotification(cb: (method: string, params: any) => void): void;
     /** Serve peer->client requests. Throw RpcError for a coded error; anything else answers -32603. */
     onRequest(cb: (method: string, params: any, id: number | string) => any | Promise<any>): void;
+    /**
+     * Fires once when the child process exits/closes. A driver awaiting a terminal *notification*
+     * (not a pending request) MUST use this to settle its turn — otherwise a process that dies
+     * without emitting its completion notification leaves the turn hanging forever.
+     */
+    onClose(cb: () => void): void;
     /** Rolling tail of the process' stderr — startup/crash diagnostics. */
     stderrText(): string;
     start(): boolean;

package/packages/kernel/dist/drivers/rpc.js

@@ -16,6 +16,7 @@ export class StdioRpcClient {
     pending = new Map();
     notifyCb;
     requestCb;
+    closeCb;
     stderrTail = [];
     label;
     constructor(opts) {
@@ -25,6 +26,12 @@ export class StdioRpcClient {
     onNotification(cb) { this.notifyCb = cb; }
     /** Serve peer->client requests. Throw RpcError for a coded error; anything else answers -32603. */
     onRequest(cb) { this.requestCb = cb; }
+    /**
+     * Fires once when the child process exits/closes. A driver awaiting a terminal *notification*
+     * (not a pending request) MUST use this to settle its turn — otherwise a process that dies
+     * without emitting its completion notification leaves the turn hanging forever.
+     */
+    onClose(cb) { this.closeCb = cb; }
     /** Rolling tail of the process' stderr — startup/crash diagnostics. */
     stderrText() { return this.stderrTail.join('\n'); }
     start() {
@@ -55,6 +62,7 @@ export class StdioRpcClient {
             for (const cb of this.pending.values())
                 cb({ error: { message: `${this.label} exited` } });
             this.pending.clear();
+            this.closeCb?.();
         });
         this.proc.on('error', () => { });
         return true;

package/packages/kernel/dist/ports/defaults.d.ts

@@ -25,9 +25,21 @@ export declare class FsSessionStore implements SessionStore {
         text?: string;
         sessionId?: string | null;
     }): Promise<void>;
+    markRunning(agent: string, sessionId: string, owner: {
+        pid: number;
+        startedAt: number;
+    }): Promise<void>;
+    reconcileRunning(isAlive: (pid: number) => boolean): Promise<number>;
     appendTurn(agent: string, sessionId: string, turn: UniversalSnapshot): Promise<void>;
     history(agent: string, sessionId: string): Promise<UniversalSnapshot[]>;
 }
+/**
+ * Is a pid currently a live process? `signal 0` probes without delivering a signal: ESRCH =>
+ * no such process (dead); EPERM => alive but owned by someone we can't signal (treat as alive).
+ * The conservative bias (unknown => alive) is deliberate — reconciliation must never reap a turn
+ * that might still be running.
+ */
+export declare function isProcessAlive(pid: number): boolean;
 export declare function defaultBaseDir(appNamespace: string): string;
 export declare class NullModelResolver implements ModelResolver {
     resolve(): Promise<null>;

package/packages/kernel/dist/ports/defaults.js

@@ -74,6 +74,7 @@ export class FsSessionStore {
             return;
         rec.runState = result.ok ? 'completed' : 'incomplete';
         rec.runDetail = result.error ?? null;
+        rec.runPid = null; // turn is over — drop the owner so reconciliation ignores it
         if (result.sessionId)
             rec.nativeSessionId = result.sessionId;
         if (result.text && !rec.title)
@@ -82,6 +83,43 @@ export class FsSessionStore {
             rec.preview = result.text.replace(/\s+/g, ' ').trim().slice(0, 200) || rec.preview || null;
         await this.save(rec);
     }
+    async markRunning(agent, sessionId, owner) {
+        const rec = await this.get(agent, sessionId);
+        if (!rec)
+            return;
+        rec.runState = 'running';
+        rec.runDetail = null;
+        rec.runPid = owner.pid;
+        rec.runStartedAt = owner.startedAt;
+        await this.save(rec);
+    }
+    async reconcileRunning(isAlive) {
+        let agents = [];
+        try {
+            agents = fs.readdirSync(this.baseDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name);
+        }
+        catch {
+            return 0;
+        }
+        let repaired = 0;
+        for (const agent of agents) {
+            for (const rec of await this.list(agent)) {
+                if (rec.runState !== 'running')
+                    continue;
+                // Only reap a KNOWN-dead owner. No pid (legacy record) or a live pid (possibly a turn
+                // running in another process against this shared store) is left alone — never clobber a
+                // turn that might still be live elsewhere.
+                if (typeof rec.runPid !== 'number' || isAlive(rec.runPid))
+                    continue;
+                rec.runState = 'incomplete';
+                rec.runDetail = rec.runDetail || 'interrupted: owner process exited';
+                rec.runPid = null;
+                await this.save(rec);
+                repaired++;
+            }
+        }
+        return repaired;
+    }
     async appendTurn(agent, sessionId, turn) {
         const p = this.turnsPath(agent, sessionId);
         fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -108,6 +146,23 @@ export class FsSessionStore {
         return out;
     }
 }
+/**
+ * Is a pid currently a live process? `signal 0` probes without delivering a signal: ESRCH =>
+ * no such process (dead); EPERM => alive but owned by someone we can't signal (treat as alive).
+ * The conservative bias (unknown => alive) is deliberate — reconciliation must never reap a turn
+ * that might still be running.
+ */
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === 'EPERM';
+    }
+}
 export function defaultBaseDir(appNamespace) {
     return path.join(os.homedir(), `.${appNamespace}`, 'sessions');
 }

package/packages/kernel/dist/runtime/hub.js

@@ -94,6 +94,10 @@ export class Hub {
         };
         this.sessions.set(sessionKey, entry);
         this.emitSessionsChanged();
+        // Stamp the persisted record as running under THIS process, so runState is authoritative for
+        // the whole turn (new AND resumed) and a crash strands an owner pid that boot reconciliation
+        // can reap. Best-effort: a store without markRunning just won't be reconcilable.
+        await this.deps.sessionStore.markRunning?.(agent, sessionId, { pid: process.pid, startedAt: Date.now() }).catch(() => { });
         // Resolve injection / tools / resume-target at run time so a promoted turn sees the
         // prior turn's native session id and any refreshed credentials/tools.
         const rec = await this.deps.sessionStore.get(agent, sessionId);

package/packages/kernel/dist/runtime/loom.js

@@ -1,4 +1,4 @@
-import { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, NoopCatalog, DeferToTerminalInteractionHandler, defaultBaseDir, } from '../ports/defaults.js';
+import { FsSessionStore, NullModelResolver, NoopToolProvider, PassthroughSystemPromptBuilder, NoopCatalog, DeferToTerminalInteractionHandler, defaultBaseDir, isProcessAlive, } from '../ports/defaults.js';
 import { Hub } from './hub.js';
 import { PtyBridge } from './pty.js';
 import { attachTui } from './tui.js';
@@ -59,6 +59,17 @@ export function createLoom(config = {}) {
             if (started)
                 return;
             started = true;
+            // Repair sessions stranded at runState:'running' by a previous process that died mid-turn
+            // (crash / kill / power loss) before its driver could settle. Safe under a shared store:
+            // only records whose owner pid is dead are reaped (see reconcileRunning). Best-effort.
+            try {
+                const repaired = await sessionStore.reconcileRunning?.(isProcessAlive);
+                if (repaired)
+                    log(`[loom] reconciled ${repaired} orphaned running session(s) at startup`);
+            }
+            catch (e) {
+                log(`[loom] startup reconcile failed: ${e?.message || e}`);
+            }
             for (const t of surfaces) {
                 await t.start(hub, { openTui }); // hub = Lane S (LoomIO); openTui = Lane R
                 log(`[loom] terminal started: ${t.id}`);