@selesai/code 0.13.39 → 0.14.0

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

@@ -120,6 +120,28 @@ export class MemoryStore {
     if (target === "failure") return this.config.memoryCharLimit * 2; // Failures get more space
     return target === "user" ? this.config.userCharLimit : this.config.memoryCharLimit;
   }
+
+  /**
+   * Public read for consolidation tooling: the char budget this target is held
+   * to (failure tier is 2× the memory limit). Chunked consolidation stops at
+   * this goal instead of its own prompt budget, so a 2×-tier store is not
+   * over-merged down to a single slice size.
+   */
+  capacityGoal(target: "memory" | "user" | "failure"): number {
+    return this.charLimit(target);
+  }
+
+  /**
+   * Public read for consolidation tooling: the store's current size in the
+   * SAME units the cap enforces (encoded entries, metadata included). The
+   * chunked loop measures progress against capacityGoal() in these units —
+   * prompt-side chars are metadata-stripped and would under-report by ~40
+   * chars per entry, letting consolidation declare success while the
+   * triggering add still fails.
+   */
+  capacityUsage(target: "memory" | "user" | "failure"): number {
+    return this.charCount(target);
+  }
   private get capEnforced(): boolean {
     return this.config.memoryMode !== "policy-only";
   }
@@ -327,7 +349,10 @@ export class MemoryStore {
 
     const retried = await this.addWithConsolidation(target, content, signal, retriesLeft - 1, addedMessage, project);
     if (retried.success || !retried.error?.startsWith("Memory at ")) return retried;
-    return { ...retried, error: `${retried.error} Auto-consolidation ran but did not free enough space.` };
+    const partialNote = consolidation.partial
+      ? ` Consolidation is incomplete: ${consolidation.error ?? "retrigger consolidation to continue"}.`
+      : " Auto-consolidation ran but did not free enough space.";
+    return { ...retried, error: `${retried.error}${partialNote}` };
   }
 
   private async fifoEvictAndAdd(
@@ -710,28 +735,39 @@ export class MemoryStore {
     const entries = this.entriesFor(target);
     const current = this.charCount(target);
     const limit = this.charLimit(target);
-    const pct = limit > 0 ? Math.min(100, Math.floor((current / limit) * 100)) : 0;
 
     const resp: MemoryResult = {
       success: true,
       target,
-      usage: `${pct}% — ${current}/${limit} chars`,
+      usage: this.usageLabel(current, limit),
       entry_count: entries.length,
     };
     if (message) resp.message = message;
     return resp;
   }
 
+  /**
+   * Capacity label shared by tool results and rendered block headers.
+   * policy-only mode does not enforce the cap (#218 / #221), so a percentage
+   * would name a ceiling that is intentionally not applied; report the count
+   * alone. Single source so the report and the gates cannot drift apart.
+   */
+  private usageLabel(current: number, limit: number): string {
+    if (!this.capEnforced) return `${current} chars`;
+    const pct = limit > 0 ? Math.min(100, Math.floor((current / limit) * 100)) : 0;
+    return `${pct}% — ${current}/${limit} chars`;
+  }
+
   private renderBlock(target: "memory" | "user", entries: string[]): string {
     if (!entries.length) return "";
     const limit = this.charLimit(target);
     const content = entries.join(ENTRY_DELIMITER);
     const current = content.length;
-    const pct = limit > 0 ? Math.min(100, Math.floor((current / limit) * 100)) : 0;
+    const usage = this.usageLabel(current, limit);
 
     const header = target === "user"
-      ? `USER PROFILE (who the user is) [${pct}% — ${current}/${limit} chars]`
-      : `MEMORY (your personal notes) [${pct}% — ${current}/${limit} chars]`;
+      ? `USER PROFILE (who the user is) [${usage}]`
+      : `MEMORY (your personal notes) [${usage}]`;
 
     const separator = "═".repeat(46);
     return `${separator}\n${header}\n${separator}\n${content}`;
@@ -761,9 +797,9 @@ export class MemoryStore {
     const limit = this.config.memoryCharLimit;
     const content = entries.join(ENTRY_DELIMITER);
     const current = content.length;
-    const pct = limit > 0 ? Math.min(100, Math.floor((current / limit) * 100)) : 0;
+    const usage = this.usageLabel(current, limit);
 
-    const header = `PROJECT MEMORY: ${projectName} [${pct}% — ${current}/${limit} chars]`;
+    const header = `PROJECT MEMORY: ${projectName} [${usage}]`;
     const separator = "═".repeat(46);
     return `${separator}\n${header}\n${separator}\n${content}`;
   }

package/dist/extensions/pi-hermes-memory/src/store/schema.ts

@@ -81,7 +81,9 @@ export const SCHEMA_SQL = `
     tool_state TEXT,
     corrected_to TEXT,
     created DATE NOT NULL,
-    last_referenced DATE NOT NULL
+    last_referenced DATE NOT NULL,
+    hit_count INTEGER NOT NULL DEFAULT 0,
+    last_hit_at DATE
   );
 
   -- FTS5 trigram index for memory substring search

package/dist/extensions/pi-hermes-memory/src/store/sqlite-memory-store.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { DatabaseManager } from './db.js';
 import {
   buildFallbackFts5Query,
@@ -8,6 +9,7 @@ import {
   normalizeNaturalLanguageFts5Query,
 } from './fts-query.js';
 import { normalizeMemoryLookupText } from './memory-lookup.js';
+import { MDSYNC_METADATA_KEY_PREFIX } from '../constants.js';
 import type { MemoryCategory } from '../types.js';
 
 export { isFts5QueryError };
@@ -105,6 +107,37 @@ export interface MarkdownMemoryReconcileResult {
   degradedReason?: string;
 }
 
+export interface MarkdownReconcileOptions {
+  /** Repair path. Ignore stored fingerprint and rewrite the scope. */
+  force?: boolean;
+}
+
+interface MarkdownScopeSyncState {
+  sha256: string;
+  entryCount: number;
+}
+
+function markdownScopeSyncKey(target: string, project: string | null): string {
+  return MDSYNC_METADATA_KEY_PREFIX + JSON.stringify([target, project]);
+}
+
+function parseMarkdownScopeSyncState(value: unknown): MarkdownScopeSyncState | null {
+  if (typeof value !== 'string') return null;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  const rec = parsed as Record<string, unknown>;
+  if (Object.keys(rec).length !== 2) return null;
+  const { sha256, entryCount } = rec;
+  if (typeof sha256 !== 'string' || !/^[0-9a-f]{64}$/i.test(sha256)) return null;
+  if (typeof entryCount !== 'number' || !Number.isInteger(entryCount) || entryCount < 0) return null;
+  return { sha256, entryCount };
+}
+
 export interface ParsedMarkdownMemoryEntry extends SqliteMemorySyncInput {}
 
 function today(): string {
@@ -471,8 +504,12 @@ export function reconcileMarkdownMemoryScope(
   rawEntries: string[],
   target: 'memory' | 'user' | 'failure',
   project: string | null = null,
+  options?: MarkdownReconcileOptions,
 ): MarkdownMemoryReconcileResult {
   const normalizedProject = normalizeNullable(project);
+  const syncKey = markdownScopeSyncKey(target, normalizedProject);
+  const hash = createHash('sha256').update(JSON.stringify(rawEntries)).digest('hex');
+  const force = options?.force === true;
 
   // The full reconcile runs against the CURRENT database handle. It must fetch
   // it via dbManager.getDb() rather than a pre-fetched handle: after corruption
@@ -480,6 +517,32 @@ export function reconcileMarkdownMemoryScope(
   // to run on the new handle.
   const reconcile = (): MarkdownMemoryReconcileResult => {
     const db = dbManager.getDb();
+
+    // Read the fingerprint row on the force path too: an emptying scope needs it
+    // to know whether a stale row is worth deleting, and force is the repair
+    // command, where one indexed read costs nothing.
+    const stateRow = db.prepare(
+      'SELECT value FROM extension_metadata WHERE key = ?',
+    ).get(syncKey) as { value: string } | undefined;
+    const state = parseMarkdownScopeSyncState(stateRow?.value);
+    if (!force && state && state.sha256 === hash) {
+      // Liveness here is a row COUNT over this scope's slice: the fingerprint
+      // binds markdown bytes, not the mirror's content, so a mirror that drifted
+      // without changing its row count keeps skipping. That is the deliberate
+      // trade for the per-startup sweep this gate removes; the forced
+      // /memory-sync-markdown reconcile is the repair for every such drift,
+      // including a search index that lost rows.
+      const countParams: unknown[] = [];
+      const countConditions = buildScopeConditions(countParams, target, normalizedProject);
+      const countRow = db.prepare(
+        `SELECT COUNT(*) as count FROM memories WHERE ${countConditions.join(' AND ')}`,
+      ).get(...countParams) as { count: number } | undefined;
+      const count = Number(countRow?.count ?? 0);
+      if (count === state.entryCount) {
+        return { inserted: 0, existing: state.entryCount, removed: 0 };
+      }
+    }
+
     let inserted = 0;
     let existing = 0;
     let removed = 0;
@@ -520,6 +583,19 @@ export function reconcileMarkdownMemoryScope(
       removed = db.prepare(`DELETE FROM memories WHERE id IN (${placeholders})`).run(...orphanIds).changes;
     }
 
+    const unique = desiredIdentities.size;
+    if (unique === 0) {
+      // Only a scope that previously had a fingerprint needs the delete; an
+      // always-empty scope costs two reads, never a write transaction.
+      if (state) {
+        db.prepare('DELETE FROM extension_metadata WHERE key = ?').run(syncKey);
+      }
+    } else {
+      db.prepare(
+        'INSERT OR REPLACE INTO extension_metadata (key, value) VALUES (?, ?)',
+      ).run(syncKey, JSON.stringify({ sha256: hash, entryCount: unique }));
+    }
+
     return { inserted, existing, removed };
   };
 
@@ -558,6 +634,7 @@ function failureProject(rawEntry: string): string | null {
 export function reconcileMarkdownFailureScopes(
   dbManager: DatabaseManager,
   rawEntries: string[],
+  options?: MarkdownReconcileOptions,
 ): MarkdownMemoryReconcileResult {
   const entriesByProject = new Map<string | null, string[]>();
   for (const rawEntry of rawEntries) {
@@ -585,6 +662,7 @@ export function reconcileMarkdownFailureScopes(
       entriesByProject.get(project) ?? [],
       'failure',
       project,
+      options,
     );
     total.inserted += result.inserted;
     total.existing += result.existing;
@@ -1091,6 +1169,69 @@ export function touchMemory(dbManager: DatabaseManager, id: number): void {
   db.prepare('UPDATE memories SET last_referenced = ? WHERE id = ?').run(today(), id);
 }
 
+/**
+ * Per-entry recall stats gathered from the memory_search read path.
+ */
+export interface MemoryUsageSignal {
+  hits: number;
+  /** ISO date (YYYY-MM-DD) of the most recent recall, or null if never recalled. */
+  lastHit: string | null;
+}
+
+/**
+ * Record one recall per given entry id (batched, single statement). Called by
+ * the memory_search tool after results are returned; failures must never
+ * break search, so callers are expected to swallow errors from this function.
+ */
+export function recordSearchHits(dbManager: DatabaseManager, ids: number[]): void {
+  if (ids.length === 0) return;
+  const db = dbManager.getDb();
+  const placeholders = ids.map(() => '?').join(', ');
+  db.prepare(
+    `UPDATE memories SET hit_count = hit_count + 1, last_hit_at = ? WHERE id IN (${placeholders})`,
+  ).run(today(), ...ids);
+}
+
+/**
+ * Recall stats for every entry in a store scope, keyed by entry CONTENT only
+ * (trimmed — the same stripped form MemoryStore entries and the SQLite mirror
+ * both use). Note this is narrower than syncMemoryEntry's identity
+ * (project+target+category+content): two rows with identical text but
+ * different categories share one signal, and the first matching row wins —
+ * harmless for advisory tie-breaker data. Entries with no recorded recalls
+ * are absent from the map.
+ */
+export function getMemoryUsageSignals(
+  dbManager: DatabaseManager,
+  options: { target: 'memory' | 'user' | 'failure'; project?: string | null }
+): Map<string, MemoryUsageSignal> {
+  const db = dbManager.getDb();
+  const { target, project = null } = options;
+  const params: unknown[] = [target];
+  const conditions = ['target = ?'];
+  if (project === null) {
+    conditions.push('project IS NULL');
+  } else {
+    conditions.push('project = ?');
+    params.push(project);
+  }
+
+  const rows = db.prepare(`
+    SELECT content, hit_count, last_hit_at
+    FROM memories
+    WHERE ${conditions.join(' AND ')}
+  `).all(...params) as Array<{ content: string; hit_count: number | bigint; last_hit_at: string | null }>;
+
+  const signals = new Map<string, MemoryUsageSignal>();
+  for (const row of rows) {
+    const hits = typeof row.hit_count === 'bigint' ? Number(row.hit_count) : (row.hit_count ?? 0);
+    if (hits > 0 && !signals.has(row.content)) {
+      signals.set(row.content, { hits, lastHit: row.last_hit_at ?? null });
+    }
+  }
+  return signals;
+}
+
 /**
  * Get memory statistics.
  */

package/dist/extensions/pi-hermes-memory/src/store/standing-instructions.ts

@@ -51,6 +51,7 @@ export class StandingInstructions {
     private readonly filePath: string,
     private readonly maxEntries: number = STANDING_MAX_ENTRIES,
     private readonly maxChars: number = STANDING_MAX_CHARS,
+    private readonly legacyFilePath?: string,
   ) {}
 
   getFilePath(): string {
@@ -58,13 +59,23 @@ export class StandingInstructions {
   }
 
   async load(): Promise<void> {
-    try {
-      const raw = await fs.readFile(this.filePath, "utf-8");
-      this.instructions = parseInstructions(raw);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-      this.instructions = [];
+    // Read legacy pins without opening SQLite or migrating other memory. The
+    // primary file (even if empty) wins; recheck it if migration moved the legacy
+    // file between reads. Mutations still publish only to the primary path.
+    const candidates = this.legacyFilePath
+      ? [this.filePath, this.legacyFilePath, this.filePath]
+      : [this.filePath];
+    for (const candidate of candidates) {
+      try {
+        const raw = await fs.readFile(candidate, "utf-8");
+        this.instructions = parseInstructions(raw);
+        this.loaded = true;
+        return;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+      }
     }
+    this.instructions = [];
     this.loaded = true;
   }
 

package/dist/extensions/pi-hermes-memory/src/tools/memory-search-tool.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { DatabaseManager } from '../store/db.js';
-import { searchMemories, getMemoryStats } from '../store/sqlite-memory-store.js';
+import { searchMemories, getMemoryStats, recordSearchHits } from '../store/sqlite-memory-store.js';
 import type { MemoryCategory } from '../types.js';
 import { createSharedToolResultRenderer } from './shared-output-view.js';
 import { searchResultView } from './tool-result-views.js';
@@ -23,8 +23,8 @@ function scopeLabel(project: string | null): string {
   return project ? `project:${encodeURIComponent(project)}` : "global";
 }
 
-/** The read-only implementation shared by the model tool and local extensions. */
-export function searchMemory(dbManager: DatabaseManager, args: MemorySearchRequestInput): MemorySearchResponse {
+/** Shared lookup; only model-tool calls opt into recall tracking. Local bridge calls remain read-only. */
+export function searchMemory(dbManager: DatabaseManager, args: MemorySearchRequestInput, options: { usageTrackingEnabled?: boolean } = {}): MemorySearchResponse {
   const query = args.query;
   const project = args.project;
   const target = args.target;
@@ -46,6 +46,16 @@ export function searchMemory(dbManager: DatabaseManager, args: MemorySearchReque
     return { success: true, count: 0, message: `No memories found matching "${query}". Try a different search term or broader query.` };
   }
 
+  // Usage-hit tracking (the promotion-gate data for consolidation): one
+  // batched counter UPDATE per search. Must never break the read path.
+  if (options.usageTrackingEnabled === true) {
+    try {
+      recordSearchHits(dbManager, results.map((entry) => entry.id));
+    } catch (err) {
+      console.warn(`[pi-hermes-memory] usage-hit recording failed (search result unaffected): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
   let output = `Found ${results.length} memories matching "${query}":\n\n`;
 
   for (const entry of results) {
@@ -61,7 +71,11 @@ export function searchMemory(dbManager: DatabaseManager, args: MemorySearchReque
   return { success: true, count: results.length, output: output.trim() };
 }
 
-export function registerMemorySearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+export function registerMemorySearchTool(
+  pi: ExtensionAPI,
+  dbManager: DatabaseManager,
+  options: { usageTrackingEnabled?: boolean } = {},
+): void {
   pi.events?.on(MEMORY_SEARCH_REQUEST_EVENT, (request: unknown) => {
     if (!isMemorySearchRequest(request)) return;
     request.respond(searchMemory(dbManager, request.input));
@@ -82,11 +96,7 @@ target="project" returns only project-attributed memory entries (the ones labele
 
 Returns matching memory entries with their mutation target, scope, and dates. The displayed target is the value required by memory_replace and memory_remove.`,
     promptSnippet: 'Search extended memory store (unlimited capacity)',
-    ...{ discovery: {
-      summary: 'Search the extended durable memory store for relevant entries',
-      aliases: ['memory lookup', 'search memories', 'recall memory'],
-      category: 'memory',
-    } },
+    exposure: "direct",
     promptGuidelines: [
       'Use memory_search when you need context beyond what is in the system prompt.',
       'Use memory_search to find project-specific memories or user preferences.',
@@ -101,7 +111,7 @@ Returns matching memory entries with their mutation target, scope, and dates. Th
       limit: Type.Optional(Type.Number({ description: 'Maximum results to return (default: 10, max: 20).' })),
     }),
     execute: async (_id: string, args: { query: string; project?: string; target?: 'memory' | 'user' | 'failure' | 'project'; category?: MemorySearchRequestInput['category']; limit?: number }) => {
-      const result = searchMemory(dbManager, args);
+      const result = searchMemory(dbManager, args, { usageTrackingEnabled: options.usageTrackingEnabled !== false });
       return { content: [{ type: 'text' as const, text: result.output ?? result.message ?? '' }], details: result };
     },
   });

package/dist/extensions/pi-hermes-memory/src/tools/memory-tool.ts

@@ -413,14 +413,13 @@ This action-specific tool accepts only the parameters listed in its schema.`;
     label: string,
     description: string,
     parameters: TSchema,
-    discovery: { summary: string; aliases: string[]; category: string },
   ) => {
     pi.registerTool({
       name,
       label,
       description,
       promptSnippet: `${label}: persistent memory that survives across sessions`,
-      ...{ discovery },
+      exposure: "direct",
       promptGuidelines: [
         "Use this tool proactively when the user corrects you, shares a preference, or reveals durable environment or project facts.",
         "Do not use memory tools for temporary task state, TODO items, or session progress.",
@@ -456,11 +455,6 @@ Add one durable entry. The target and content fields are required.`,
       category: Type.Optional(category),
       failure_reason: Type.Optional(Type.String({ description: "Why a failure occurred." })),
     }),
-    {
-      summary: "Save durable information to persistent memory",
-      aliases: ["remember this", "save memory", "store memory"],
-      category: "memory",
-    },
   );
   registerActionTool(
     "replace",
@@ -474,11 +468,6 @@ Replace one existing entry. The target, old_text, and content fields are require
       old_text: Type.String({ description: "Substring identifying the entry to replace." }),
       content: Type.String({ description: "Replacement entry content." }),
     }),
-    {
-      summary: "Replace an existing durable memory entry in place",
-      aliases: ["update memory", "edit memory"],
-      category: "memory",
-    },
   );
   registerActionTool(
     "remove",
@@ -491,11 +480,6 @@ Remove one existing entry. The target and old_text fields are required.`,
       target,
       old_text: Type.String({ description: "Substring identifying the entry to remove." }),
     }),
-    {
-      summary: "Remove a durable memory entry",
-      aliases: ["forget memory", "delete memory", "remove memory"],
-      category: "memory",
-    },
   );
   return configureProjectStore;
 }

package/dist/extensions/pi-hermes-memory/src/tools/session-search-tool.ts

@@ -87,11 +87,7 @@ any:
 exclude:
 - delta`,
     promptSnippet: 'Search past session JSONL files for compact source anchors',
-    ...{ discovery: {
-      summary: 'Search past Selesai sessions for compact source anchors',
-      aliases: ['past sessions', 'session history anchors'],
-      category: 'memory',
-    } },
+    exposure: "direct",
     promptGuidelines: [
       'Use session_search with markdown only when the session search anchor mode is configured.',
       'Request source anchors, not summaries or previews.',
@@ -161,11 +157,7 @@ Examples:
 
 Returns bounded conversation snippets with session dates and project context. Large messages are truncated with their original character count.`,
     promptSnippet: 'Search past conversations for relevant context',
-    ...{ discovery: {
-      summary: 'Search past Selesai sessions for relevant conversation context',
-      aliases: ['past sessions', 'conversation history', 'session history'],
-      category: 'memory',
-    } },
+    exposure: "direct",
     promptGuidelines: [
       'Use session_search when the user asks about previous discussions or past work.',
       'Use session_search when you need context from earlier sessions.',

package/dist/extensions/pi-hermes-memory/src/tools/skill-tool.ts

@@ -62,7 +62,7 @@ const SKILL_TOOL_PARAMETERS = Type.Object({
   })),
   skill_id: Type.Optional(SKILL_ID_PARAM),
   description: Type.Optional(Type.String({
-    description: "One-line description of when to use this skill. Required for create; optional for update/edit.",
+    description: "Discovery-only summary of what the skill does and when to use it. Include the trigger signals a user would actually type (error strings, symptoms, phrasings) — Pi indexes skills by this field alone. Required for create; optional for update/edit; max 1024 chars.",
   })),
   scope: Type.Optional(StringEnum(["global", "project"] as const, {
     description: "Required for create. Use 'global' for portable procedures and 'project' for repo-specific workflows.",
@@ -74,7 +74,7 @@ const SKILL_TOOL_PARAMETERS = Type.Object({
     description: "Raw markdown body for create/update/edit, or Markdown section body for patch. Prefer structured fields over free-form content when possible. For patch, JSON arrays are auto-coerced for list sections; JSON objects are rejected.",
   })),
   when_to_use: Type.Optional(Type.String({
-    description: "Structured create/update/edit field, or structured patch body when section is 'When to Use'.",
+    description: "Structured create/update/edit field, or structured patch body when section is 'When to Use'. Renders into the skill body only — it does not participate in Pi's skill index, so discoverable trigger signals belong in 'description'.",
   })),
   procedure_steps: Type.Optional(Type.Array(Type.String(), {
     description: "Structured create/update/edit field, or structured patch body when section is 'Procedure'. Ordered concrete steps.",
@@ -95,16 +95,12 @@ export function registerSkillTool(pi: ExtensionAPI, store: SkillStore): void {
     label: "Skill Manager",
     description: SKILL_TOOL_DESCRIPTION,
     promptSnippet: "Create, inspect, and update reusable procedures and patterns",
-    ...{ discovery: {
-      summary: "Create, inspect, or update reusable procedure skills",
-      aliases: ["manage skills", "save procedure", "create skill"],
-      category: "capability",
-    } },
+    exposure: "direct",
     promptGuidelines: [
       "Use the skill_manage tool after completing complex tasks that required trial and error or multiple tool calls.",
       "Use 'create' to save a new reusable procedure, 'patch' to update a section of an existing skill by skill_id, and 'update' for a full rewrite.",
       "Scope is required on create: choose scope='global' for transferable procedures and scope='project' when the workflow depends on this repo's paths, scripts, conventions, or deploy steps.",
-      "Prefer structured fields for create/update/patch: when_to_use, procedure_steps, pitfalls, and verification_steps. The tool renders valid SKILL.md sections for you.",
+      "Prefer structured fields for create/update/patch: when_to_use, procedure_steps, pitfalls, and verification_steps. The tool renders valid SKILL.md sections for you. Put the trigger signals a user would type in 'description' — Pi indexes skills by that field alone.",
       "For patch, pass section plus the matching structured field (e.g. section='Procedure' with procedure_steps). Avoid free-form content that is a JSON array/object string.",
       "Prefer 'update' for multi-section rewrites when patch content would be large or format-unstable.",
       "Use 'view' before patching or updating when you need to inspect an existing skill.",

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

@@ -18,6 +18,8 @@ export interface SessionSearchConfig {
 }
 
 export interface MemoryConfig {
+  /** Defer policy-only memory initialization until first use. Default: false */
+  lazyInitialization?: boolean;
   /** Prompt memory mode. Default: policy-only */
   memoryMode: "policy-only" | "legacy-inject";
   /** Policy prompt style used when memoryMode is policy-only. Default: full */
@@ -46,6 +48,9 @@ export interface MemoryConfig {
   flushMinTurns: number;
   /** Recent conversation messages included in session flush. 0 = all. Default: 0 */
   flushRecentMessages?: number;
+  /** Ceiling for the compact-path flush (direct + subprocess). Default: 60000 */
+  flushCompactTimeoutMs?: number;
+
   /** Override extension storage directory. Default: ~/.selesai/agent/pi-hermes-memory */
   memoryDir?: string;
   /** Directory for project-scoped memory (relative to ~/.selesai/agent). Default: "projects-memory" */
@@ -88,6 +93,37 @@ export interface MemoryConfig {
   nudgeToolCalls: number;
   /** Maximum time in milliseconds for a consolidation run, auto or manual. Default: 180000 */
   consolidationTimeoutMs: number;
+  /**
+   * Master switch for chunked subprocess consolidation. When false (the
+   * default), the subprocess path keeps the legacy single-shot behavior for
+   * stores of any size. When true, entries joined above
+   * `consolidationChunkChars` split the work into multiple child runs that
+   * share one overall time budget (consolidationTimeoutMs); the loop stops at
+   * the target's capacity goal. Has no effect on the direct (in-process)
+   * transport.
+   */
+  /**
+   * Enables chunked subprocess consolidation (bounded rounds with a shared
+   * time budget). Default: false — the legacy single-shot behavior applies
+   * until explicitly enabled. Provisional pending reproduction of the
+   * original timeout on a faster model.
+   */
+  consolidationChunking?: boolean;
+  consolidationChunkChars?: number;
+  /**
+   * Record memory_search recalls per entry (hit_count / last_hit_at). Default:
+   * true. Recording is invisible — it changes no prompt, ranking, or result;
+   * the counters only feed consolidation usage signals and /memory-insights.
+   */
+  usageHitTrackingEnabled?: boolean;
+  /**
+   * Feed recorded memory_search recalls into consolidation prompts as per-entry
+   * "Usage Signals" (the blog-style promotion gate: well-recalled entries are
+   * load-bearing, never-recalled entries are weaker keep candidates). Inert
+   * until entries have actually been recalled — fresh installs see byte-identical
+   * prompts until real usage accrues. Default: true.
+   */
+  consolidationUsageSignals?: boolean;
   /** Log failed auto-consolidation attempts to the session console. Default: true */
   autoConsolidationWarnOnFailure: boolean;
   /** Inject pinned STANDING.md instructions into every session. Default: true */
@@ -145,6 +181,18 @@ export interface ConsolidationResult {
   consolidated: boolean;
   /** Error message if consolidation failed */
   error?: string;
+  /**
+   * True when at least one round completed but the run ended with a failure
+   * or the store is still over its capacity goal. Progress is real and on
+   * disk; retriggering continues from current state. Consumers should
+   * surface `error` alongside the success path when this is set.
+   */
+  partial?: boolean;
+  /**
+   * Number of subprocess consolidation rounds that completed successfully
+   * (chunked path only; absent for single-shot runs).
+   */
+  rounds?: number;
   /**
    * Set when another session already holds the consolidation lock for this
    * target. Nothing is broken — the work is happening elsewhere — so callers