@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-hermes-memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.9.8",
+  "version": "0.9.10",
   "description": "Bundled Selesai fork of pi-hermes-memory: persistent memory, session search, and secret scanning.",
   "type": "module",
   "main": "src/index.ts",
@@ -19,6 +19,7 @@
   "scripts": {
     "check": "node scripts/ensure-dev.mjs check && tsc --noEmit",
     "check:min-sdk": "node scripts/ensure-dev.mjs check && node scripts/check-min-sdk.mjs",
+    "check:production": "node scripts/check-production-install.mjs",
     "test": "node scripts/ensure-dev.mjs test && tests/run-all.sh"
   },
   "keywords": [
@@ -47,19 +48,20 @@
     "url": "https://github.com/chandra447/pi-hermes-memory"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.80.6",
-    "@earendil-works/pi-coding-agent": ">=0.80.6"
+    "@earendil-works/pi-ai": ">=1.0.4",
+    "@earendil-works/pi-coding-agent": ">=1.0.4",
+    "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.85.1",
-    "@earendil-works/pi-coding-agent": "0.85.1",
     "@types/better-sqlite3": "^7.6.13",
     "tsx": "^4.21.0",
     "typebox": "^1.1.33",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "@earendil-works/pi-ai": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.0"
   },
   "dependencies": {
-    "@earendil-works/pi-tui": "0.85.1",
     "better-sqlite3": "^13.0.3",
     "strip-ansi": "7.2.0"
   }

package/dist/extensions/pi-hermes-memory/scripts/benchmark-memory-startup.mjs

@@ -0,0 +1,72 @@
+// Run from a development checkout: node --import tsx scripts/benchmark-memory-startup.mjs [--lazy] [entry.ts]
+// Measures the extension lifecycle, not Pi's TUI. No model calls or user data.
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const lazy = process.argv.includes("--lazy");
+const entry = process.argv.slice(2).find((arg) => arg !== "--lazy")
+  ?? join(dirname(fileURLToPath(import.meta.url)), "../src/index.ts");
+const root = await mkdtemp(join(tmpdir(), "pi-memory-startup-bench-"));
+const globalDir = join(root, "pi-hermes-memory");
+const handlers = new Map();
+const tools = new Map();
+const ctx = {
+  cwd: join(root, "workspace"), hasUI: false,
+  sessionManager: { getBranch: () => [], getSessionFile: () => undefined },
+  ui: { notify() {} },
+};
+const emit = async (event, data = {}) => {
+  for (const handler of handlers.get(event) ?? []) await handler(data, ctx);
+};
+
+try {
+  process.env.PI_CODING_AGENT_DIR = root;
+  await mkdir(globalDir);
+  await mkdir(ctx.cwd);
+  await writeFile(join(root, "hermes-memory-config.json"), JSON.stringify({
+    lazyInitialization: lazy, memoryMode: "policy-only",
+    reviewEnabled: false, correctionDetection: false,
+    flushOnShutdown: false, flushOnCompact: false,
+  }));
+  await writeFile(join(globalDir, "MEMORY.md"), "durable global preference");
+  for (let i = 0; i < 20; i++) {
+    const dir = join(root, "projects-memory", `project-${i}`);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, "MEMORY.md"), `durable project ${i} convention`);
+  }
+
+  const started = performance.now();
+  const { default: register } = await import(pathToFileURL(resolve(entry)).href);
+  const imported = performance.now();
+  register({
+    on(event, handler) {
+      if (!handlers.has(event)) handlers.set(event, []);
+      handlers.get(event).push(handler);
+    },
+    registerTool(tool) { tools.set(tool.name, tool); },
+    registerCommand() {},
+  });
+  const registered = performance.now();
+  await emit("session_start");
+  await emit("resources_discover", { cwd: ctx.cwd, reason: "startup" });
+  const ready = performance.now();
+  const databaseAtStartup = existsSync(join(globalDir, "sessions.db"));
+  const search = await tools.get("memory_search").execute("bench", { query: "durable" }, undefined, undefined, ctx);
+  const searched = performance.now();
+  if (!search.details.success || search.details.count === 0) throw new Error("First-use search failed");
+  console.log(JSON.stringify({
+    lazy, entry: resolve(entry),
+    importMs: Math.round(imported - started),
+    registrationMs: Math.round(registered - imported),
+    sessionStartMs: Math.round(ready - registered),
+    totalStartupMs: Math.round(ready - started),
+    firstSearchMs: Math.round(searched - ready),
+    databaseAtStartup,
+  }));
+} finally {
+  await emit("session_shutdown", { reason: "quit" });
+  await rm(root, { recursive: true, force: true });
+}

package/dist/extensions/pi-hermes-memory/scripts/check-production-install.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+// Exercise Pi's real jiti loader and completion SDK without package-local peers.
+// npm access installs production dependencies; model traffic is loopback-only.
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const repo = dirname(dirname(fileURLToPath(import.meta.url)));
+const root = await mkdtemp(join(tmpdir(), "pi-hermes-production-"));
+const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
+let requests = 0;
+const server = createServer((req, res) => {
+  req.resume();
+  req.on("end", () => {
+    if (req.url !== "/v1/chat/completions") {
+      res.writeHead(404).end();
+      return;
+    }
+    requests++;
+    res.writeHead(200, { "content-type": "text/event-stream" });
+    const chunk = (delta, finish_reason) => ({
+      id: "smoke", object: "chat.completion.chunk", created: 0, model: "smoke",
+      choices: [{ index: 0, delta, finish_reason }],
+    });
+    res.end([
+      `data: ${JSON.stringify(chunk({ role: "assistant", content: '{"operations":[]}' }, null))}`,
+      `data: ${JSON.stringify(chunk({}, "stop"))}`,
+      "data: [DONE]", "",
+    ].join("\n\n"));
+  });
+});
+
+function npm(args, cwd) {
+  return execFileSync(process.platform === "win32" ? "npm.cmd" : "npm", args, {
+    cwd, encoding: "utf8", timeout: 180_000, stdio: ["ignore", "pipe", "inherit"],
+  });
+}
+
+try {
+  process.env.PI_CODING_AGENT_DIR = join(root, "agent");
+  await mkdir(process.env.PI_CODING_AGENT_DIR);
+  const [packed] = JSON.parse(npm(["pack", "--ignore-scripts", "--json", "--pack-destination", root], repo));
+  const install = join(root, "install");
+  await mkdir(install);
+  await writeFile(join(install, "package.json"), JSON.stringify({ name: "production-smoke", private: true }));
+  npm(["install", "--omit=dev", "--omit=peer", "--ignore-scripts", "--no-audit", "--no-fund", join(root, packed.filename)], install);
+  const installed = join(install, "node_modules", "pi-hermes-memory");
+  const requireFromPackage = createRequire(join(installed, "package.json"));
+  for (const specifier of ["@earendil-works/pi-ai/compat", "@earendil-works/pi-coding-agent"]) {
+    assert.throws(() => requireFromPackage.resolve(specifier), { code: "MODULE_NOT_FOUND" });
+  }
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const baseUrl = `http://127.0.0.1:${server.address().port}/v1`;
+  const probe = join(installed, "production-probe.ts");
+  await writeFile(probe, `
+import { Type } from "typebox";
+import { runDirectMemoryCompletion } from "./src/handlers/review-memory-ops.js";
+export default function (pi) {
+  pi.registerTool({
+    name: "production_probe", label: "Probe", description: "Synthetic direct completion", parameters: Type.Object({}),
+    async execute() {
+      const model = {
+        provider: "openai", api: "openai-completions", id: "smoke", name: "Smoke", baseUrl: ${JSON.stringify(baseUrl)},
+        reasoning: false, input: ["text"], contextWindow: 8192, maxTokens: 1024,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      };
+      const result = await runDirectMemoryCompletion({
+        model, modelRegistry: { getApiKeyAndHeaders: async () => ({ ok: true, apiKey: "synthetic-smoke-key" }) },
+      }, {}, null, { userPrompt: "Return no memory operations.", systemPrompt: "Synthetic test.", config: {}, timeoutMs: 10000 });
+      return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+    },
+  });
+}
+`);
+
+  // The host SDK is installed in the development checkout, not beside the
+  // production package. Only Pi's loader can provide its aliases to the probe.
+  const hostSdk = import.meta.resolve("@earendil-works/pi-coding-agent");
+  const { loadExtensions } = await import(new URL("./core/extensions/loader.js", hostSdk).href);
+  const loaded = await loadExtensions([join(installed, "src", "index.ts"), probe], install);
+  assert.deepEqual(loaded.errors, []);
+  const tool = loaded.extensions.find((extension) => extension.tools.has("production_probe"))
+    ?.tools.get("production_probe").definition;
+  assert.ok(tool, "production probe registered through Pi");
+  for (const operation of ["review", "flush", "correction", "consolidation"]) {
+    const result = await tool.execute(operation, {});
+    assert.equal(result.details.ok, true, JSON.stringify(result.details));
+    assert.equal(result.details.appliedCount, 0);
+  }
+  assert.equal(requests, 4);
+  console.log("Production install passed: no package-local SDK peers; Pi jiti load and four loopback direct completions succeeded.");
+} finally {
+  server.closeAllConnections();
+  await new Promise((resolve) => server.close(resolve));
+  if (previousAgentDir === undefined) delete process.env.PI_CODING_AGENT_DIR;
+  else process.env.PI_CODING_AGENT_DIR = previousAgentDir;
+  await rm(root, { recursive: true, force: true });
+}

package/dist/extensions/pi-hermes-memory/src/auto-consolidation-warning.ts

@@ -1,6 +1,7 @@
 export function shouldWarnAutoConsolidationFailure(
   warnOnFailure: boolean,
   consolidated: boolean,
+  partial = false,
 ): boolean {
-  return !consolidated && warnOnFailure;
+  return warnOnFailure && (!consolidated || partial);
 }

package/dist/extensions/pi-hermes-memory/src/config.ts

@@ -11,7 +11,11 @@ import {
   DEFAULT_NUDGE_TOOL_CALLS,
   DEFAULT_REVIEW_RECENT_MESSAGES,
   DEFAULT_FLUSH_RECENT_MESSAGES,
+  DEFAULT_CONSOLIDATION_CHUNKING,
+  DEFAULT_CONSOLIDATION_CHUNK_CHARS,
   DEFAULT_CONSOLIDATION_TIMEOUT_MS,
+  DEFAULT_FLUSH_COMPACT_TIMEOUT_MS,
+  CONSOLIDATION_CHUNK_CHARS_MIN,
   DEFAULT_OVERFLOW_GRACE_MS,
   DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
   DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
@@ -41,6 +45,7 @@ function isThinkingLevel(value: unknown): value is ThinkingLevel {
 }
 
 const DEFAULT_CONFIG: MemoryConfig = {
+  lazyInitialization: false,
   memoryMode: "policy-only",
   memoryPolicyStyle: "full",
   memoryCharLimit: DEFAULT_MEMORY_CHAR_LIMIT,
@@ -54,6 +59,7 @@ const DEFAULT_CONFIG: MemoryConfig = {
   flushOnShutdown: true,
   flushMinTurns: DEFAULT_FLUSH_MIN_TURNS,
   flushRecentMessages: DEFAULT_FLUSH_RECENT_MESSAGES,
+  flushCompactTimeoutMs: DEFAULT_FLUSH_COMPACT_TIMEOUT_MS,
   memoryOverflowStrategy: "auto-consolidate",
   overflowGraceMs: DEFAULT_OVERFLOW_GRACE_MS,
   autoConsolidate: true,
@@ -61,7 +67,11 @@ const DEFAULT_CONFIG: MemoryConfig = {
   failureInjectionEnabled: true,
   failureInjectionMaxAgeDays: DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
   failureInjectionMaxEntries: DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
+  consolidationChunking: DEFAULT_CONSOLIDATION_CHUNKING,
+  consolidationChunkChars: DEFAULT_CONSOLIDATION_CHUNK_CHARS,
   consolidationTimeoutMs: DEFAULT_CONSOLIDATION_TIMEOUT_MS,
+  usageHitTrackingEnabled: true,
+  consolidationUsageSignals: true,
   autoConsolidationWarnOnFailure: true,
   nudgeToolCalls: DEFAULT_NUDGE_TOOL_CALLS,
   standingInstructionsEnabled: true,
@@ -120,6 +130,7 @@ export function loadConfig(
       );
       let hasLegacyAutoConsolidate = false;
       let hasMemoryOverflowStrategy = false;
+      if (typeof parsed.lazyInitialization === "boolean") config.lazyInitialization = parsed.lazyInitialization;
       if (parsed.memoryMode === "policy-only" || parsed.memoryMode === "legacy-inject") config.memoryMode = parsed.memoryMode;
       if (
         parsed.memoryPolicyStyle === "full" ||
@@ -138,6 +149,16 @@ export function loadConfig(
       if (typeof parsed.flushOnShutdown === "boolean") config.flushOnShutdown = parsed.flushOnShutdown;
       if (typeof parsed.flushMinTurns === "number") config.flushMinTurns = parsed.flushMinTurns;
       if (isNonNegativeNumber(parsed.flushRecentMessages)) config.flushRecentMessages = parsed.flushRecentMessages;
+      if (typeof parsed.flushCompactTimeoutMs === "number" && Number.isFinite(parsed.flushCompactTimeoutMs)) {
+        config.flushCompactTimeoutMs = parsed.flushCompactTimeoutMs;
+        // Zero and below is the documented disable, not a too-low timeout.
+        if (parsed.flushCompactTimeoutMs > 0 && parsed.flushCompactTimeoutMs < DEFAULT_FLUSH_COMPACT_TIMEOUT_MS) {
+          console.warn(
+            `⚠️ flushCompactTimeoutMs is set to ${parsed.flushCompactTimeoutMs}ms, below the ${DEFAULT_FLUSH_COMPACT_TIMEOUT_MS}ms default.`
+            + " Compact flush is one LLM turn over the conversation; local models are routinely cut off below this.",
+          );
+        }
+      }
       if (typeof parsed.autoConsolidate === "boolean") {
         config.autoConsolidate = parsed.autoConsolidate;
         hasLegacyAutoConsolidate = true;
@@ -161,6 +182,20 @@ export function loadConfig(
           );
         }
       }
+      if (typeof parsed.consolidationChunking === "boolean") {
+        config.consolidationChunking = parsed.consolidationChunking;
+      }
+      if (typeof parsed.usageHitTrackingEnabled === "boolean") {
+        config.usageHitTrackingEnabled = parsed.usageHitTrackingEnabled;
+      }
+      if (typeof parsed.consolidationUsageSignals === "boolean") {
+        config.consolidationUsageSignals = parsed.consolidationUsageSignals;
+      }
+      if (typeof parsed.consolidationChunkChars === "number"
+        && Number.isFinite(parsed.consolidationChunkChars)
+        && parsed.consolidationChunkChars >= CONSOLIDATION_CHUNK_CHARS_MIN) {
+        config.consolidationChunkChars = parsed.consolidationChunkChars;
+      }
       if (typeof parsed.autoConsolidationWarnOnFailure === "boolean") {
         config.autoConsolidationWarnOnFailure = parsed.autoConsolidationWarnOnFailure;
       }

package/dist/extensions/pi-hermes-memory/src/constants.ts

@@ -35,6 +35,39 @@ export const DEFAULT_FLUSH_RECENT_MESSAGES = 0;
  * value below this is set.
  */
 export const DEFAULT_CONSOLIDATION_TIMEOUT_MS = 300000;
+/**
+ * Compact flush is one LLM turn over the conversation snapshot, awaited
+ * before compaction. 30s was cutting local-model prompts mid-prefill
+ * (#225); the value is a ceiling (cloud calls return early). Honor
+ * configured values verbatim; loadConfig warns below this.
+ */
+export const DEFAULT_FLUSH_COMPACT_TIMEOUT_MS = 60_000;
+
+/** Shutdown flush cap. Not configurable. */
+export const DEFAULT_FLUSH_SHUTDOWN_TIMEOUT_MS = 10_000;
+
+/**
+ * Above this many chars of (metadata-stripped) entries in one consolidation
+ * prompt, the subprocess path splits the work into multiple child runs
+ * ("rounds") that share one overall time budget (consolidationTimeoutMs),
+ * reloading from disk between rounds; the loop stops at the target's capacity
+ * goal. Stores at or below the threshold keep today's single-shot child run.
+ * #P1: one whole-store LLM merge routinely exceeds any sane single-call
+ * timeout at cap scale.
+ */
+export const DEFAULT_CONSOLIDATION_CHUNK_CHARS = 4000;
+/** Whether chunked subprocess consolidation is enabled. Default OFF — the original single-shot timeout was never reproduced on a fast model; the feature is available for users who hit it. Set consolidationChunking: true to enable. */
+export const DEFAULT_CONSOLIDATION_CHUNKING = false;
+
+/** Floor for the consolidationChunkChars config value. */
+export const CONSOLIDATION_CHUNK_CHARS_MIN = 500;
+/**
+ * Safety cap on subprocess consolidation rounds per trigger. In practice the
+ * loop exits earlier: capacity goal met, overall budget exhausted (the trigger
+ * never blocks longer than the old single call — consolidationTimeoutMs), a
+ * round that shrinks nothing, or a child failure.
+ */
+export const MAX_CONSOLIDATION_ROUNDS = 6;
 /** Wall-clock grace after overflow before an automatic consolidation may run. */
 export const DEFAULT_OVERFLOW_GRACE_MS = 180000;
 export const DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS = 7;
@@ -55,6 +88,17 @@ export const MEMORY_FILE = "MEMORY.md";
 export const USER_FILE = "USER.md";
 export const STANDING_FILE = "STANDING.md";
 
+// ─── Markdown→SQLite sync state ───
+/**
+ * Key prefix for per-scope reconcile fingerprints in `extension_metadata`.
+ * Bump the version whenever `parseMarkdownMemoryEntry` or the reconcile body
+ * changes what a fingerprinted scope should produce — a stored fingerprint
+ * cannot see a parser change, so the prefix is what invalidates every scope.
+ * The corruption-rebuild strip reads this same constant, so bumping it keeps
+ * both sides in step.
+ */
+export const MDSYNC_METADATA_KEY_PREFIX = "mdsync:v1:";
+
 // ─── Standing instructions (#121) ───
 // A hard budget, deliberately separate from memoryCharLimit/userCharLimit.
 // These are injected in every mode including policy-only, so the cost has to
@@ -103,7 +147,7 @@ If memory conflicts with current evidence, prefer current evidence and mention t
 Procedural skills:
 - Use the skill_manage tool during normal work when a task reveals a reusable how-to workflow, or when the user asks you to remember how to do something later.
 - Always pass scope explicitly on create: scope="global" for portable procedures, scope="project" for workflows tied to this repo's paths, scripts, architecture, deploy steps, or conventions.
-- Prefer structured fields for create/update/patch: when_to_use, procedure_steps, pitfalls, verification_steps. Use patch with the matching structured field for one section, update for a full rewrite, and view before changing an existing skill.
+- Prefer structured fields for create/update/patch: when_to_use, procedure_steps, pitfalls, verification_steps. Use patch with the matching structured field for one section, update for a full rewrite, and view before changing an existing skill. Write the trigger signals a user would actually type into \`description\`: it is the only field Pi indexes for skill discovery, and \`when_to_use\` renders into the body only.
 - Do not create skills for one-off task state, generic summaries, or overly file-specific notes that will create noisy future matches.
 
 Do not use memory_search for generic questions, one-off examples, or explanations where durable memory would not help.
@@ -206,16 +250,17 @@ Only act if there's something genuinely worth saving. If nothing stands out, jus
 // (review/flush/consolidation/correction all ask the model to respond with
 // this same {"operations":[...]} shape instead of calling the memory tool,
 // since direct mode is a single completeSimple() call with no tool loop).
+//
+// GUARD: this schema must not contain a parseable operations example.
+// The direct transports fall back to parsing the thinking channel (#197),
+// so a model restating this schema in its chain of thought would have any
+// valid example parsed into a live operation. Show the shape only in prose
+// or with a deliberately unparseable placeholder, and keep the empty
+// {"operations":[]} (in the prompts below) as the only literal example.
+// No angle-bracket placeholders either — those are still valid JSON that
+// models copy into real operations.
 const DIRECT_MEMORY_OPERATIONS_SCHEMA = `Respond with JSON only (no markdown fences):
-{
-  "operations": [
-    {
-      "action": "add",
-      "target": "memory",
-      "content": "entry text"
-    }
-  ]
-}
+{"operations": [ /* one operation object per entry, using the fields below */ ]}
 
 Operation fields:
 - action: "add" | "replace" | "remove"
@@ -223,7 +268,9 @@ Operation fields:
 - content: required for add/replace
 - old_text: required for replace/remove (substring match)
 - category: for failure target — failure | correction | insight | convention | tool-quirk | preference
-- failure_reason: optional context for failure entries`;
+- failure_reason: optional context for failure entries
+
+Put the JSON in the assistant text, not only in thinking.`;
 
 export const DIRECT_REVIEW_SYSTEM_PROMPT = `You review coding conversations and extract durable memories worth saving across sessions.
 
@@ -379,10 +426,10 @@ WHEN TO UPDATE A SKILL:
 
 SKILL FORMAT:
 - name: short, descriptive (e.g., "debug-typescript-errors")
-- description: one-line summary of when to use it
+- description: what the skill does and the trigger signals a user would type (error strings, symptoms, phrasings). Pi indexes skills by this field alone, so body-only triggers never surface at discovery time.
 - body: structured with sections — ## When to Use, ## Procedure, ## Pitfalls, ## Verification
 - Prefer structured fields over raw markdown when possible:
-  - when_to_use: trigger conditions and boundaries
+  - when_to_use: expanded trigger conditions and boundaries. Renders into the skill body and does not participate in Pi's skill index — discoverable trigger signals belong in description.
   - procedure_steps: ordered concrete steps
   - pitfalls: caveats or failure modes
   - verification_steps: checks that prove success
@@ -392,9 +439,9 @@ ONE-SHOT EXAMPLE:
 {
   "action": "create",
   "name": "debug-typescript-errors",
-  "description": "Debug TypeScript build failures in this repo",
+  "description": "Debug TypeScript build failures in this repo: tsc --noEmit errors, type-check failures in the workspace or CI.",
   "scope": "project",
-  "when_to_use": "Use when TypeScript fails in this repo's workspace or CI.",
+  "when_to_use": "Use when pnpm tsc --noEmit fails locally or in CI, or when asked to fix TypeScript build errors here. Not for runtime-only type issues.",
   "procedure_steps": [
     "Run pnpm tsc --noEmit to get the full error list.",
     "Fix dependency or config errors before leaf-module errors.",