@adhdev/daemon-core 1.0.17 → 1.0.18-rc.10

package/src/cli-adapters/provider-cli-adapter.ts

@@ -707,8 +707,10 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         });
 
-        this.ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
-            LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode}`);
+        this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number | null; signal?: number | null }) => {
+            // Preserve the unknown case: a null exitCode (signal-terminated or
+            // otherwise unreported) is logged as "unknown", never as exit 0.
+            LOG.info('CLI', `[${this.cliType}] Exit code ${exitCode === null || exitCode === undefined ? 'unknown' : exitCode}${signal ? ` (signal ${signal})` : ''}`);
             this.flushPendingOutputParse();
             this.ptyProcess = null;
             this.engine.onPtyExit();
@@ -1072,7 +1074,19 @@ export class ProviderCliAdapter implements CliAdapter {
 
     getStatus(options: { allowParse?: boolean } = {}): CliSessionStatus {
         const allowParse = options.allowParse !== false;
-        const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        let startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        // (fix: kimi startup-gate stale-approval bypass) startupParseGate can
+        // still be open by the time a real approval is requested AND resolved
+        // — this ad-hoc parse of recentOutputBuffer runs independently of the
+        // settled-eval loop and previously had no staleness protection at all,
+        // so it kept re-surfacing the identical already-resolved modal for as
+        // long as its text remained anywhere in the rolling buffer, bypassing
+        // engine.activeModal (which resolveModal() had already correctly
+        // cleared). Reuse the SAME discriminator the settle loop uses instead
+        // of inventing a second one here.
+        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
+            startupModal = null;
+        }
         const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal
             ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText())
             : null;
@@ -1179,7 +1193,20 @@ export class ProviderCliAdapter implements CliAdapter {
                 // and let a later evaluate find the complete modal.
                 const buttonsOk = liveModal && Array.isArray(liveModal.buttons)
                     && liveModal.buttons.some((b: any) => typeof b === 'string' && b.trim());
-                if (liveModal && buttonsOk) {
+                // (fix: kimi live-detect stale-approval bypass) This fallback is
+                // NOT gated by startupParseGate — it runs on every getStatus()
+                // call (including the periodic background status heartbeat)
+                // for as long as isWaitingForResponse stays true, which for a
+                // provider that keeps "thinking" after the approved tool call
+                // can be the whole rest of the turn. Its own unguarded re-parse
+                // of recentOutputBuffer/terminalScreen previously kept
+                // re-writing engine.activeModal directly — bypassing setStatus
+                // (so rawStatus never even flipped) and bypassing
+                // applyWaitingApproval's staleness guard entirely, silently
+                // re-corrupting the engine's own state moments after
+                // resolveModal() had correctly cleared it. Reuse the same
+                // engine-owned discriminator here too.
+                if (liveModal && buttonsOk && !this.engine.isStaleResolvedApproval(liveModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
                     effectiveModal = liveModal;
                     if (!this.engine.activeModal) this.engine.activeModal = liveModal;
                 }
@@ -2474,7 +2501,14 @@ export class ProviderCliAdapter implements CliAdapter {
 
     getDebugState(): Record<string, any> {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
-        const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        let startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        // (fix: kimi startup-gate stale-approval bypass) See the matching
+        // comment in getStatus() — this ad-hoc startup-gate parse bypassed
+        // engine.activeModal's staleness protection entirely. Reuse the same
+        // engine-owned discriminator rather than duplicating it here.
+        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
+            startupModal = null;
+        }
         const startupDetectedStatus = this.startupParseGate && !startupModal
             ? this.runDetectStatus(this.recentOutputBuffer || screenText)
             : null;

package/src/cli-adapters/pty-transport.d.ts

@@ -37,7 +37,8 @@ export interface PtyRuntimeTransport {
     getMetadata?(): PtyRuntimeMetadata | null;
     onData(callback: (data: string) => void): void;
     onExit(callback: (info: {
-        exitCode: number;
+        exitCode: number | null;
+        signal?: number | null;
     }) => void): void;
 }
 export interface PtyTransportFactory {

package/src/cli-adapters/pty-transport.ts

@@ -62,7 +62,7 @@ export interface PtyRuntimeTransport {
   updateMeta?(meta: Record<string, unknown>, replace?: boolean): void;
   getMetadata?(): PtyRuntimeMetadata | null;
   onData(callback: (data: string) => void): void;
-  onExit(callback: (info: { exitCode: number }) => void): void;
+  onExit(callback: (info: { exitCode: number | null; signal?: number | null }) => void): void;
 }
 
 export interface PtyTransportFactory {

package/src/cli-adapters/session-host-transport.ts

@@ -42,7 +42,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
 
     private readonly client: SessionHostClient;
     private readonly dataCallbacks = new Set<(data: string) => void>();
-    private readonly exitCallbacks = new Set<(info: { exitCode: number }) => void>();
+    private readonly exitCallbacks = new Set<(info: { exitCode: number | null; signal?: number | null }) => void>();
     private readonly pendingOutput: string[] = [];
     private operationChain = Promise.resolve();
     private unsubscribe: (() => void) | null = null;
@@ -79,7 +79,7 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
         }
     }
 
-    onExit(callback: (info: { exitCode: number }) => void): void {
+    onExit(callback: (info: { exitCode: number | null; signal?: number | null }) => void): void {
         this.exitCallbacks.add(callback);
     }
 
@@ -361,8 +361,13 @@ class SessionHostRuntimeTransport implements PtyRuntimeTransport {
             return;
         }
         if (event.type === 'session_exit') {
+            // Preserve the nullable/unknown exitCode and signal exactly as the
+            // session host reported them — never collapse null to 0, which would
+            // make a signal-terminated process indistinguishable from a clean exit.
+            const exitCode = typeof event.exitCode === 'number' ? event.exitCode : null;
+            const signal = typeof event.signal === 'number' ? event.signal : null;
             for (const callback of this.exitCallbacks) {
-                callback({ exitCode: event.exitCode ?? 0 });
+                callback({ exitCode, signal });
             }
             void this.closeClient(false);
         }

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -115,8 +115,12 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                         try {
                             const { readOperatingNotes } = await import('../../mesh/mesh-ledger.js');
                             // readOperatingNotes filters out tombstoned (forgotten) notes so a
-                            // retracted lesson never rides into the prompt. Newest last; tail 20.
-                            const noteEntries = readOperatingNotes(id, { tail: 20 });
+                            // retracted lesson never rides into the prompt. Newest last.
+                            // Phase 2 (d): the byte-budget/count cap now bounds the injected list
+                            // (selectOperatingNotesForPrompt), so read a larger candidate tail than
+                            // the old fixed 20 and let injection-side ranking + budget do the
+                            // bounding. Keep a sane store-read ceiling to avoid unbounded arrays.
+                            const noteEntries = readOperatingNotes(id, { tail: 100 });
                             const notes = noteEntries
                                 .map((e) => {
                                     const p = (e.payload || {}) as Record<string, unknown>;
@@ -131,6 +135,17 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                                         category,
                                         createdAt: typeof p.createdAt === 'string' ? p.createdAt : e.timestamp,
                                         sourceCoordinator: typeof p.sourceCoordinator === 'string' ? p.sourceCoordinator : undefined,
+                                        // Operating-notes lifecycle: thread pinned/expiresAt so the
+                                        // injection-side selection can honor them. Legacy notes lack
+                                        // these → pinned defaults false, expiry governed by category TTL.
+                                        pinned: p.pinned === true,
+                                        ...(typeof p.expiresAt === 'string' ? { expiresAt: p.expiresAt } : {}),
+                                        // Phase 2 (b)/(c): thread the ledger id + supersedes/subjectKey
+                                        // so version-supersede targeting and same-class folding work.
+                                        // Legacy notes lack them → no supersede, fold by leading [tag].
+                                        noteId: e.id,
+                                        ...(typeof p.supersedes === 'string' ? { supersedes: p.supersedes } : {}),
+                                        ...(typeof p.subjectKey === 'string' ? { subjectKey: p.subjectKey } : {}),
                                     };
                                 })
                                 .filter((n): n is NonNullable<typeof n> => n !== null);

package/src/commands/process-lifecycle.ts

@@ -0,0 +1,248 @@
+import { execFileSync, type ExecFileSyncOptions } from 'child_process';
+import * as path from 'path';
+
+export interface ProcessLifecycleOptions {
+    platform?: NodeJS.Platform;
+    execFileSync?: typeof import('child_process').execFileSync;
+}
+
+export interface OwnedProcessInfo {
+    pid: number;
+    commandLine: string | null;
+}
+
+function defaultExecFileSync(): typeof import('child_process').execFileSync {
+    return execFileSync;
+}
+
+function getWindowsProcessCommandLine(
+    pid: number,
+    exec: typeof import('child_process').execFileSync,
+): string | null {
+    const pidFilter = `ProcessId=${pid}`;
+
+    try {
+        const psOut = exec('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy', 'Bypass',
+            '-Command',
+            `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
+        ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const text = String(psOut).trim();
+        if (text) return text;
+    } catch {
+        // fall through to wmic fallback
+    }
+
+    try {
+        const wmicOut = exec('wmic', [
+            'process', 'where', pidFilter, 'get', 'CommandLine',
+        ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const text = String(wmicOut).trim();
+        if (text) return text;
+    } catch {
+        // noop
+    }
+
+    return null;
+}
+
+export function getProcessCommandLine(
+    pid: number,
+    options: ProcessLifecycleOptions = {},
+): string | null {
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const platform = options.platform ?? process.platform;
+
+    if (platform === 'win32') {
+        return getWindowsProcessCommandLine(pid, exec);
+    }
+
+    try {
+        const text = String(exec('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })).trim();
+        return text || null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Extract the script argument (the token after the node executable) from a
+ * command line. Handles both quoted and unquoted executables/scripts.
+ */
+export function parseNodeScriptPath(commandLine: string | null): string | null {
+    if (!commandLine) return null;
+    let rest = commandLine.trim();
+
+    // Skip the leading executable token.
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('"', 1);
+        if (end === -1) return null;
+        rest = rest.slice(end + 1).trim();
+    } else {
+        const idx = rest.search(/\s/);
+        if (idx === -1) return null;
+        rest = rest.slice(idx + 1).trim();
+    }
+    if (!rest) return null;
+
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('"', 1);
+        return end === -1 ? rest.slice(1) : rest.slice(1, end);
+    }
+    const idx = rest.search(/\s/);
+    return idx === -1 ? rest : rest.slice(0, idx);
+}
+
+function normalizeWindowsPath(value: string): string {
+    return value.toLowerCase().replace(/\//g, '\\').replace(/\\+$/, '');
+}
+
+function isCommandLineUnderPrefix(commandLine: string | null, prefix: string): boolean {
+    if (!commandLine) return false;
+    const needle = normalizeWindowsPath(prefix);
+    // Command-line paths may quote Windows separators as either single or
+    // doubled backslashes; collapse doubles before matching.
+    const haystack = commandLine.split('\\\\').join('\\').toLowerCase();
+    return haystack.includes(needle);
+}
+
+export function killProcess(pid: number, options: ProcessLifecycleOptions = {}): boolean {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const platform = options.platform ?? process.platform;
+
+    try {
+        if (platform === 'win32') {
+            exec('taskkill', ['/PID', String(pid), '/T', '/F'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+        } else {
+            process.kill(pid, 'SIGTERM');
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean> {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        } catch {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * List Node processes whose command line places them under any of the supplied
+ * prefixes. Windows-only — the versioned-prefix lifecycle this supports does not
+ * exist on POSIX, so the helper is a no-op there.
+ */
+export function listOwnedNodeProcesses(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+} & ProcessLifecycleOptions): OwnedProcessInfo[] {
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'win32') return [];
+
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const prefixes = options.prefixes.map((p) => normalizeWindowsPath(p));
+    const exclude = new Set((options.excludePids ?? []).filter((n) => Number.isFinite(n) && n > 0));
+    // Command-line paths use Windows separators; normalize marker separators the
+    // same way so a marker like "dist/cli/index.js" matches "dist\cli\index.js".
+    const markers = (options.markers ?? []).map((m) => m.toLowerCase().replace(/\//g, '\\'));
+
+    let pids: number[] = [];
+    try {
+        const out = String(exec('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy', 'Bypass',
+            '-Command',
+            'Get-Process node -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id | ConvertTo-Json -Compress',
+        ], { encoding: 'utf8', timeout: 8000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true })).trim();
+        if (out) {
+            const parsed = JSON.parse(out);
+            pids = Array.isArray(parsed) ? parsed : [parsed];
+        }
+    } catch {
+        return [];
+    }
+
+    const results: OwnedProcessInfo[] = [];
+    for (const pid of pids) {
+        if (!Number.isFinite(pid) || pid <= 0 || exclude.has(pid)) continue;
+        const commandLine = getProcessCommandLine(pid, { platform, execFileSync: exec });
+        if (!commandLine) continue;
+        const lower = commandLine.toLowerCase();
+        const underPrefix = prefixes.some((prefix) => lower.includes(prefix));
+        if (!underPrefix) continue;
+        if (markers.length > 0 && !markers.some((marker) => lower.includes(marker))) continue;
+        results.push({ pid, commandLine });
+    }
+    return results;
+}
+
+export async function stopOwnedProcesses(options: {
+    processes: readonly OwnedProcessInfo[];
+    waitMs?: number;
+} & ProcessLifecycleOptions): Promise<{ stopped: number; survivors: OwnedProcessInfo[] }> {
+    const waitMs = options.waitMs ?? 15_000;
+    const killed = new Set<number>();
+
+    for (const p of options.processes) {
+        if (killProcess(p.pid, options)) killed.add(p.pid);
+    }
+
+    const survivors: OwnedProcessInfo[] = [];
+    for (const p of options.processes) {
+        if (!killed.has(p.pid)) {
+            survivors.push(p);
+            continue;
+        }
+        const exited = await waitForPidExit(p.pid, waitMs);
+        if (!exited) survivors.push(p);
+    }
+
+    // A process counts as stopped only when it left the process table; a failed
+    // kill or a post-kill timeout both land it in `survivors`.
+    return { stopped: options.processes.length - survivors.length, survivors };
+}
+
+export async function stopOwnedProcessesForPrefixes(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+    waitMs?: number;
+    log?: (message: string) => void;
+} & ProcessLifecycleOptions): Promise<{ stopped: number; survivors: OwnedProcessInfo[] }> {
+    const processes = listOwnedNodeProcesses(options);
+    if (processes.length === 0) return { stopped: 0, survivors: [] };
+
+    options.log?.(`Stopping ${processes.length} owned process(es) under prefixes: ${options.prefixes.join(', ')}`);
+    const result = await stopOwnedProcesses({
+        processes,
+        waitMs: options.waitMs,
+        platform: options.platform,
+        execFileSync: options.execFileSync,
+    });
+
+    if (result.survivors.length > 0) {
+        options.log?.(`Could not stop ${result.survivors.length} owned process(es): ${result.survivors.map((s) => s.pid).join(', ')}`);
+    }
+    return result;
+}