@a5c-ai/agent-runtime 5.0.1-staging.016f0b0e8119

package/dist/session/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Session state management module.
+ * Provides utilities for managing babysitter orchestration session state.
+ */
+export type { SessionState, SessionFile, SessionContext, SessionDecision, SessionRunSummary, SessionContextSnapshot, SessionHistory, SessionInitOptions, SessionAssociateOptions, SessionResumeOptions, SessionStateOptions, SessionUpdateOptions, SessionInitResult, SessionAssociateResult, SessionResumeResult, SessionStateResult, SessionUpdateResult, } from './types';
+export { SessionError, SessionErrorCode } from './types';
+export { DEFAULT_SESSION_STATE, parseYamlFrontmatter, parseSessionState, readSessionFile, sessionFileExists, validateSessionState, getSessionFilePath, } from './parse';
+export { serializeSessionState, createSessionFileContent, writeSessionFile, updateSessionState, getCurrentTimestamp, isoToEpochSeconds, updateIterationTimes, addRunToSession, getSessionRuns, } from './write';
+export { getSessionContextPath, getSessionContext, updateSessionContext, } from './context';
+export { HARNESS_ENV_VARS, resolveAmbientSessionId, } from './discovery';
+export { getSessionHistoryPath, addDecision, addRunSummary, saveContextSnapshot, getSessionHistory, } from './history';
+export type { SessionFinding, SessionFileModification, SessionBreakpointPattern, SessionPersistentState, } from './persistence';
+export { SESSION_PERSISTENT_SCHEMA_VERSION, getSessionPersistentStatePath, getSessionPersistentState, addFinding, setPreference, recordFileModification, recordBreakpointInteraction, buildResumeContext, } from './persistence';
+export type { ContinuityPhase, ContinuityDecision, ContinuityWorkingContext, ContinuityState, } from './continuityState';
+export { CONTINUITY_STATE_SCHEMA_VERSION, getContinuityStatePath, getContinuityState, setCurrentPhase, upsertDecision, updateWorkingContext, buildContinuityResumePrompt, } from './continuityState';
+export type { MemoryCategory, MemoryConfidence, MemoryEntry, LongTermMemoryStore, MemoryExtractionInput, } from './memoryExtraction';
+export { LONG_TERM_MEMORY_SCHEMA_VERSION, extractMemoriesFromSession, readLongTermMemory, persistMemories, queryMemories, pruneMemories, } from './memoryExtraction';
+export type { SessionBudget, SessionCostState, SessionBudgetAlert, BudgetCheckResult, RunCostUpdate, } from './cost';
+export { getSessionCostPath, getSessionCost, updateSessionCost, setSessionBudget, checkBudget, markThresholdsTriggered, } from './cost';
+//# sourceMappingURL=index.d.ts.map

package/dist/session/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/session/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,YAAY,EACZ,WAAW,EACX,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGzD,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,qBAAqB,EACrB,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AAGnB,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,iCAAiC,EACjC,6BAA6B,EAC7B,yBAAyB,EACzB,UAAU,EACV,aAAa,EACb,sBAAsB,EACtB,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,eAAe,CAAC;AAGvB,YAAY,EACV,eAAe,EACf,kBAAkB,EAClB,wBAAwB,EACxB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,+BAA+B,EAC/B,sBAAsB,EACtB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC;AAG3B,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,WAAW,EACX,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,+BAA+B,EAC/B,0BAA0B,EAC1B,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,aAAa,GACd,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,GACd,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,uBAAuB,GACxB,MAAM,QAAQ,CAAC"}

package/dist/session/index.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Session state management module.
+ * Provides utilities for managing babysitter orchestration session state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionCostPath = exports.pruneMemories = exports.queryMemories = exports.persistMemories = exports.readLongTermMemory = exports.extractMemoriesFromSession = exports.LONG_TERM_MEMORY_SCHEMA_VERSION = exports.buildContinuityResumePrompt = exports.updateWorkingContext = exports.upsertDecision = exports.setCurrentPhase = exports.getContinuityState = exports.getContinuityStatePath = exports.CONTINUITY_STATE_SCHEMA_VERSION = exports.buildResumeContext = exports.recordBreakpointInteraction = exports.recordFileModification = exports.setPreference = exports.addFinding = exports.getSessionPersistentState = exports.getSessionPersistentStatePath = exports.SESSION_PERSISTENT_SCHEMA_VERSION = exports.getSessionHistory = exports.saveContextSnapshot = exports.addRunSummary = exports.addDecision = exports.getSessionHistoryPath = exports.resolveAmbientSessionId = exports.HARNESS_ENV_VARS = exports.updateSessionContext = exports.getSessionContext = exports.getSessionContextPath = exports.getSessionRuns = exports.addRunToSession = exports.updateIterationTimes = exports.isoToEpochSeconds = exports.getCurrentTimestamp = exports.updateSessionState = exports.writeSessionFile = exports.createSessionFileContent = exports.serializeSessionState = exports.getSessionFilePath = exports.validateSessionState = exports.sessionFileExists = exports.readSessionFile = exports.parseSessionState = exports.parseYamlFrontmatter = exports.DEFAULT_SESSION_STATE = exports.SessionErrorCode = exports.SessionError = void 0;
+exports.markThresholdsTriggered = exports.checkBudget = exports.setSessionBudget = exports.updateSessionCost = exports.getSessionCost = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "SessionError", { enumerable: true, get: function () { return types_1.SessionError; } });
+Object.defineProperty(exports, "SessionErrorCode", { enumerable: true, get: function () { return types_1.SessionErrorCode; } });
+// Parsing utilities
+var parse_1 = require("./parse");
+Object.defineProperty(exports, "DEFAULT_SESSION_STATE", { enumerable: true, get: function () { return parse_1.DEFAULT_SESSION_STATE; } });
+Object.defineProperty(exports, "parseYamlFrontmatter", { enumerable: true, get: function () { return parse_1.parseYamlFrontmatter; } });
+Object.defineProperty(exports, "parseSessionState", { enumerable: true, get: function () { return parse_1.parseSessionState; } });
+Object.defineProperty(exports, "readSessionFile", { enumerable: true, get: function () { return parse_1.readSessionFile; } });
+Object.defineProperty(exports, "sessionFileExists", { enumerable: true, get: function () { return parse_1.sessionFileExists; } });
+Object.defineProperty(exports, "validateSessionState", { enumerable: true, get: function () { return parse_1.validateSessionState; } });
+Object.defineProperty(exports, "getSessionFilePath", { enumerable: true, get: function () { return parse_1.getSessionFilePath; } });
+// Writing utilities
+var write_1 = require("./write");
+Object.defineProperty(exports, "serializeSessionState", { enumerable: true, get: function () { return write_1.serializeSessionState; } });
+Object.defineProperty(exports, "createSessionFileContent", { enumerable: true, get: function () { return write_1.createSessionFileContent; } });
+Object.defineProperty(exports, "writeSessionFile", { enumerable: true, get: function () { return write_1.writeSessionFile; } });
+Object.defineProperty(exports, "updateSessionState", { enumerable: true, get: function () { return write_1.updateSessionState; } });
+Object.defineProperty(exports, "getCurrentTimestamp", { enumerable: true, get: function () { return write_1.getCurrentTimestamp; } });
+Object.defineProperty(exports, "isoToEpochSeconds", { enumerable: true, get: function () { return write_1.isoToEpochSeconds; } });
+Object.defineProperty(exports, "updateIterationTimes", { enumerable: true, get: function () { return write_1.updateIterationTimes; } });
+Object.defineProperty(exports, "addRunToSession", { enumerable: true, get: function () { return write_1.addRunToSession; } });
+Object.defineProperty(exports, "getSessionRuns", { enumerable: true, get: function () { return write_1.getSessionRuns; } });
+// Context persistence (GAP-SESSION-001)
+var context_1 = require("./context");
+Object.defineProperty(exports, "getSessionContextPath", { enumerable: true, get: function () { return context_1.getSessionContextPath; } });
+Object.defineProperty(exports, "getSessionContext", { enumerable: true, get: function () { return context_1.getSessionContext; } });
+Object.defineProperty(exports, "updateSessionContext", { enumerable: true, get: function () { return context_1.updateSessionContext; } });
+// Discovery (autodiscovery from markers + env)
+var discovery_1 = require("./discovery");
+Object.defineProperty(exports, "HARNESS_ENV_VARS", { enumerable: true, get: function () { return discovery_1.HARNESS_ENV_VARS; } });
+Object.defineProperty(exports, "resolveAmbientSessionId", { enumerable: true, get: function () { return discovery_1.resolveAmbientSessionId; } });
+// History persistence (GAP-SESSION-002)
+var history_1 = require("./history");
+Object.defineProperty(exports, "getSessionHistoryPath", { enumerable: true, get: function () { return history_1.getSessionHistoryPath; } });
+Object.defineProperty(exports, "addDecision", { enumerable: true, get: function () { return history_1.addDecision; } });
+Object.defineProperty(exports, "addRunSummary", { enumerable: true, get: function () { return history_1.addRunSummary; } });
+Object.defineProperty(exports, "saveContextSnapshot", { enumerable: true, get: function () { return history_1.saveContextSnapshot; } });
+Object.defineProperty(exports, "getSessionHistory", { enumerable: true, get: function () { return history_1.getSessionHistory; } });
+var persistence_1 = require("./persistence");
+Object.defineProperty(exports, "SESSION_PERSISTENT_SCHEMA_VERSION", { enumerable: true, get: function () { return persistence_1.SESSION_PERSISTENT_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "getSessionPersistentStatePath", { enumerable: true, get: function () { return persistence_1.getSessionPersistentStatePath; } });
+Object.defineProperty(exports, "getSessionPersistentState", { enumerable: true, get: function () { return persistence_1.getSessionPersistentState; } });
+Object.defineProperty(exports, "addFinding", { enumerable: true, get: function () { return persistence_1.addFinding; } });
+Object.defineProperty(exports, "setPreference", { enumerable: true, get: function () { return persistence_1.setPreference; } });
+Object.defineProperty(exports, "recordFileModification", { enumerable: true, get: function () { return persistence_1.recordFileModification; } });
+Object.defineProperty(exports, "recordBreakpointInteraction", { enumerable: true, get: function () { return persistence_1.recordBreakpointInteraction; } });
+Object.defineProperty(exports, "buildResumeContext", { enumerable: true, get: function () { return persistence_1.buildResumeContext; } });
+var continuityState_1 = require("./continuityState");
+Object.defineProperty(exports, "CONTINUITY_STATE_SCHEMA_VERSION", { enumerable: true, get: function () { return continuityState_1.CONTINUITY_STATE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "getContinuityStatePath", { enumerable: true, get: function () { return continuityState_1.getContinuityStatePath; } });
+Object.defineProperty(exports, "getContinuityState", { enumerable: true, get: function () { return continuityState_1.getContinuityState; } });
+Object.defineProperty(exports, "setCurrentPhase", { enumerable: true, get: function () { return continuityState_1.setCurrentPhase; } });
+Object.defineProperty(exports, "upsertDecision", { enumerable: true, get: function () { return continuityState_1.upsertDecision; } });
+Object.defineProperty(exports, "updateWorkingContext", { enumerable: true, get: function () { return continuityState_1.updateWorkingContext; } });
+Object.defineProperty(exports, "buildContinuityResumePrompt", { enumerable: true, get: function () { return continuityState_1.buildContinuityResumePrompt; } });
+var memoryExtraction_1 = require("./memoryExtraction");
+Object.defineProperty(exports, "LONG_TERM_MEMORY_SCHEMA_VERSION", { enumerable: true, get: function () { return memoryExtraction_1.LONG_TERM_MEMORY_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "extractMemoriesFromSession", { enumerable: true, get: function () { return memoryExtraction_1.extractMemoriesFromSession; } });
+Object.defineProperty(exports, "readLongTermMemory", { enumerable: true, get: function () { return memoryExtraction_1.readLongTermMemory; } });
+Object.defineProperty(exports, "persistMemories", { enumerable: true, get: function () { return memoryExtraction_1.persistMemories; } });
+Object.defineProperty(exports, "queryMemories", { enumerable: true, get: function () { return memoryExtraction_1.queryMemories; } });
+Object.defineProperty(exports, "pruneMemories", { enumerable: true, get: function () { return memoryExtraction_1.pruneMemories; } });
+var cost_1 = require("./cost");
+Object.defineProperty(exports, "getSessionCostPath", { enumerable: true, get: function () { return cost_1.getSessionCostPath; } });
+Object.defineProperty(exports, "getSessionCost", { enumerable: true, get: function () { return cost_1.getSessionCost; } });
+Object.defineProperty(exports, "updateSessionCost", { enumerable: true, get: function () { return cost_1.updateSessionCost; } });
+Object.defineProperty(exports, "setSessionBudget", { enumerable: true, get: function () { return cost_1.setSessionBudget; } });
+Object.defineProperty(exports, "checkBudget", { enumerable: true, get: function () { return cost_1.checkBudget; } });
+Object.defineProperty(exports, "markThresholdsTriggered", { enumerable: true, get: function () { return cost_1.markThresholdsTriggered; } });

package/dist/session/memoryExtraction.d.ts

@@ -0,0 +1,65 @@
+/**
+ * GAP-STATE-001: Long-Term Memory Extraction.
+ *
+ * Extract and persist important facts, decisions, and patterns from
+ * session history into a long-term memory store for cross-session recall.
+ */
+export type MemoryCategory = "fact" | "decision" | "pattern" | "preference" | "architecture" | "other";
+export type MemoryConfidence = "high" | "medium" | "low";
+export interface MemoryEntry {
+    id: string;
+    content: string;
+    category: MemoryCategory;
+    confidence: MemoryConfidence;
+    sourceRunId?: string;
+    sourceSessionId?: string;
+    tags: string[];
+    extractedAt: string;
+    lastAccessedAt?: string;
+}
+export interface LongTermMemoryStore {
+    schemaVersion: string;
+    entries: MemoryEntry[];
+    updatedAt: string;
+}
+export interface MemoryExtractionInput {
+    decisions: Array<{
+        summary: string;
+        rationale?: string;
+        timestamp: string;
+        runId?: string;
+    }>;
+    findings: Array<{
+        content: string;
+        category: string;
+        timestamp: string;
+        runId?: string;
+    }>;
+}
+export declare const LONG_TERM_MEMORY_SCHEMA_VERSION = "2026.01.long-term-memory-v1";
+/**
+ * Extract memory entries from session data. Pure function, no I/O.
+ * Deduplicates by content string.
+ */
+export declare function extractMemoriesFromSession(input: MemoryExtractionInput): MemoryEntry[];
+/**
+ * Read the long-term memory store. Returns empty store on ENOENT or corrupt JSON.
+ */
+export declare function readLongTermMemory(globalStateDir: string): Promise<LongTermMemoryStore>;
+/**
+ * Merge new entries into existing store. Deduplicates by id. Trims to maxEntries.
+ */
+export declare function persistMemories(globalStateDir: string, newEntries: MemoryEntry[], maxEntries?: number): Promise<void>;
+/**
+ * Query memories with optional filters.
+ */
+export declare function queryMemories(globalStateDir: string, options?: {
+    category?: string;
+    tags?: string[];
+    limit?: number;
+}): Promise<MemoryEntry[]>;
+/**
+ * Prune memories beyond keepCount. Returns number pruned.
+ */
+export declare function pruneMemories(globalStateDir: string, keepCount?: number): Promise<number>;
+//# sourceMappingURL=memoryExtraction.d.ts.map

package/dist/session/memoryExtraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoryExtraction.d.ts","sourceRoot":"","sources":["../../src/session/memoryExtraction.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,GAAG,OAAO,CAAC;AACvG,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEzD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,CAAC;IACzB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7F,QAAQ,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3F;AAMD,eAAO,MAAM,+BAA+B,gCAAgC,CAAC;AA4B7E;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,qBAAqB,GAAG,WAAW,EAAE,CAoCtF;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAkB7F;AAWD;;GAEG;AACH,wBAAsB,eAAe,CACnC,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,WAAW,EAAE,EACzB,UAAU,GAAE,MAA4B,GACvC,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,OAAO,CAAC,WAAW,EAAE,CAAC,CAuBxB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,cAAc,EAAE,MAAM,EACtB,SAAS,GAAE,MAA4B,GACtC,OAAO,CAAC,MAAM,CAAC,CAYjB"}

package/dist/session/memoryExtraction.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * GAP-STATE-001: Long-Term Memory Extraction.
+ *
+ * Extract and persist important facts, decisions, and patterns from
+ * session history into a long-term memory store for cross-session recall.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LONG_TERM_MEMORY_SCHEMA_VERSION = void 0;
+exports.extractMemoriesFromSession = extractMemoriesFromSession;
+exports.readLongTermMemory = readLongTermMemory;
+exports.persistMemories = persistMemories;
+exports.queryMemories = queryMemories;
+exports.pruneMemories = pruneMemories;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+exports.LONG_TERM_MEMORY_SCHEMA_VERSION = "2026.01.long-term-memory-v1";
+const DEFAULT_MAX_ENTRIES = 500;
+const MEMORY_FILENAME = "long-term-memory.json";
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function emptyStore() {
+    return {
+        schemaVersion: exports.LONG_TERM_MEMORY_SCHEMA_VERSION,
+        entries: [],
+        updatedAt: new Date().toISOString(),
+    };
+}
+function generateMemoryId() {
+    return `mem-${crypto.randomUUID()}`;
+}
+function getStorePath(globalStateDir) {
+    return path.join(globalStateDir, MEMORY_FILENAME);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Extract memory entries from session data. Pure function, no I/O.
+ * Deduplicates by content string.
+ */
+function extractMemoriesFromSession(input) {
+    const seen = new Set();
+    const entries = [];
+    const now = new Date().toISOString();
+    for (const decision of input.decisions) {
+        if (seen.has(decision.summary))
+            continue;
+        seen.add(decision.summary);
+        entries.push({
+            id: generateMemoryId(),
+            content: decision.summary,
+            category: "decision",
+            confidence: "high",
+            sourceRunId: decision.runId,
+            tags: [],
+            extractedAt: now,
+        });
+    }
+    for (const finding of input.findings) {
+        if (seen.has(finding.content))
+            continue;
+        seen.add(finding.content);
+        const category = ["fact", "decision", "pattern", "preference", "architecture", "other"]
+            .find((c) => c === finding.category) ?? "other";
+        entries.push({
+            id: generateMemoryId(),
+            content: finding.content,
+            category,
+            confidence: "medium",
+            sourceRunId: finding.runId,
+            tags: [],
+            extractedAt: now,
+        });
+    }
+    return entries;
+}
+/**
+ * Read the long-term memory store. Returns empty store on ENOENT or corrupt JSON.
+ */
+async function readLongTermMemory(globalStateDir) {
+    const filePath = getStorePath(globalStateDir);
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return emptyStore();
+    }
+    try {
+        const data = JSON.parse(raw);
+        return {
+            schemaVersion: typeof data.schemaVersion === "string" ? data.schemaVersion : exports.LONG_TERM_MEMORY_SCHEMA_VERSION,
+            entries: Array.isArray(data.entries) ? data.entries : [],
+            updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : new Date().toISOString(),
+        };
+    }
+    catch {
+        return emptyStore();
+    }
+}
+async function writeStore(globalStateDir, store) {
+    const filePath = getStorePath(globalStateDir);
+    const dir = path.dirname(filePath);
+    const tempPath = `${filePath}.tmp.${process.pid}`;
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(tempPath, JSON.stringify(store, null, 2), "utf8");
+    await fs.rename(tempPath, filePath);
+}
+/**
+ * Merge new entries into existing store. Deduplicates by id. Trims to maxEntries.
+ */
+async function persistMemories(globalStateDir, newEntries, maxEntries = DEFAULT_MAX_ENTRIES) {
+    const store = await readLongTermMemory(globalStateDir);
+    const existingIds = new Set(store.entries.map((e) => e.id));
+    for (const entry of newEntries) {
+        if (!existingIds.has(entry.id)) {
+            store.entries.push(entry);
+            existingIds.add(entry.id);
+        }
+    }
+    // Sort by extractedAt descending (newest first), trim to maxEntries
+    store.entries.sort((a, b) => b.extractedAt.localeCompare(a.extractedAt));
+    if (store.entries.length > maxEntries) {
+        store.entries = store.entries.slice(0, maxEntries);
+    }
+    store.updatedAt = new Date().toISOString();
+    await writeStore(globalStateDir, store);
+}
+/**
+ * Query memories with optional filters.
+ */
+async function queryMemories(globalStateDir, options) {
+    const store = await readLongTermMemory(globalStateDir);
+    let results = store.entries;
+    if (options?.category) {
+        results = results.filter((e) => e.category === options.category);
+    }
+    if (options?.tags && options.tags.length > 0) {
+        const filterTags = options.tags;
+        results = results.filter((e) => filterTags.some((t) => e.tags.includes(t)));
+    }
+    // Sort by extractedAt descending (newest first)
+    results.sort((a, b) => b.extractedAt.localeCompare(a.extractedAt));
+    if (options?.limit) {
+        results = results.slice(0, options.limit);
+    }
+    return results;
+}
+/**
+ * Prune memories beyond keepCount. Returns number pruned.
+ */
+async function pruneMemories(globalStateDir, keepCount = DEFAULT_MAX_ENTRIES) {
+    const store = await readLongTermMemory(globalStateDir);
+    if (store.entries.length <= keepCount)
+        return 0;
+    // Sort by extractedAt descending, keep newest
+    store.entries.sort((a, b) => b.extractedAt.localeCompare(a.extractedAt));
+    const pruned = store.entries.length - keepCount;
+    store.entries = store.entries.slice(0, keepCount);
+    store.updatedAt = new Date().toISOString();
+    await writeStore(globalStateDir, store);
+    return pruned;
+}

package/dist/session/parse.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Session state file parsing utilities.
+ * Parses markdown files with YAML frontmatter for session state.
+ */
+import type { SessionState, SessionFile } from './types';
+/**
+ * Default session state values.
+ */
+export declare const DEFAULT_SESSION_STATE: SessionState;
+/**
+ * Parse YAML frontmatter from a string.
+ * Expects format:
+ * ```
+ * ---
+ * key: value
+ * ---
+ * content
+ * ```
+ */
+export declare function parseYamlFrontmatter(content: string): {
+    frontmatter: Record<string, string>;
+    body: string;
+};
+/**
+ * Parse session state from YAML frontmatter values.
+ */
+export declare function parseSessionState(frontmatter: Record<string, string>): SessionState;
+/**
+ * Read and parse a session state file.
+ */
+export declare function readSessionFile(filePath: string): Promise<SessionFile>;
+/**
+ * Check if a session state file exists.
+ */
+export declare function sessionFileExists(filePath: string): Promise<boolean>;
+/**
+ * Validate session state values.
+ * Throws SessionError if validation fails.
+ */
+export declare function validateSessionState(state: SessionState): void;
+/**
+ * Get the state file path for a session.
+ */
+export declare function getSessionFilePath(stateDir: string, sessionId: string): string;
+//# sourceMappingURL=parse.d.ts.map

package/dist/session/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/session/parse.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGzD;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,YASnC,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAuC3G;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CA0CnF;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CA4B5E;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO1E;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAgB9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9E"}

package/dist/session/parse.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Session state file parsing utilities.
+ * Parses markdown files with YAML frontmatter for session state.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SESSION_STATE = void 0;
+exports.parseYamlFrontmatter = parseYamlFrontmatter;
+exports.parseSessionState = parseSessionState;
+exports.readSessionFile = readSessionFile;
+exports.sessionFileExists = sessionFileExists;
+exports.validateSessionState = validateSessionState;
+exports.getSessionFilePath = getSessionFilePath;
+const node_fs_1 = require("node:fs");
+const types_1 = require("./types");
+/**
+ * Default session state values.
+ */
+exports.DEFAULT_SESSION_STATE = {
+    active: false,
+    iteration: 1,
+    maxIterations: 65_000,
+    runId: '',
+    runIds: [],
+    startedAt: '',
+    lastIterationAt: '',
+    iterationTimes: [],
+};
+/**
+ * Parse YAML frontmatter from a string.
+ * Expects format:
+ * ```
+ * ---
+ * key: value
+ * ---
+ * content
+ * ```
+ */
+function parseYamlFrontmatter(content) {
+    const lines = content.split('\n');
+    const frontmatter = {};
+    let inFrontmatter = false;
+    let frontmatterEnd = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line === '---') {
+            if (!inFrontmatter) {
+                inFrontmatter = true;
+                continue;
+            }
+            else {
+                frontmatterEnd = i;
+                break;
+            }
+        }
+        if (inFrontmatter && line) {
+            const colonIndex = line.indexOf(':');
+            if (colonIndex > 0) {
+                const key = line.slice(0, colonIndex).trim();
+                let value = line.slice(colonIndex + 1).trim();
+                // Remove surrounding quotes if present
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                frontmatter[key] = value;
+            }
+        }
+    }
+    const body = frontmatterEnd >= 0
+        ? lines.slice(frontmatterEnd + 1).join('\n').trim()
+        : content;
+    return { frontmatter, body };
+}
+/**
+ * Parse session state from YAML frontmatter values.
+ */
+function parseSessionState(frontmatter) {
+    const parseNumber = (value, defaultValue) => {
+        if (!value)
+            return defaultValue;
+        const parsed = parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : defaultValue;
+    };
+    const parseBoolean = (value, defaultValue) => {
+        if (!value)
+            return defaultValue;
+        return value.toLowerCase() === 'true';
+    };
+    const parseNumberArray = (value) => {
+        if (!value || value.trim() === '')
+            return [];
+        return value
+            .split(',')
+            .map(s => parseInt(s.trim(), 10))
+            .filter(n => Number.isFinite(n) && n > 0);
+    };
+    const parseStringArray = (value) => {
+        if (!value || value.trim() === '')
+            return [];
+        return value.split(',').map(s => s.trim()).filter(s => s.length > 0);
+    };
+    const metadata = Object.fromEntries(Object.entries(frontmatter)
+        .filter(([key]) => key.startsWith('metadata_'))
+        .map(([key, value]) => [key.slice('metadata_'.length), value]));
+    return {
+        active: parseBoolean(frontmatter.active, exports.DEFAULT_SESSION_STATE.active),
+        iteration: parseNumber(frontmatter.iteration, exports.DEFAULT_SESSION_STATE.iteration),
+        maxIterations: parseNumber(frontmatter.max_iterations, exports.DEFAULT_SESSION_STATE.maxIterations),
+        runId: frontmatter.run_id ?? exports.DEFAULT_SESSION_STATE.runId,
+        runIds: parseStringArray(frontmatter.run_ids),
+        startedAt: frontmatter.started_at ?? exports.DEFAULT_SESSION_STATE.startedAt,
+        lastIterationAt: frontmatter.last_iteration_at ?? exports.DEFAULT_SESSION_STATE.lastIterationAt,
+        iterationTimes: parseNumberArray(frontmatter.iteration_times),
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    };
+}
+/**
+ * Read and parse a session state file.
+ */
+async function readSessionFile(filePath) {
+    let content;
+    try {
+        content = await node_fs_1.promises.readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            throw new types_1.SessionError(`Session state file not found: ${filePath}`, types_1.SessionErrorCode.SESSION_NOT_FOUND, { filePath });
+        }
+        throw new types_1.SessionError(`Failed to read session state file: ${err.message}`, types_1.SessionErrorCode.FS_ERROR, { filePath, originalError: err.message });
+    }
+    const { frontmatter, body } = parseYamlFrontmatter(content);
+    const state = parseSessionState(frontmatter);
+    return {
+        state,
+        prompt: body,
+        filePath,
+    };
+}
+/**
+ * Check if a session state file exists.
+ */
+async function sessionFileExists(filePath) {
+    try {
+        await node_fs_1.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate session state values.
+ * Throws SessionError if validation fails.
+ */
+function validateSessionState(state) {
+    if (typeof state.iteration !== 'number' || !Number.isFinite(state.iteration) || state.iteration < 0) {
+        throw new types_1.SessionError(`Invalid iteration value: ${state.iteration}`, types_1.SessionErrorCode.INVALID_STATE_VALUE, { field: 'iteration', value: state.iteration });
+    }
+    if (typeof state.maxIterations !== 'number' || !Number.isFinite(state.maxIterations) || state.maxIterations < 0) {
+        throw new types_1.SessionError(`Invalid maxIterations value: ${state.maxIterations}`, types_1.SessionErrorCode.INVALID_STATE_VALUE, { field: 'maxIterations', value: state.maxIterations });
+    }
+}
+/**
+ * Get the state file path for a session.
+ */
+function getSessionFilePath(stateDir, sessionId) {
+    return `${stateDir}/${sessionId}.md`;
+}

package/dist/session/persistence.d.ts

@@ -0,0 +1,46 @@
+/**
+ * GAP-STATE-003: Session State Persistence.
+ *
+ * Stores rich persistent state: findings, file modifications, breakpoint patterns,
+ * and user preferences. Follows the same atomic temp-file + rename pattern
+ * as context.ts and history.ts.
+ */
+export interface SessionFinding {
+    content: string;
+    category: "architecture" | "bug" | "pattern" | "dependency" | "other";
+    runId?: string;
+    timestamp: string;
+}
+export interface SessionFileModification {
+    filePath: string;
+    action: "create" | "modify" | "delete";
+    runId?: string;
+    timestamp: string;
+}
+export interface SessionBreakpointPattern {
+    breakpointId: string;
+    approvedCount: number;
+    rejectedCount: number;
+    lastAction: "approved" | "rejected";
+    lastInteractionAt: string;
+}
+export interface SessionPersistentState {
+    schemaVersion: string;
+    findings: SessionFinding[];
+    preferences: Record<string, string>;
+    fileModifications: SessionFileModification[];
+    breakpointPatterns: SessionBreakpointPattern[];
+}
+export declare const SESSION_PERSISTENT_SCHEMA_VERSION = "2026.01.session-persistent-v1";
+export declare function getSessionPersistentStatePath(stateDir: string, sessionId: string): string;
+export declare function getSessionPersistentState(stateDir: string, sessionId: string): Promise<SessionPersistentState>;
+export declare function addFinding(stateDir: string, sessionId: string, finding: Omit<SessionFinding, "timestamp">): Promise<void>;
+export declare function setPreference(stateDir: string, sessionId: string, key: string, value: string): Promise<void>;
+export declare function recordFileModification(stateDir: string, sessionId: string, mod: Omit<SessionFileModification, "timestamp">): Promise<void>;
+export declare function recordBreakpointInteraction(stateDir: string, sessionId: string, breakpointId: string, action: "approved" | "rejected"): Promise<void>;
+/**
+ * Render persistent state into a markdown section for resume prompt injection.
+ * Returns empty string when no meaningful data exists.
+ */
+export declare function buildResumeContext(stateDir: string, sessionId: string): Promise<string>;
+//# sourceMappingURL=persistence.d.ts.map

package/dist/session/persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.d.ts","sourceRoot":"","sources":["../../src/session/persistence.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,cAAc,GAAG,KAAK,GAAG,SAAS,GAAG,YAAY,GAAG,OAAO,CAAC;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,UAAU,GAAG,UAAU,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,iBAAiB,EAAE,uBAAuB,EAAE,CAAC;IAC7C,kBAAkB,EAAE,wBAAwB,EAAE,CAAC;CAChD;AAED,eAAO,MAAM,iCAAiC,kCAAkC,CAAC;AAuDjF,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzF;AAED,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAEpH;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,CAAC,GAC9C,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,UAAU,GAAG,UAAU,GAC9B,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA+B7F"}