@adhdev/daemon-core 1.0.18-rc.2 → 1.0.18-rc.3

package/dist/cli-adapters/cli-state-engine.d.ts

@@ -59,6 +59,17 @@ export interface CliStateEngineCallbacks {
      */
     isInApprovalResumeGrace?(): boolean;
 }
+/**
+ * Minimal shape computeApprovalContentSignature / isStaleResolvedApproval
+ * actually need — deliberately narrower than the full CliBufferSnapshot so
+ * callers outside the settled-eval loop (e.g. the adapter's startup-gate
+ * modal parse in getStatus/getDebugState) can supply just these two fields
+ * without having to fabricate an entire snapshot.
+ */
+interface ApprovalSignatureSnapshot {
+    screenText?: string;
+    accumulatedBuffer?: string;
+}
 export declare class CliStateEngine {
     private readonly provider;
     private readonly runner;
@@ -76,6 +87,22 @@ export declare class CliStateEngine {
     } | null;
     lastApprovalResolvedAt: number;
     lastResolvedModalMessage: string;
+    /**
+     * Normalized approval-context signature captured at resolve time (see
+     * `computeApprovalContentSignature`) — the screen text with blank-line
+     * padding and any manifest-declared chrome (transcriptPty.chromePatterns,
+     * spinner.patterns) stripped out. Used by applyWaitingApproval's
+     * isStaleResolvedRepaint check to tell "the same already-answered modal,
+     * re-parsed from a screen that has not meaningfully changed" apart from
+     * "a genuinely new approval" — content-based, not time-based, because
+     * ordinary TUI chrome (status bar, context meter, blank-line repaint)
+     * keeps producing fresh PTY bytes on an otherwise-unchanged screen and
+     * defeats any output-timestamp discriminator within a few hundred ms.
+     * Cleared whenever a turn starts or the session tears down (see
+     * onTurnStarted / resetActiveTurnState / onPtyExit) so a next-turn
+     * approval is never compared against stale prior-turn state.
+     */
+    lastApprovalResolvedContentSignature: string;
     /**
      * Monotonic counter bumped every time the FSM *enters* waiting_approval
      * with a freshly captured modal (see `applyWaitingApproval`). It is the
@@ -243,6 +270,55 @@ export declare class CliStateEngine {
     finishResponse(): void;
     private scheduleIdleFinish;
     private cancelPendingIdleFinish;
+    /**
+     * Derive a stable approval-context signature from the current screen,
+     * with blank-line padding and any manifest-declared chrome stripped out.
+     *
+     * Generic by design — no kimi- or provider-specific hardcoding: it reads
+     * whatever `tui.transcriptPty.chromePatterns` and `tui.spinner.patterns`
+     * the ACTIVE provider's own manifest already declares (present on any
+     * declarative-TUI provider; simply absent/empty for scripted providers,
+     * in which case this degrades to blank-line stripping only — never worse
+     * than comparing the raw screen). Those pattern lists exist precisely to
+     * name "known volatile repaint noise" (status bar, context meter, spinner
+     * ticks, banners) — reusing them here means the SAME declared knowledge
+     * that governs transcript-chrome stripping also governs staleness
+     * detection, instead of re-encoding provider knowledge into daemon-core.
+     *
+     * Deliberately NOT a hash of the whole screen/buffer: an ordinary TUI
+     * repaints its footer/status/context-meter chrome continuously even while
+     * genuinely idle, so a raw whole-screen or whole-buffer fingerprint (or a
+     * mere "did any bytes arrive" timestamp) changes on every repaint tick
+     * regardless of whether anything approval-relevant actually happened.
+     * Stripping the declared chrome first yields a signature that only
+     * changes when the surrounding conversation/tool-output content itself
+     * changes — exactly the discriminator applyWaitingApproval's
+     * isStaleResolvedRepaint check needs.
+     */
+    private computeApprovalContentSignature;
+    /**
+     * True when `modal` is a stale re-parse of an already-resolved approval:
+     * same message text, and the chrome-stripped approval-context signature
+     * of `snap` is unchanged from the signature captured at resolve time.
+     *
+     * Public and reused verbatim by BOTH the settled-eval capture path
+     * (applyWaitingApproval, below) and any OUTSIDE re-parse the adapter
+     * performs independently of the settle loop — e.g. provider-cli-adapter's
+     * getStatus()/getDebugState() startup-gate modal detection, which reads
+     * `recentOutputBuffer` directly while `startupParseGate` is open and can
+     * re-surface the same already-resolved modal before the gate closes.
+     * Centralizing the discriminator here means there is exactly ONE
+     * definition of "stale" for the whole session — no divergent duplicate
+     * heuristic re-implemented per call site.
+     */
+    isStaleResolvedApproval(modal: {
+        message: string;
+        buttons: string[];
+    } | null, snap: ApprovalSignatureSnapshot): boolean;
+    /** Clear all resolve-time approval bookkeeping (message, timestamp, content
+     *  signature) — called at turn/session boundaries so a next-turn or
+     *  next-session approval is never compared against stale prior state. */
+    private clearApprovalResolutionMemory;
     /**
      * Schedule one more settled evaluation while pinned to `waiting_approval`
      * with no actionable modal. The settled FSM normally only re-runs on new
@@ -269,3 +345,4 @@ export declare class CliStateEngine {
     private parsedStatusHasFinalStandardAssistantMessage;
     private recordTrace;
 }
+export {};

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

@@ -39,7 +39,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/dist/commands/process-lifecycle.d.ts

@@ -0,0 +1,43 @@
+export interface ProcessLifecycleOptions {
+    platform?: NodeJS.Platform;
+    execFileSync?: typeof import('child_process').execFileSync;
+}
+export interface OwnedProcessInfo {
+    pid: number;
+    commandLine: string | null;
+}
+export declare function getProcessCommandLine(pid: number, options?: ProcessLifecycleOptions): string | null;
+/**
+ * Extract the script argument (the token after the node executable) from a
+ * command line. Handles both quoted and unquoted executables/scripts.
+ */
+export declare function parseNodeScriptPath(commandLine: string | null): string | null;
+export declare function killProcess(pid: number, options?: ProcessLifecycleOptions): boolean;
+export declare function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean>;
+/**
+ * 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 declare function listOwnedNodeProcesses(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+} & ProcessLifecycleOptions): OwnedProcessInfo[];
+export declare function stopOwnedProcesses(options: {
+    processes: readonly OwnedProcessInfo[];
+    waitMs?: number;
+} & ProcessLifecycleOptions): Promise<{
+    stopped: number;
+    survivors: OwnedProcessInfo[];
+}>;
+export declare function stopOwnedProcessesForPrefixes(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+    waitMs?: number;
+    log?: (message: string) => void;
+} & ProcessLifecycleOptions): Promise<{
+    stopped: number;
+    survivors: OwnedProcessInfo[];
+}>;

package/dist/commands/windows-atomic-upgrade.d.ts

@@ -1,4 +1,5 @@
 import { type ChildProcess } from 'child_process';
+export declare const ADHDEV_OWNED_MARKERS: readonly ["session-host-daemon", "node_modules/adhdev", "node_modules/@adhdev/daemon-standalone"];
 export interface WindowsInstallerLayout {
     homeDir: string;
     installRoot: string;
@@ -13,7 +14,7 @@ export interface WindowsAtomicUpgradeHooks {
     restartOld: (portableNode: string) => void;
     waitForHealth: (pid: number, targetVersion: string) => Promise<boolean>;
     stopProcess: (pid: number) => void;
-    cleanup: (layout: WindowsInstallerLayout, activePrefix: string) => void;
+    cleanup: (layout: WindowsInstallerLayout, activePrefix: string) => void | Promise<void>;
     log: (message: string) => void;
 }
 export interface WindowsAtomicUpgradeOptions {
@@ -22,6 +23,8 @@ export interface WindowsAtomicUpgradeOptions {
     targetVersion: string;
     portableNode: string;
     hooks: WindowsAtomicUpgradeHooks;
+    /** PIDs that must never be terminated during prefix sweeps (helper + parent daemon). */
+    excludePids?: number[];
 }
 export interface WindowsAtomicUpgradeResult {
     stagedPrefix: string;
@@ -45,3 +48,11 @@ export declare function createDefaultWindowsAtomicHooks(options: {
     log: (message: string) => void;
 }): WindowsAtomicUpgradeHooks;
 export declare function boundedCleanupInactivePrefixes(layout: WindowsInstallerLayout, activePrefix: string, log: (message: string) => void): void;
+export declare function cleanupInactivePrefixesWithGuard(options: {
+    layout: WindowsInstallerLayout;
+    activePrefix: string;
+    excludePids?: number[];
+    markers?: readonly string[];
+    waitMs?: number;
+    log?: (message: string) => void;
+}): Promise<void>;