@selesai/code 0.13.39 → 0.14.0

package/dist/extensions/pi-hermes-memory/src/handlers/session-flush.ts

@@ -6,6 +6,21 @@
  * Default transport: in-process direct completion (same mechanism as
  * background review — see review-memory-ops.ts). Falls back to a `pi -p`
  * subprocess only if direct mode fails or reviewTransport forces subprocess.
+ *
+ * Compact flush spends at most `flushCompactTimeoutMs` across both transports
+ * (one shared window). Direct runs first; the `pi -p` fallback gets only the
+ * remainder, never a second copy of the budget. Shutdown stays a hardcoded
+ * 10s cap and is silent. `pi.exec` resolves (never rejects) on timeout/kill,
+ * so a non-zero child exit notifies the same way an exhaust does.
+ *
+ * Access pattern (remaining × session-signal × notify):
+ * | Event                                         | leftover                         | session signal | notify                          |
+ * | Direct ok                                     | n/a (return)                     | live           | none                            |
+ * | Direct `no_model` / `parse_error` with time   | subprocess leftover, not budget  | live           | none unless child fails/exits   |
+ * | Direct internal timeout at ceiling            | leftover < floor → skip child    | live           | warning, once                   |
+ * | Esc during compact (`event.signal`)           | skip even if leftover ≫ 0        | aborted        | silent                          |
+ * | `reviewTransport: "subprocess"`               | one child, leftover = budget     | as above       | warn on nonzero exit / throw    |
+ * | Shutdown                                      | budget 10000, no session signal  | n/a            | never                           |
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -13,17 +28,86 @@ import { MemoryStore } from "../store/memory-store.js";
 import { DatabaseManager } from "../store/db.js";
 import {
   buildMemoryTargetRoutingGuidance,
+  DEFAULT_FLUSH_COMPACT_TIMEOUT_MS,
+  DEFAULT_FLUSH_SHUTDOWN_TIMEOUT_MS,
   DIRECT_FLUSH_SYSTEM_PROMPT,
   ENTRY_DELIMITER,
   FLUSH_PROMPT,
 } from "../constants.js";
 import type { MemoryConfig } from "../types.js";
+import type { EnsureMemoryReady } from "../memory-initialization.js";
 import { measureLifecycle } from "../lifecycle-timing.js";
 import { collectMessageParts } from "./message-parts.js";
 import { execChildPrompt, resolveChildPiModel } from "./pi-child-process.js";
 import { runDirectMemoryCompletion, usesDirectTransport } from "./review-memory-ops.js";
 import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
 
+/** Do not spawn pi -p when leftover time is below this, floored by the budget itself. */
+const FLUSH_SUBPROCESS_MIN_REMAINING_MS = 5_000;
+
+export type FlushKind = "compact" | "shutdown";
+
+export type FlushHandoff =
+  | { skip: "session_aborted" }
+  | { skip: "budget_exhausted" }
+  | { timeoutMs: number };
+
+type FlushContext = Pick<ExtensionContext, "sessionManager" | "model" | "modelRegistry" | "cwd"> & {
+  ui?: Pick<ExtensionContext["ui"], "notify">;
+};
+
+/** Remaining subprocess budget. null = skip (spent, below spawn floor, or non-positive). */
+export function remainingFlushTimeoutMs(budgetMs: number, elapsedMs: number): number | null {
+  if (budgetMs <= 0) return null;
+  const elapsed = Math.max(0, elapsedMs);
+  const remaining = budgetMs - elapsed;
+  const floor = Math.min(FLUSH_SUBPROCESS_MIN_REMAINING_MS, budgetMs);
+  if (remaining < floor) return null;
+  return remaining;
+}
+
+export function resolveFlushHandoff(
+  sessionAborted: boolean,
+  budgetMs: number,
+  elapsedMs: number,
+): FlushHandoff {
+  if (sessionAborted) return { skip: "session_aborted" };
+  const leftover = remainingFlushTimeoutMs(budgetMs, elapsedMs);
+  if (leftover === null) return { skip: "budget_exhausted" };
+  return { timeoutMs: leftover };
+}
+
+function linkBudget(parent: AbortSignal | undefined, timeoutMs: number): { signal: AbortSignal; dispose: () => void } {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const onParent = () => controller.abort();
+  parent?.addEventListener("abort", onParent, { once: true });
+  if (parent?.aborted) controller.abort();
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onParent);
+    },
+  };
+}
+
+function notifyCompactFailure(
+  ctx: FlushContext,
+  kind: FlushKind,
+  detail: string,
+): void {
+  if (kind !== "compact") return;
+  try {
+    ctx.ui?.notify(
+      `Memory flush before compact did not save (${detail}). Compaction continues. Raise flushCompactTimeoutMs for slow/local models.`,
+      "warning",
+    );
+  } catch {
+    // compact ctx can go stale; never throw into session_before_compact
+  }
+}
+
 function buildDirectFlushUserPrompt(
   store: MemoryStore,
   projectStore: MemoryStore | null,
@@ -61,9 +145,14 @@ export function setupSessionFlush(
   config: MemoryConfig,
   dbManager: DatabaseManager | null = null,
   projectName: ProjectNameRef = null,
-  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
+  deps: {
+    runDirectMemoryCompletion?: typeof runDirectMemoryCompletion;
+    now?: () => number;
+    ensureMemoryReady?: EnsureMemoryReady;
+  } = {},
 ): void {
   let userTurnCount = 0;
+  const now = deps.now ?? Date.now;
   const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
 
   pi.on("message_end", async (event, _ctx) => {
@@ -72,80 +161,130 @@ export function setupSessionFlush(
 
   /** Shared flush logic — builds conversation snapshot and saves memories */
   async function flush(
-    ctx: Pick<ExtensionContext, "sessionManager" | "model" | "modelRegistry" | "cwd">,
-    signal?: AbortSignal,
-    timeoutMs = 30000,
+    ctx: FlushContext,
+    signal: AbortSignal | undefined,
+    timeoutMs: number,
+    kind: FlushKind,
   ): Promise<void> {
-    if (userTurnCount < config.flushMinTurns) return;
-
-    let entries;
     try {
-      entries = ctx.sessionManager.getBranch();
-    } catch {
-      return; // Context already stale
-    }
+      if (userTurnCount < config.flushMinTurns) return;
 
-    const parts = collectMessageParts(entries, config.flushRecentMessages);
-    const activeProjectStore = resolveProjectStore(projectStore);
-    const activeProjectName = resolveProjectName(projectName);
+      let entries;
+      try {
+        entries = ctx.sessionManager.getBranch();
+      } catch {
+        return; // Context already stale
+      }
 
-    if (usesDirectTransport(config)) {
+      const parts = collectMessageParts(entries, config.flushRecentMessages);
       try {
-        const directResult = await runDirect(
-          ctx,
-          store,
-          activeProjectStore,
-          {
-            systemPrompt: [
-              DIRECT_FLUSH_SYSTEM_PROMPT,
-              "",
-              buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
-            ].join("\n"),
-            userPrompt: buildDirectFlushUserPrompt(store, activeProjectStore, parts),
-            config,
-            timeoutMs,
-            signal,
-          },
-          dbManager,
-          activeProjectName,
-        );
-        if (directResult.ok) return;
+        await deps.ensureMemoryReady?.(ctx);
       } catch {
-        // Fall through to subprocess below.
+        return; // Do not flush against an unloaded or partially migrated store.
       }
-    }
+      const activeProjectStore = resolveProjectStore(projectStore);
+      const activeProjectName = resolveProjectName(projectName);
+      if (signal?.aborted) return;
+      if (timeoutMs <= 0) return; // explicit disable or degenerate config: silent
 
-    const flushMessage = [
-      FLUSH_PROMPT,
-      "",
-      buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
-      "",
-      "--- Conversation ---",
-      parts.join("\n\n"),
-    ].join("\n");
+      const started = now();
 
-    try {
-      await execChildPrompt(pi, flushMessage, config, {
-        cwd: ctx.cwd,
-        model: resolveChildPiModel(ctx.model),
-        signal,
-        timeoutMs,
-      });
+      const budget = linkBudget(signal, timeoutMs);
+      try {
+        if (usesDirectTransport(config)) {
+          try {
+            const directResult = await runDirect(
+              ctx,
+              store,
+              activeProjectStore,
+              {
+                systemPrompt: [
+                  DIRECT_FLUSH_SYSTEM_PROMPT,
+                  "",
+                  buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+                ].join("\n"),
+                userPrompt: buildDirectFlushUserPrompt(store, activeProjectStore, parts),
+                config,
+                timeoutMs,
+                signal: budget.signal,
+              },
+              dbManager,
+              activeProjectName,
+            );
+            if (directResult.ok) return;
+          } catch {
+            // Fall through with leftover, not a copied ceiling.
+          }
+        }
+
+        const handoff = resolveFlushHandoff(Boolean(signal?.aborted), timeoutMs, now() - started);
+        if ("skip" in handoff) {
+          if (handoff.skip === "budget_exhausted") {
+            const elapsed = Math.max(0, now() - started);
+            notifyCompactFailure(
+              ctx,
+              kind,
+              elapsed >= timeoutMs
+                ? `timed out after ${timeoutMs}ms`
+                : `only ${Math.max(0, timeoutMs - elapsed)}ms left of the ${timeoutMs}ms budget, too little to spawn the fallback`,
+            );
+          }
+          return;
+        }
+
+        const flushMessage = [
+          FLUSH_PROMPT,
+          "",
+          buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+          "",
+          "--- Conversation ---",
+          parts.join("\n\n"),
+        ].join("\n");
+
+        try {
+          const childResult = await execChildPrompt(pi, flushMessage, config, {
+            cwd: ctx.cwd,
+            model: resolveChildPiModel(ctx.model),
+            signal,
+            timeoutMs: handoff.timeoutMs,
+          });
+          // pi.exec resolves {code, killed} on timeout/kill instead of rejecting.
+          // A signal kill can arrive as code 0 with killed true, so both shapes
+          // are misses worth surfacing; a non-zero code is the more specific
+          // report when the child did exit on its own.
+          if (!signal?.aborted) {
+            if (typeof childResult?.code === "number" && childResult.code !== 0) {
+              notifyCompactFailure(ctx, kind, `child exited with code ${childResult.code}`);
+            } else if (childResult?.killed === true) {
+              notifyCompactFailure(ctx, kind, "child was killed before it saved");
+            }
+          }
+        } catch (err) {
+          if (!signal?.aborted) {
+            const detail = err instanceof Error ? err.message : String(err);
+            notifyCompactFailure(ctx, kind, `child error: ${detail}`);
+          }
+        }
+      } finally {
+        budget.dispose();
+      }
     } catch {
-      // Best-effort flush — never block compaction or shutdown.
+      // Best-effort flush — never throw into compaction or shutdown.
     }
   }
 
   // Flush before compaction (can afford to wait)
   pi.on("session_before_compact", async (event, ctx) => {
     if (!config.flushOnCompact) return;
-    await flush(ctx, event.signal, 30000);
+    await flush(ctx, event.signal, config.flushCompactTimeoutMs ?? DEFAULT_FLUSH_COMPACT_TIMEOUT_MS, "compact");
   });
 
   // Flush before session shutdown. Pi awaits async session_shutdown handlers
   // before invalidating the session, so await the bounded flush here.
   pi.on("session_shutdown", async (event, ctx) => {
     if (!config.flushOnShutdown || event.reason === "reload") return;
-    await measureLifecycle("shutdown.flush", () => flush(ctx, undefined, 10000));
+    await measureLifecycle("shutdown.flush", () =>
+      flush(ctx, undefined, DEFAULT_FLUSH_SHUTDOWN_TIMEOUT_MS, "shutdown"),
+    );
   });
 }

package/dist/extensions/pi-hermes-memory/src/handlers/skills-command.ts

@@ -1284,8 +1284,12 @@ export function registerSkillsCommand(pi: ExtensionAPI, store: SkillStore): void
       const initialRows = buildUnifiedSkillRows(managedSkills, loadedSkills);
       const projectName = store.getProjectName();
 
-      if (!ctx.hasUI || typeof ctx.ui.custom !== "function") {
-        ctx.ui.notify(formatSkillsList(initialRows, projectName), "info");
+      // Selesai exposes mode; older upstream hosts may not. RPC has dialog UI,
+      // but custom TUI components are a no-op there, so do not invoke the modal.
+      const isRpc = (ctx as ExtensionCommandContext & { mode?: string }).mode === "rpc";
+      if (isRpc || !ctx.hasUI || typeof ctx.ui.custom !== "function") {
+        const notice = isRpc ? "Interactive skills management requires the terminal UI; showing a read-only list.\n\n" : "";
+        ctx.ui.notify(notice + formatSkillsList(initialRows, projectName), "info");
         return;
       }
 

package/dist/extensions/pi-hermes-memory/src/handlers/sync-markdown-memories.ts

@@ -28,10 +28,20 @@ export interface BackfillCounters {
   warnings: string[];
 }
 
-export interface MigrationSyncOptions extends ExtensionRootMigrationOptions {
+export interface MigrationSyncOptions extends ExtensionRootMigrationOptions, SyncMarkdownOptions {
   onMigrationSucceeded?: () => void;
 }
 
+export interface SyncMarkdownOptions {
+  force?: boolean;
+  /**
+   * Startup scope: reconcile only these project scopes (plus the global
+   * files), so a pi startup never touches every projects-memory folder.
+   * `undefined`/`null` keeps the full sweep used by /memory-sync-markdown.
+   */
+  onlyProjects?: string[] | null;
+}
+
 function readEntries(filePath: string): string[] {
   if (!fs.existsSync(filePath)) return [];
   const raw = fs.readFileSync(filePath, 'utf-8').trim();
@@ -135,6 +145,7 @@ export async function syncMarkdownMemoriesToSqlite(
   globalDir: string,
   projectsMemoryDir?: string,
   agentRoot = AGENT_ROOT,
+  options?: SyncMarkdownOptions,
 ): Promise<BackfillCounters & { projectCount: number }> {
   const counters: BackfillCounters = {
     filesScanned: 0,
@@ -160,8 +171,8 @@ export async function syncMarkdownMemoriesToSqlite(
       counters.entriesScanned += entries.length;
       try {
         const result = target === 'failure'
-          ? reconcileMarkdownFailureScopes(dbManager, entries)
-          : reconcileMarkdownMemoryScope(dbManager, entries, target, project);
+          ? reconcileMarkdownFailureScopes(dbManager, entries, options)
+          : reconcileMarkdownMemoryScope(dbManager, entries, target, project, options);
         counters.imported += result.inserted;
         counters.skipped += result.existing;
         counters.removed += result.removed;
@@ -184,6 +195,20 @@ export async function syncMarkdownMemoriesToSqlite(
   await reconcileFile(globalUserFile, 'user');
   await reconcileFile(globalFailureFile, 'failure');
 
+  // Startup passes onlyProjects (global files + current project) so boot cost
+  // never scales with the projects-memory folder count. The full sweep below
+  // stays for /memory-sync-markdown, which is the repair path for the scopes
+  // a scoped startup skips (including orphan pruning outside the scope).
+  const scopedProjects = options?.onlyProjects ?? null;
+  if (scopedProjects) {
+    const projectsRoot = path.resolve(agentRoot, projectsMemoryDir ?? 'projects-memory');
+    for (const projectName of new Set(scopedProjects)) {
+      const memoryFile = resolveAuthoritativeMemoryFile(projectsRoot, projectName);
+      await reconcileFile(memoryFile, 'memory', projectName);
+    }
+    return { ...counters, projectCount: new Set(scopedProjects).size };
+  }
+
   const projects = scanProjectDirs(agentRoot, globalDir, projectsMemoryDir);
   const projectFiles = new Map(projects.map((project) => [project.name, project.memoryFile]));
   const mirroredProjects = dbManager.getDb().prepare(`
@@ -221,7 +246,10 @@ export async function migrateThenSyncMarkdownMemories(
     }
     migrationOptions.onMigrationSucceeded?.();
   }
-  return await syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir, agentRoot);
+  return await syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir, agentRoot, {
+    force: migrationOptions.force,
+    onlyProjects: migrationOptions.onlyProjects,
+  });
 }
 
 export function registerSyncMarkdownMemoriesCommand(
@@ -237,7 +265,7 @@ export function registerSyncMarkdownMemoriesCommand(
       ctx.ui.notify('🔄 Reconciling the SQLite search mirror with Markdown memories...', 'info');
 
       try {
-        const counters = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir, agentRoot);
+        const counters = await syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir, agentRoot, { force: true });
 
         let output = `\n✅ Markdown → SQLite sync complete!\n\n`;
         output += `📊 Results:\n`;