@exaudeus/workrail 3.15.0 → 3.17.0

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -13,6 +13,7 @@ const constants_js_1 = require("../constants.js");
 const validation_requirements_extractor_js_1 = require("./validation-requirements-extractor.js");
 const index_js_2 = require("../schemas/artifacts/index.js");
 const run_context_js_1 = require("../../projections/run-context.js");
+const sorted_event_log_js_1 = require("../sorted-event-log.js");
 const condition_evaluator_js_1 = require("../../../utils/condition-evaluator.js");
 const context_template_resolver_js_1 = require("./context-template-resolver.js");
 const retrieval_contract_js_1 = require("./retrieval-contract.js");
@@ -86,15 +87,7 @@ function buildRecoverySegments(args) {
     ];
 }
 function resolveParentLoopStep(workflow, stepId) {
-    for (const step of workflow.definition.steps) {
-        if ((0, workflow_js_1.isLoopStepDefinition)(step) && Array.isArray(step.body)) {
-            for (const bodyStep of step.body) {
-                if (bodyStep.id === stepId)
-                    return step;
-            }
-        }
-    }
-    return undefined;
+    return workflow.parentLoopByStepId.get(stepId);
 }
 function buildLoopRenderContext(loopStep, iteration, sessionContext) {
     const iterationVar = loopStep.loop.iterationVar || 'currentIteration';
@@ -238,11 +231,13 @@ function renderPendingPrompt(args) {
     const isExitStep = outputContract?.contractRef === index_js_2.LOOP_CONTROL_CONTRACT_REF;
     const loopStep = resolveParentLoopStep(args.workflow, args.stepId);
     const maxIterations = loopStep?.loop.maxIterations;
-    const sessionContext = (0, run_context_js_1.projectRunContextV2)(args.truth.events).match((ok) => (ok.byRunId[String(args.runId)]?.context ?? {}), (e) => {
-        console.warn(`[prompt-renderer] Context projection failed for step '${args.stepId}' — ` +
-            `{{varName}} tokens will render as [unset:...]: ${e.message}`);
-        return {};
-    });
+    const sessionContext = args.precomputedIndex
+        ? (args.precomputedIndex.runContextByRunId.get(String(args.runId)) ?? {})
+        : (0, sorted_event_log_js_1.asSortedEventLog)(args.truth.events).andThen((sorted) => (0, run_context_js_1.projectRunContextV2)(sorted)).match((ok) => (ok.byRunId[String(args.runId)]?.context ?? {}), (e) => {
+            console.warn(`[prompt-renderer] Context projection failed for step '${args.stepId}' — ` +
+                `{{varName}} tokens will render as [unset:...]: ${e.message}`);
+            return {};
+        });
     const loopIterationFrame = args.loopPath.at(-1);
     const loopRenderContext = loopStep && loopIterationFrame
         ? buildLoopRenderContext(loopStep, loopIterationFrame.iteration, sessionContext)
@@ -250,7 +245,7 @@ function renderPendingPrompt(args) {
     const renderContext = { ...sessionContext, ...loopRenderContext };
     const basePrompt = (0, context_template_resolver_js_1.resolveContextTemplates)(step.prompt ?? '', renderContext);
     const baseTitle = (0, context_template_resolver_js_1.resolveContextTemplates)(step.title, renderContext);
-    const cleanResponseFormat = process.env.WORKRAIL_CLEAN_RESPONSE_FORMAT === 'true';
+    const cleanResponseFormat = args.cleanResponseFormat ?? false;
     const loopBanner = buildLoopContextBanner({ loopPath: args.loopPath, isExitStep, maxIterations, cleanFormat: cleanResponseFormat });
     const validationCriteria = step.validationCriteria;
     const requirements = (0, validation_requirements_extractor_js_1.extractValidationRequirements)(validationCriteria);
@@ -279,7 +274,9 @@ function renderPendingPrompt(args) {
         if (cleanResponseFormat) {
             return '';
         }
-        const hasPriorNotes = hasPriorNotesInRun({ truth: args.truth, runId: args.runId });
+        const hasPriorNotes = args.precomputedIndex
+            ? args.precomputedIndex.hasPriorNotesByRunId.has(String(args.runId))
+            : hasPriorNotesInRun({ truth: args.truth, runId: args.runId });
         if (hasPriorNotes && !args.rehydrateOnly) {
             return '\n\n**NOTES REQUIRED (System):** Include `output.notesMarkdown` when advancing.\n\n' +
                 'Scope: this step only — WorkRail concatenates notes automatically.\n' +
@@ -321,8 +318,15 @@ function renderPendingPrompt(args) {
     const fragmentSuffix = promptFragments && promptFragments.length > 0
         ? assembleFragmentedPrompt(promptFragments, renderContext)
         : '';
-    const enhancedPrompt = loopBanner + basePrompt + requirementsSection + contractSection + assessmentSection + notesSection
-        + (fragmentSuffix ? '\n\n' + fragmentSuffix : '');
+    const enhancedPrompt = [
+        loopBanner,
+        basePrompt,
+        requirementsSection,
+        contractSection,
+        assessmentSection,
+        notesSection,
+        fragmentSuffix ? '\n\n' + fragmentSuffix : '',
+    ].join('');
     if (!args.rehydrateOnly) {
         return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: enhancedPrompt, agentRole, requireConfirmation });
     }

package/dist/v2/durable-core/domain/recap-recovery.js

@@ -6,18 +6,21 @@ exports.buildChildSummary = buildChildSummary;
 const neverthrow_1 = require("neverthrow");
 const constants_js_1 = require("../constants.js");
 function collectAncestryRecap(args) {
-    const buildChain = (cur, visited) => {
-        if (!cur || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildChain(parent, newVisited)];
+    const buildChain = (start) => {
+        const result = [];
+        const visited = new Set();
+        let cur = start;
+        while (cur !== null && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
     const startNode = args.includeCurrentNode
         ? String(args.nodeId)
         : args.dag.nodesById[String(args.nodeId)]?.parentNodeId ?? null;
-    const chain = buildChain(startNode, new Set());
+    const chain = buildChain(startNode);
     const recaps = chain.flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)
@@ -35,15 +38,19 @@ function collectAncestryRecap(args) {
     return (0, neverthrow_1.ok)([...recaps].reverse());
 }
 function collectDownstreamRecap(args) {
-    const buildPathBackward = (cur, visited) => {
-        if (!cur || cur === String(args.fromNodeId) || visited.has(cur))
-            return [];
-        const nodeData = args.dag.nodesById[cur];
-        const parent = nodeData?.parentNodeId ?? null;
-        const newVisited = new Set([...visited, cur]);
-        return [cur, ...buildPathBackward(parent, newVisited)];
+    const buildPathBackward = (start) => {
+        const result = [];
+        const visited = new Set();
+        const fromId = String(args.fromNodeId);
+        let cur = start;
+        while (cur !== null && cur !== fromId && !visited.has(cur)) {
+            visited.add(cur);
+            result.push(cur);
+            cur = args.dag.nodesById[cur]?.parentNodeId ?? null;
+        }
+        return result;
     };
-    const pathBackward = buildPathBackward(String(args.toNodeId), new Set());
+    const pathBackward = buildPathBackward(String(args.toNodeId));
     const recaps = [...pathBackward].reverse().flatMap((nodeId) => {
         const nodeOutputs = args.outputs.nodesById[nodeId];
         if (!nodeOutputs)

package/dist/v2/durable-core/domain/retrieval-contract.js

@@ -63,17 +63,21 @@ exports.RESUME_PREVIEW_CONTRACT = {
 };
 const encoder = new TextEncoder();
 const decoder = new TextDecoder('utf-8');
+const TIER_PRIORITY = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const TIER_RETENTION = Object.fromEntries(exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.map((t) => [t.tier, t.retention]));
+const RESUME_PREVIEW_TIER_PRIORITY = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.priority]));
+const RESUME_PREVIEW_TIER_MAX_BYTES = Object.fromEntries(exports.RESUME_PREVIEW_CONTRACT.tiers.map((t) => [t.tier, t.maxBytes]));
 function getTierPriority(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getTierRetention(tier) {
-    return exports.REHYDRATE_RETRIEVAL_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.retention ?? 'tail';
+    return TIER_RETENTION[tier] ?? 'tail';
 }
 function getResumePreviewTierPriority(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.priority ?? Number.MAX_SAFE_INTEGER;
+    return RESUME_PREVIEW_TIER_PRIORITY[tier] ?? Number.MAX_SAFE_INTEGER;
 }
 function getResumePreviewTierMaxBytes(tier) {
-    return exports.RESUME_PREVIEW_CONTRACT.tiers.find((candidate) => candidate.tier === tier)?.maxBytes ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
+    return RESUME_PREVIEW_TIER_MAX_BYTES[tier] ?? exports.RESUME_PREVIEW_CONTRACT.budgetBytes;
 }
 function compareAscii(a, b) {
     return a < b ? -1 : a > b ? 1 : 0;
@@ -283,7 +287,8 @@ function renderBudgetedRehydrateRecovery(args) {
     const initiallyIncludedTiers = tiersInOrder.filter((tier) => (sectionsByTier.get(tier) ?? []).length > 0);
     let includedTiers = initiallyIncludedTiers;
     let recoveryText = renderFromTiers(includedTiers);
-    while (encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES) {
+    let recoveryBytes = encoder.encode(recoveryText).length;
+    while (recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES) {
         const droppableTierIndex = [...includedTiers]
             .reverse()
             .findIndex((tier) => getTierRetention(tier) === 'tail');
@@ -293,9 +298,10 @@ function renderBudgetedRehydrateRecovery(args) {
         const actualIndex = includedTiers.length - 1 - droppableTierIndex;
         includedTiers = includedTiers.filter((_, index) => index !== actualIndex);
         recoveryText = renderFromTiers(includedTiers);
+        recoveryBytes = encoder.encode(recoveryText).length;
     }
     const omittedTierCount = initiallyIncludedTiers.length - includedTiers.length;
-    const needsSuffix = omittedTierCount > 0 || encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
+    const needsSuffix = omittedTierCount > 0 || recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0;
     const finalText = recoveryText.length === 0
         ? trimFinalRecoveryText(args.header, initiallyIncludedTiers.length)
         : !needsSuffix
@@ -305,6 +311,6 @@ function renderBudgetedRehydrateRecovery(args) {
         text: finalText,
         includedTiers,
         omittedTierCount,
-        truncatedWithinTier: encoder.encode(recoveryText).length > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
+        truncatedWithinTier: recoveryBytes > constants_js_1.RECOVERY_BUDGET_BYTES || includedTiers.length === 0,
     };
 }

package/dist/v2/durable-core/schemas/compiled-workflow/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompiledWorkflowSnapshotSchema = exports.CompiledWorkflowSnapshotV1Schema = void 0;
 const zod_1 = require("zod");
 const json_zod_js_1 = require("../../canonical/json-zod.js");
+const workflow_definition_js_1 = require("../../../../types/workflow-definition.js");
 const CompiledWorkflowSnapshotV1PreviewSchema = zod_1.z.object({
     schemaVersion: zod_1.z.literal(1),
     sourceKind: zod_1.z.literal('v1_preview'),
@@ -33,7 +34,7 @@ const CompiledWorkflowSnapshotV1PinnedSchema = zod_1.z.object({
             source: zod_1.z.string().min(1),
             purpose: zod_1.z.string().min(1),
             authoritative: zod_1.z.boolean(),
-            resolveFrom: zod_1.z.enum(['workspace', 'package']),
+            resolveFrom: zod_1.z.enum(workflow_definition_js_1.RESOLVE_FROM_VALUES),
             status: zod_1.z.literal('resolved'),
             resolvedPath: zod_1.z.string().min(1),
         }),
@@ -43,7 +44,7 @@ const CompiledWorkflowSnapshotV1PinnedSchema = zod_1.z.object({
             source: zod_1.z.string().min(1),
             purpose: zod_1.z.string().min(1),
             authoritative: zod_1.z.boolean(),
-            resolveFrom: zod_1.z.enum(['workspace', 'package']),
+            resolveFrom: zod_1.z.enum(workflow_definition_js_1.RESOLVE_FROM_VALUES),
             status: zod_1.z.literal('unresolved'),
         }),
         zod_1.z.object({
@@ -52,7 +53,7 @@ const CompiledWorkflowSnapshotV1PinnedSchema = zod_1.z.object({
             source: zod_1.z.string().min(1),
             purpose: zod_1.z.string().min(1),
             authoritative: zod_1.z.boolean(),
-            resolveFrom: zod_1.z.enum(['workspace', 'package']),
+            resolveFrom: zod_1.z.enum(workflow_definition_js_1.RESOLVE_FROM_VALUES),
             status: zod_1.z.literal('pinned'),
         }),
     ])).optional(),

package/dist/v2/durable-core/session-index.d.ts

@@ -0,0 +1,22 @@
+import type { Brand } from '../../runtime/brand.js';
+import type { SortedEventLog } from './sorted-event-log.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { JsonObject } from './canonical/json-types.js';
+export interface SessionIndexData {
+    readonly sortedEvents: SortedEventLog;
+    readonly runStartedByRunId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'run_started';
+    }>>;
+    readonly nodeCreatedByNodeId: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'node_created';
+    }>>;
+    readonly hasChildEdgeByFromNodeId: ReadonlySet<string>;
+    readonly advanceRecordedByDedupeKey: ReadonlyMap<string, Extract<DomainEventV1, {
+        kind: 'advance_recorded';
+    }>>;
+    readonly nextEventIndex: number;
+    readonly hasPriorNotesByRunId: ReadonlySet<string>;
+    readonly runContextByRunId: ReadonlyMap<string, JsonObject>;
+}
+export type SessionIndex = Brand<SessionIndexData, 'v2.SessionIndex'>;
+export declare function buildSessionIndex(events: SortedEventLog): SessionIndex;

package/dist/v2/durable-core/session-index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSessionIndex = buildSessionIndex;
+const constants_js_1 = require("./constants.js");
+function buildSessionIndex(events) {
+    const runStartedByRunId = new Map();
+    const nodeCreatedByNodeId = new Map();
+    const hasChildEdgeByFromNodeId = new Set();
+    const advanceRecordedByDedupeKey = new Map();
+    const hasPriorNotesByRunId = new Set();
+    const runContextByRunId = new Map();
+    for (const event of events) {
+        switch (event.kind) {
+            case 'run_started':
+                runStartedByRunId.set(event.scope.runId, event);
+                break;
+            case 'node_created':
+                nodeCreatedByNodeId.set(event.scope.nodeId, event);
+                break;
+            case 'edge_created':
+                hasChildEdgeByFromNodeId.add(event.data.fromNodeId);
+                break;
+            case 'advance_recorded':
+                advanceRecordedByDedupeKey.set(event.dedupeKey, event);
+                break;
+            case 'node_output_appended': {
+                const outputEvt = event;
+                if (outputEvt.data.outputChannel === constants_js_1.OUTPUT_CHANNEL.RECAP &&
+                    outputEvt.data.payload.payloadKind === constants_js_1.PAYLOAD_KIND.NOTES) {
+                    hasPriorNotesByRunId.add(event.scope.runId);
+                }
+                break;
+            }
+            case 'context_set': {
+                const ctx = event.data.context;
+                if (ctx && typeof ctx === 'object' && !Array.isArray(ctx)) {
+                    runContextByRunId.set(event.scope.runId, ctx);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const lastEvent = events[events.length - 1];
+    const nextEventIndex = lastEvent !== undefined ? lastEvent.eventIndex + 1 : 0;
+    const data = {
+        sortedEvents: events,
+        runStartedByRunId,
+        nodeCreatedByNodeId,
+        hasChildEdgeByFromNodeId,
+        advanceRecordedByDedupeKey,
+        nextEventIndex,
+        hasPriorNotesByRunId,
+        runContextByRunId,
+    };
+    return data;
+}

package/dist/v2/durable-core/sorted-event-log.d.ts

@@ -0,0 +1,6 @@
+import type { Result } from 'neverthrow';
+import type { Brand } from '../../runtime/brand.js';
+import type { DomainEventV1 } from './schemas/session/index.js';
+import type { ProjectionError } from '../projections/projection-error.js';
+export type SortedEventLog = Brand<readonly DomainEventV1[], 'v2.SortedEventLog'>;
+export declare function asSortedEventLog(events: readonly DomainEventV1[]): Result<SortedEventLog, ProjectionError>;

package/dist/v2/durable-core/sorted-event-log.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asSortedEventLog = asSortedEventLog;
+const neverthrow_1 = require("neverthrow");
+function asSortedEventLog(events) {
+    for (let i = 1; i < events.length; i++) {
+        if (events[i].eventIndex <= events[i - 1].eventIndex) {
+            return (0, neverthrow_1.err)({
+                code: 'PROJECTION_INVARIANT_VIOLATION',
+                message: 'Events must be sorted by eventIndex strictly ascending (no duplicates)',
+            });
+        }
+    }
+    return (0, neverthrow_1.ok)(events);
+}

package/dist/v2/infra/local/fs/index.js

@@ -166,18 +166,18 @@ class NodeFileSystemV2 {
     readdirWithMtime(dirPath) {
         return neverthrow_1.ResultAsync.fromPromise((async () => {
             const entries = await fs.readdir(dirPath);
+            const results = await Promise.allSettled(entries.map((name) => fs.stat(path.join(dirPath, name)).then((s) => ({ name, mtimeMs: s.mtimeMs }))));
             const withMtime = [];
             let skipped = 0;
-            for (const name of entries) {
-                try {
-                    const stats = await fs.stat(path.join(dirPath, name));
-                    withMtime.push({ name, mtimeMs: stats.mtimeMs });
+            for (let i = 0; i < results.length; i++) {
+                const result = results[i];
+                if (result.status === 'fulfilled') {
+                    withMtime.push(result.value);
                 }
-                catch (e) {
-                    const code = nodeErrorCode(e);
+                else {
+                    const code = nodeErrorCode(result.reason);
                     skipped++;
-                    console.error(`[workrail:session-enum] Skipping ${name}: stat failed (${code ?? 'unknown'}: ${e instanceof Error ? e.message : String(e)})`);
-                    continue;
+                    console.error(`[workrail:session-enum] Skipping ${entries[i]}: stat failed (${code ?? 'unknown'}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)})`);
                 }
             }
             if (skipped > 0) {

package/dist/v2/infra/local/pinned-workflow-store/index.d.ts

@@ -9,5 +9,7 @@ export declare class LocalPinnedWorkflowStoreV2 implements PinnedWorkflowStorePo
     private readonly fs;
     constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2);
     get(workflowHash: WorkflowHash): ResultAsync<CompiledWorkflowSnapshot | null, PinnedWorkflowStoreError>;
+    list(): ResultAsync<readonly WorkflowHash[], PinnedWorkflowStoreError>;
+    prune(_olderThanMs: number): ResultAsync<number, PinnedWorkflowStoreError>;
     put(workflowHash: WorkflowHash, compiled: CompiledWorkflowSnapshot): ResultAsync<void, PinnedWorkflowStoreError>;
 }

package/dist/v2/infra/local/pinned-workflow-store/index.js

@@ -1,6 +1,40 @@
 "use strict";
+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.LocalPinnedWorkflowStoreV2 = void 0;
+const nodePath = __importStar(require("node:path"));
 const neverthrow_1 = require("neverthrow");
 const index_js_1 = require("../../../durable-core/schemas/compiled-workflow/index.js");
 const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
@@ -43,6 +77,21 @@ class LocalPinnedWorkflowStoreV2 {
             return (0, neverthrow_1.okAsync)(validated.data);
         });
     }
+    list() {
+        const dir = this.dataDir.pinnedWorkflowsDir();
+        return this.fs.readdir(dir)
+            .orElse((e) => {
+            if (e.code === 'FS_NOT_FOUND')
+                return (0, neverthrow_1.okAsync)([]);
+            return (0, neverthrow_1.errAsync)(mapFsToStoreError(e));
+        })
+            .map((entries) => entries
+            .filter((name) => name.endsWith('.json') && !name.endsWith('.tmp'))
+            .map((name) => nodePath.basename(name, '.json')));
+    }
+    prune(_olderThanMs) {
+        return (0, neverthrow_1.okAsync)(0);
+    }
     put(workflowHash, compiled) {
         const dir = this.dataDir.pinnedWorkflowsDir();
         const filePath = this.dataDir.pinnedWorkflowPath(workflowHash);

package/dist/v2/infra/local/remembered-roots-store/index.d.ts

@@ -1,11 +1,13 @@
 import type { ResultAsync } from 'neverthrow';
 import type { DataDirPortV2 } from '../../../ports/data-dir.port.js';
 import type { FileSystemPortV2 } from '../../../ports/fs.port.js';
+import type { TimeClockPortV2 } from '../../../ports/time-clock.port.js';
 import type { RememberedRootRecordV2, RememberedRootsStoreError, RememberedRootsStorePortV2 } from '../../../ports/remembered-roots-store.port.js';
 export declare class LocalRememberedRootsStoreV2 implements RememberedRootsStorePortV2 {
     private readonly dataDir;
     private readonly fs;
-    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2);
+    private readonly clock;
+    constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, clock: TimeClockPortV2);
     listRoots(): ResultAsync<readonly string[], RememberedRootsStoreError>;
     listRootRecords(): ResultAsync<readonly RememberedRootRecordV2[], RememberedRootsStoreError>;
     rememberRoot(rootPath: string): ResultAsync<void, RememberedRootsStoreError>;

package/dist/v2/infra/local/remembered-roots-store/index.js

@@ -9,6 +9,7 @@ const zod_1 = require("zod");
 const neverthrow_1 = require("neverthrow");
 const jcs_js_1 = require("../../../durable-core/canonical/jcs.js");
 const REMEMBERED_ROOTS_LOCK_RETRY_MS = 250;
+const TTL_30_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
 const RememberedRootRecordSchema = zod_1.z.object({
     path: zod_1.z.string(),
     addedAtMs: zod_1.z.number().int().nonnegative(),
@@ -48,9 +49,10 @@ function normalizeRootRecords(roots) {
     return normalized;
 }
 class LocalRememberedRootsStoreV2 {
-    constructor(dataDir, fs) {
+    constructor(dataDir, fs, clock) {
         this.dataDir = dataDir;
         this.fs = fs;
+        this.clock = clock;
     }
     listRoots() {
         return this.listRootRecords().map((roots) => roots.map((root) => root.path));
@@ -88,7 +90,7 @@ class LocalRememberedRootsStoreV2 {
     }
     rememberRoot(rootPath) {
         const normalizedRoot = path_1.default.resolve(rootPath);
-        const nowMs = Date.now();
+        const nowMs = this.clock.nowMs();
         return this.withLock(() => this.listRootRecords().andThen((roots) => {
             const existing = roots.find((root) => root.path === normalizedRoot);
             const nextRoots = existing
@@ -104,7 +106,8 @@ class LocalRememberedRootsStoreV2 {
                         source: 'explicit_workspace_path',
                     },
                 ];
-            return this.persist(nextRoots);
+            const withEviction = nextRoots.filter((r) => r.lastSeenAtMs >= nowMs - TTL_30_DAYS_MS);
+            return this.persist(withEviction);
         }));
     }
     persist(roots) {

package/dist/v2/infra/local/session-store/index.d.ts

@@ -10,7 +10,7 @@ export declare class LocalSessionEventLogStoreV2 implements SessionEventLogReado
     private readonly fs;
     private readonly sha256;
     constructor(dataDir: DataDirPortV2, fs: FileSystemPortV2, sha256: Sha256PortV2);
-    append(lock: WithHealthySessionLock, plan: AppendPlanV2): ResultAsync<void, SessionEventLogStoreError>;
+    append(lock: WithHealthySessionLock, plan: AppendPlanV2, preloadedTruth?: LoadedSessionTruthV2): ResultAsync<void, SessionEventLogStoreError>;
     load(sessionId: SessionId): ResultAsync<LoadedSessionTruthV2, SessionEventLogStoreError>;
     loadValidatedPrefix(sessionId: SessionId): ResultAsync<LoadedValidatedPrefixV2, SessionEventLogStoreError>;
     private appendImpl;