@orion-agents/orion-code 0.3.2 → 0.3.7

package/dist/memory/embeddings.js

@@ -100,7 +100,7 @@ class EmbeddingService {
                 input: text,
             }, {
                 headers: {
-                    'Authorization': `Bearer ${apiKey}`,
+                    Authorization: `Bearer ${apiKey}`,
                     'Content-Type': 'application/json',
                 },
                 timeout: 30000,
@@ -121,8 +121,7 @@ let defaultService = null;
 function getEmbeddingService(config) {
     if (!defaultService) {
         // Auto-detect provider from environment
-        const provider = process.env[environment_1.ENV.EMBEDDING_PROVIDER] ||
-            (process.env.OLLAMA_BASE_URL ? 'ollama' : 'openai');
+        const provider = process.env[environment_1.ENV.EMBEDDING_PROVIDER] || (process.env.OLLAMA_BASE_URL ? 'ollama' : 'openai');
         defaultService = new EmbeddingService({
             provider: provider,
             model: process.env[environment_1.ENV.EMBEDDING_MODEL],

package/dist/memory/prompts.js

@@ -24,7 +24,7 @@ function buildMemoryPrompt() {
         'This directory already exists — write to it directly with the Write tool.',
         '',
         'You should build up this memory system over time so that future conversations',
-        'can have a complete picture of who the user is, how they\'d like to collaborate,',
+        "can have a complete picture of who the user is, how they'd like to collaborate,",
         'what behaviors to avoid or repeat, and the context behind the work.',
         '',
         'If the user explicitly asks you to remember something, save it immediately.',

package/dist/memory/relevant-finder.js

@@ -38,20 +38,128 @@ function extractKeywords(text, preserveCase = false) {
         .filter(w => w.length >= 2);
     // 去除常见停用词
     const stopWords = new Set([
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
-        'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are', 'were', 'been',
-        'be', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
-        'could', 'should', 'may', 'might', 'must', 'can', 'this', 'that',
-        'these', 'those', 'it', 'its', 'they', 'them', 'their', 'we', 'our',
-        'you', 'your', 'he', 'him', 'his', 'she', 'her', 'i', 'me', 'my',
-        'not', 'no', 'yes', 'all', 'any', 'some', 'each', 'every', 'both',
-        'few', 'many', 'more', 'most', 'other', 'another', 'such', 'only',
-        'own', 'same', 'so', 'than', 'too', 'very', 'just', 'also', 'now',
-        'then', 'here', 'there', 'when', 'where', 'why', 'how', 'what', 'which',
-        'who', 'whom', 'whose', 'if', 'else', 'then', 'because', 'since',
-        'although', 'though', 'while', 'during', 'before', 'after', 'until',
-        'above', 'below', 'between', 'under', 'over', 'out', 'into', 'onto',
-        'about', 'against', 'through', 'across', 'along', 'around', 'again',
+        'the',
+        'a',
+        'an',
+        'and',
+        'or',
+        'but',
+        'in',
+        'on',
+        'at',
+        'to',
+        'for',
+        'of',
+        'with',
+        'by',
+        'from',
+        'as',
+        'is',
+        'was',
+        'are',
+        'were',
+        'been',
+        'be',
+        'have',
+        'has',
+        'had',
+        'do',
+        'does',
+        'did',
+        'will',
+        'would',
+        'could',
+        'should',
+        'may',
+        'might',
+        'must',
+        'can',
+        'this',
+        'that',
+        'these',
+        'those',
+        'it',
+        'its',
+        'they',
+        'them',
+        'their',
+        'we',
+        'our',
+        'you',
+        'your',
+        'he',
+        'him',
+        'his',
+        'she',
+        'her',
+        'i',
+        'me',
+        'my',
+        'not',
+        'no',
+        'yes',
+        'all',
+        'any',
+        'some',
+        'each',
+        'every',
+        'both',
+        'few',
+        'many',
+        'more',
+        'most',
+        'other',
+        'another',
+        'such',
+        'only',
+        'own',
+        'same',
+        'so',
+        'than',
+        'too',
+        'very',
+        'just',
+        'also',
+        'now',
+        'then',
+        'here',
+        'there',
+        'when',
+        'where',
+        'why',
+        'how',
+        'what',
+        'which',
+        'who',
+        'whom',
+        'whose',
+        'if',
+        'else',
+        'then',
+        'because',
+        'since',
+        'although',
+        'though',
+        'while',
+        'during',
+        'before',
+        'after',
+        'until',
+        'above',
+        'below',
+        'between',
+        'under',
+        'over',
+        'out',
+        'into',
+        'onto',
+        'about',
+        'against',
+        'through',
+        'across',
+        'along',
+        'around',
+        'again',
     ]);
     // 停用词过滤始终大小写不敏感，否则 preserveCase 模式下 "The"/"And" 会漏过。
     return words.filter(w => !stopWords.has(preserveCase ? w.toLowerCase() : w));
@@ -84,7 +192,9 @@ function calculateKeywordMatch(queryKeywords, memoryEntry, caseSensitive = false
         for (const mk of memoryKeywords) {
             const compareMk = caseSensitive ? mk : mk.toLowerCase();
             // 精确匹配或部分匹配（包含关系）
-            if (compareMk === compareQk || compareMk.includes(compareQk) || compareQk.includes(compareMk)) {
+            if (compareMk === compareQk ||
+                compareMk.includes(compareQk) ||
+                compareQk.includes(compareMk)) {
                 matchedKeywords.push(qk);
                 matchCount++;
                 break;

package/dist/memory/vector-store.js

@@ -292,11 +292,13 @@ class VectorStore {
         const scopedIds = projectKeys.map(projectKey => this.memoryId(projectKey, name));
         const idPlaceholders = scopedIds.map(() => '?').join(', ');
         const projectPlaceholders = projectKeys.map(() => '?').join(', ');
-        const rows = this.db.prepare(`
+        const rows = this.db
+            .prepare(`
       SELECT id FROM memories
       WHERE id IN (${idPlaceholders})
          OR (id = ? AND project IN (${projectPlaceholders}))
-    `).all(...scopedIds, name, ...projectKeys);
+    `)
+            .all(...scopedIds, name, ...projectKeys);
         this.deleteMemoryIds(rows.map(row => row.id));
     }
     /** Search by similarity */
@@ -409,12 +411,14 @@ class VectorStore {
     }
     /** Count rows by project key for storage maintenance diagnostics. */
     getProjectStats() {
-        const rows = this.db.prepare(`
+        const rows = this.db
+            .prepare(`
       SELECT COALESCE(project, 'global') as project, COUNT(*) as rows
       FROM memories
       GROUP BY COALESCE(project, 'global')
       ORDER BY rows DESC, project ASC
-    `).all();
+    `)
+            .all();
         return rows.map(row => ({ project: row.project, rows: row.rows }));
     }
     /** Delete all rows for projects that are not in validProjectKeys. */
@@ -430,8 +434,7 @@ class VectorStore {
         return { orphanProjects, deletedRows };
     }
     deleteProjectRows(project) {
-        const ids = this.db.prepare('SELECT id FROM memories WHERE project = ?').all(project)
-            .map(row => row.id);
+        const ids = this.db.prepare('SELECT id FROM memories WHERE project = ?').all(project).map(row => row.id);
         if (ids.length === 0)
             return 0;
         this.deleteMemoryIds(ids);
@@ -449,7 +452,9 @@ class VectorStore {
         if (!this.hasTable('memory_vectors') || !this.hasTable('vec_memories') || ids.length === 0)
             return;
         const placeholders = ids.map(() => '?').join(', ');
-        this.db.prepare(`DELETE FROM vec_memories WHERE rowid IN (SELECT vector_rowid FROM memory_vectors WHERE memory_id IN (${placeholders}))`).run(...ids);
+        this.db
+            .prepare(`DELETE FROM vec_memories WHERE rowid IN (SELECT vector_rowid FROM memory_vectors WHERE memory_id IN (${placeholders}))`)
+            .run(...ids);
         this.db.prepare(`DELETE FROM memory_vectors WHERE memory_id IN (${placeholders})`).run(...ids);
     }
     /** Canonical project key used by v0.2.8+ storage. */
@@ -467,7 +472,7 @@ class VectorStore {
         return projectKey === 'global' ? name : `${projectKey}:${name}`;
     }
     hasTable(name) {
-        const row = this.db.prepare("SELECT name FROM sqlite_master WHERE name = ?").get(name);
+        const row = this.db.prepare('SELECT name FROM sqlite_master WHERE name = ?').get(name);
         return !!row;
     }
     /** Close database */

package/dist/migration/migrate.js

@@ -42,14 +42,7 @@ const PROJECT_RENAME_MAP = [
     { from: 'OPENHORSE.local.md', to: 'ORION.local.md' },
 ];
 /** Subdirectories whose contents are copied verbatim. */
-const VERBATIM_DIRS = new Set([
-    'projects',
-    'skills',
-    'cost',
-    'cache',
-    'backups',
-    'migration-logs',
-]);
+const VERBATIM_DIRS = new Set(['projects', 'skills', 'cost', 'cache', 'backups', 'migration-logs']);
 /** Directories whose parent is renamed (e.g. backups → backups/openhorse). */
 const NESTED_DIRS = {
     backups: 'openhorse',
@@ -144,9 +137,7 @@ function verifySqlite(path) {
     try {
         db = (0, vector_store_1.openBetterSqlite3)(path, { readonly: true });
         const result = db.pragma('integrity_check');
-        return result?.[0]?.integrity_check === 'ok'
-            ? { status: 'verified' }
-            : { status: 'invalid' };
+        return result?.[0]?.integrity_check === 'ok' ? { status: 'verified' } : { status: 'invalid' };
     }
     catch (error) {
         // ABI/module failures are environmental and actionable, not evidence that
@@ -345,7 +336,12 @@ function migrateProjectFiles(projectPath, options = {}) {
     const warnings = [];
     const resolved = (0, path_1.resolve)(projectPath);
     if (!(0, fs_1.existsSync)(resolved)) {
-        return { success: false, renamed, conflicts, warnings: [`Project path ${resolved} does not exist.`] };
+        return {
+            success: false,
+            renamed,
+            conflicts,
+            warnings: [`Project path ${resolved} does not exist.`],
+        };
     }
     for (const { from, to } of PROJECT_RENAME_MAP) {
         const srcPath = (0, path_1.join)(resolved, from);

package/dist/runtime/agent-runtime-controller.d.ts

@@ -132,6 +132,7 @@ export declare class AgentRuntimeController {
     reviewPlan(input: Parameters<NonNullable<import('./agent-runtime-runner').AgentRuntimeRunnerV1['reviewPlan']>>[0]): Promise<import('./plan-review').PlanReviewResolutionReceiptV1>;
     private runTurn;
     private handleRunLoopError;
+    private handleCommandError;
     private synchronizeSettingsAtLogicalBoundary;
     private emitAppend;
     private emitStatus;

package/dist/runtime/agent-runtime-controller.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRuntimeController = exports.FollowupQueueConflictError = void 0;
+const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
 const commands_1 = require("../commands");
 const parser_1 = require("../commands/parser");
@@ -333,21 +334,7 @@ class AgentRuntimeController {
         }
         if (parsedInput.isCommand) {
             const command = (0, commands_1.findCommand)(parsedInput.name);
-            this.activeRun = this.runCommand(command, parsedInput.args)
-                .catch(error => this.handleRunLoopError(error))
-                .finally(() => {
-                this.activeRun = null;
-            });
-            return { type: 'command_handled' };
-        }
-        if (this.turnController.hasActiveTurn()) {
-            const parsed = (0, parser_1.parseInput)(submitted);
-            if (parsed.isCommand) {
-                const command = (0, commands_1.findCommand)(parsed.name);
-                if (!command) {
-                    this.emitStatus(`Unknown command /${parsed.name}; active turn continues.`);
-                    return { type: 'command_ignored' };
-                }
+            if (this.turnController.hasActiveTurn()) {
                 if (command.busyPolicy === 'reject-busy') {
                     this.emitStatus(`/${command.name} rejected: an agent turn is active.`);
                     return { type: 'command_rejected_busy', commandId: command.id };
@@ -365,6 +352,16 @@ class AgentRuntimeController {
                 this.emitStatus(`Queued /${command.name}; it will apply after the active logical request.`);
                 return { type: 'command_queued', commandId: command.id };
             }
+            const run = this.runCommand(command, parsedInput.args)
+                .catch(error => this.handleCommandError(command, error))
+                .finally(() => {
+                if (this.activeRun === run)
+                    this.activeRun = null;
+            });
+            this.activeRun = run;
+            return { type: 'command_handled' };
+        }
+        if (this.turnController.hasActiveTurn()) {
             this.turnController.clearExitIntent();
             this.turnController.requestRevision(submitted);
             // v0.1.3 (G1): echo the incremental input to the transcript immediately,
@@ -731,6 +728,17 @@ class AgentRuntimeController {
             this.emitStatus(readyStatus);
         this.options.afterTurnLoop?.();
     }
+    handleCommandError(command, error) {
+        const message = (0, style_1.sanitizeTerminalText)((0, redaction_1.redactTraceText)(error instanceof Error ? error.message : String(error)));
+        this.emitAppend({
+            role: 'error',
+            title: `/${command.name}`,
+            content: message,
+            errorLayer: 'runtime',
+            command: commandIdentity(command, false),
+        });
+        this.emitStatus(`/${command.name} failed; the active turn state was not changed.`);
+    }
     async synchronizeSettingsAtLogicalBoundary() {
         const synchronize = this.options.runtime.synchronizeSettings;
         if (!synchronize)
@@ -1076,37 +1084,80 @@ function commandIdentity(command, success) {
     };
 }
 async function captureCommandOutput(execute) {
-    const lines = [];
-    const originalLog = console.log;
-    const originalError = console.error;
-    const originalWarn = console.warn;
-    const capture = (...values) => {
-        const line = values
-            .map(value => {
-            if (typeof value === 'string')
-                return value;
-            try {
-                return JSON.stringify(value);
-            }
-            catch {
-                return String(value);
-            }
-        })
-            .join(' ');
-        lines.push((0, style_1.sanitizeTerminalText)(line));
-    };
-    console.log = capture;
-    console.error = capture;
-    console.warn = capture;
+    const capture = { active: true, lines: [] };
+    acquireCommandConsoleBridge();
     try {
-        return { result: await execute(), output: lines.join('\n').trim() };
+        const result = await commandOutputCaptureStorage.run(capture, execute);
+        return { result, output: capture.lines.join('\n').trim() };
     }
     finally {
-        console.log = originalLog;
-        console.error = originalError;
-        console.warn = originalWarn;
+        capture.active = false;
+        releaseCommandConsoleBridge();
+    }
+}
+const commandOutputCaptureStorage = new async_hooks_1.AsyncLocalStorage();
+let commandConsoleBridgeReferences = 0;
+let commandConsoleOriginalMethods;
+const commandConsoleBridge = {
+    log: (...values) => routeCommandConsole('log', values),
+    error: (...values) => routeCommandConsole('error', values),
+    warn: (...values) => routeCommandConsole('warn', values),
+};
+function acquireCommandConsoleBridge() {
+    if (commandConsoleBridgeReferences === 0) {
+        commandConsoleOriginalMethods = {
+            log: originalConsoleMethod('log'),
+            error: originalConsoleMethod('error'),
+            warn: originalConsoleMethod('warn'),
+        };
+        console.log = commandConsoleBridge.log;
+        console.error = commandConsoleBridge.error;
+        console.warn = commandConsoleBridge.warn;
+    }
+    commandConsoleBridgeReferences += 1;
+}
+function releaseCommandConsoleBridge() {
+    commandConsoleBridgeReferences = Math.max(0, commandConsoleBridgeReferences - 1);
+    if (commandConsoleBridgeReferences !== 0 || !commandConsoleOriginalMethods)
+        return;
+    if (console.log === commandConsoleBridge.log)
+        console.log = commandConsoleOriginalMethods.log;
+    if (console.error === commandConsoleBridge.error)
+        console.error = commandConsoleOriginalMethods.error;
+    if (console.warn === commandConsoleBridge.warn)
+        console.warn = commandConsoleOriginalMethods.warn;
+}
+function originalConsoleMethod(method) {
+    const current = console[method];
+    if (current !== commandConsoleBridge[method] || !commandConsoleOriginalMethods)
+        return current;
+    return commandConsoleOriginalMethods[method];
+}
+function routeCommandConsole(method, values) {
+    const capture = commandOutputCaptureStorage.getStore();
+    if (capture?.active) {
+        capture.lines.push((0, style_1.sanitizeTerminalText)((0, redaction_1.redactTraceText)(formatConsoleValues(values))));
+        return;
+    }
+    const original = commandConsoleOriginalMethods?.[method];
+    if (original && original !== commandConsoleBridge[method]) {
+        Reflect.apply(original, console, values);
     }
 }
+function formatConsoleValues(values) {
+    return values
+        .map(value => {
+        if (typeof value === 'string')
+            return value;
+        try {
+            return JSON.stringify(value) ?? String(value);
+        }
+        catch {
+            return String(value);
+        }
+    })
+        .join(' ');
+}
 function projectFollowupQueueItem(item) {
     return Object.freeze({
         id: item.id,

package/dist/runtime/capability-receipt-journal.js

@@ -223,7 +223,7 @@ function replayAll(store) {
     const events = [];
     let cursor = 0;
     while (true) {
-        const page = store.replay(cursor);
+        const page = store.replay(cursor, undefined, 'capability_receipt_journal');
         events.push(...page.events);
         if (!page.hasMore)
             return events;

package/dist/runtime/composer/history.js

@@ -29,9 +29,7 @@ function pushHistoryEntry(state, value) {
     if (!value)
         return state;
     // Deduplicate consecutive identical.
-    const entries = state.entries[state.entries.length - 1] === value
-        ? state.entries
-        : [...state.entries, value];
+    const entries = state.entries[state.entries.length - 1] === value ? state.entries : [...state.entries, value];
     // Bound size.
     const trimmed = entries.length > exports.MAX_HISTORY_ENTRIES
         ? entries.slice(entries.length - exports.MAX_HISTORY_ENTRIES)

package/dist/runtime/composer/layout.js

@@ -124,7 +124,9 @@ function buildPromptVisualLines(value, width, cursor = value.length) {
                 chunkStart: chunk.start,
                 chunkEnd: chunk.end,
             };
-            if (cursorInThisLine && clampedCursor - lineStart >= chunk.start && clampedCursor - lineStart <= chunk.end) {
+            if (cursorInThisLine &&
+                clampedCursor - lineStart >= chunk.start &&
+                clampedCursor - lineStart <= chunk.end) {
                 cursorLineIndex = visualLines.length;
                 const cursorInChunk = Math.max(0, clampedCursor - lineStart - chunk.start);
                 cursorColumn = 5 + (0, string_width_1.default)(chunk.content.slice(0, cursorInChunk));
@@ -161,9 +163,10 @@ function formatPromptVisualLine(visualLine, width, options = {}) {
         const before = content.slice(0, offset);
         const after = content.slice(offset);
         const beforeWithCursor = `${before}${exports.PROMPT_CURSOR_GLYPH}`;
-        content = (0, string_width_1.default)(beforeWithCursor) >= maxContentWidth
-            ? `${takeVisualWidth(before, maxContentWidth - (0, string_width_1.default)(exports.PROMPT_CURSOR_GLYPH))}${exports.PROMPT_CURSOR_GLYPH}`
-            : `${beforeWithCursor}${takeVisualWidth(after, maxContentWidth - (0, string_width_1.default)(beforeWithCursor))}`;
+        content =
+            (0, string_width_1.default)(beforeWithCursor) >= maxContentWidth
+                ? `${takeVisualWidth(before, maxContentWidth - (0, string_width_1.default)(exports.PROMPT_CURSOR_GLYPH))}${exports.PROMPT_CURSOR_GLYPH}`
+                : `${beforeWithCursor}${takeVisualWidth(after, maxContentWidth - (0, string_width_1.default)(beforeWithCursor))}`;
     }
     const raw = `${prefix}${content}`;
     const padding = Math.max(0, promptContentWidth(width) - (0, string_width_1.default)(raw));

package/dist/runtime/durable-tool-receipt-reader.js

@@ -72,7 +72,7 @@ function readItemReceipt(sessionId, store, item) {
     if (!terminalSeq || terminalSeq < 2 || !toolName || !item.receipt) {
         throw new tool_receipt_validator_1.DurableToolReceiptValidationError('Terminal tool projection is missing its canonical receipt identity.');
     }
-    const pair = store.replay(terminalSeq - 2, 2).events;
+    const pair = store.replay(terminalSeq - 2, 2, 'durable_tool_receipt').events;
     const factEvent = pair.find(event => event.seq === terminalSeq - 1);
     const terminalEvent = pair.find(event => event.seq === terminalSeq);
     if (!factEvent || !terminalEvent || terminalEvent.itemId !== item.itemId) {

package/dist/runtime/legacy-thread-materializer.d.ts

@@ -1,7 +1,7 @@
 import type { RuntimeEventEnvelopeV1 } from './protocol/runtime-protocol-v1';
 import { type LegacySessionImportReceiptV1 } from './legacy-session-importer';
 import { ThreadEventStore, type ThreadCheckpointHeadV1 } from './thread-event-store';
-import { type ThreadProjectionV1 } from './thread-projection';
+import { type ThreadProjectionDigestVersionV1, type ThreadProjectionV1 } from './thread-projection';
 export type LegacyThreadMaterializationBoundaryV1 = 'after_dry_run' | 'after_receipt_staged' | 'after_facts_materialized' | 'after_projection_verified' | 'after_source_recheck' | 'before_index_switch' | 'after_index_switch';
 export interface LegacyThreadMaterializerOptionsV1 {
     readonly projectPath: string;
@@ -26,6 +26,8 @@ export interface ThreadCutoverIndexEntryV1 {
     readonly importDigest: string;
     readonly eventDigest: string;
     readonly projectionDigest: string;
+    /** Missing on v0.3.2 cutover entries; inferred against exact known schemes. */
+    readonly projectionDigestVersion?: ThreadProjectionDigestVersionV1;
     readonly cursor: number;
     readonly eventLogFile: string;
     readonly projectionFile: string;

package/dist/runtime/legacy-thread-materializer.js

@@ -82,7 +82,7 @@ function materializeLegacyThreadV1(options) {
         const existing = current.sessions[options.sessionId];
         const entry = createIndexEntry(options.sessionId, store, plan);
         if (existing) {
-            if ((0, canonical_1.canonicalRuntimeJson)(existing) !== (0, canonical_1.canonicalRuntimeJson)(entry)) {
+            if (!sameCutoverEntry(existing, entry, plan.projection)) {
                 throw new LegacyThreadMaterializationError('ORION_THREAD_CUTOVER_CONFLICT', `Session ${options.sessionId} already points at a different v2 Thread`);
             }
             mode = 'already_cutover';
@@ -131,7 +131,10 @@ function openSessionCheckpointStorageV1(projectPathInput, sessionId) {
         head.cursor < entry.cursor ||
         !head.verifiedPrefixes.some(prefix => prefix.cursor === entry.cursor &&
             prefix.eventDigest === entry.eventDigest &&
-            prefix.projectionDigest === entry.projectionDigest)) {
+            prefix.projectionDigest === entry.projectionDigest &&
+            (entry.projectionDigestVersion === undefined ||
+                prefix.projectionDigestVersion === undefined ||
+                prefix.projectionDigestVersion === entry.projectionDigestVersion))) {
         return undefined;
     }
     return Object.freeze({
@@ -179,7 +182,7 @@ function openSessionStorageV1(projectPathInput, sessionId) {
     const store = new thread_event_store_1.ThreadEventStore((0, paths_1.getProjectThreadsV2Dir)(projectPath), entry.threadId, {
         maxReplayEvents: Math.max(10000, entry.cursor),
     });
-    const prefixVerified = store.verifyDurablePrefix(entry.cursor, entry.eventDigest, entry.projectionDigest);
+    const prefixVerified = store.verifyDurablePrefix(entry.cursor, entry.eventDigest, entry.projectionDigest, entry.projectionDigestVersion);
     // The cutover receipt seals the imported prefix, not the forever-changing
     // head of a live Thread. loadProjection() independently verifies/rebuilds the
     // current cache against the complete hash-chained log.
@@ -477,7 +480,7 @@ function materializeFacts(threadsDir, plan) {
     if (cursor > plan.events.length) {
         throw diverged(`Existing Thread has ${cursor} events, expected ${plan.events.length}`);
     }
-    const existing = cursor === 0 ? [] : store.replay(0, cursor).events;
+    const existing = cursor === 0 ? [] : store.replay(0, cursor, 'legacy_materializer').events;
     for (let index = 0; index < existing.length; index += 1) {
         if ((0, canonical_1.canonicalRuntimeJson)(existing[index]) !== (0, canonical_1.canonicalRuntimeJson)(plan.events[index])) {
             throw diverged(`Existing Thread diverges from import plan at seq ${index + 1}`);
@@ -490,7 +493,7 @@ function materializeFacts(threadsDir, plan) {
     return store;
 }
 function verifyMaterializedStore(store, plan) {
-    const replay = store.replay(0, Math.max(1, plan.events.length));
+    const replay = store.replay(0, Math.max(1, plan.events.length), 'legacy_materializer');
     if (replay.hasMore ||
         replay.events.length !== plan.events.length ||
         (0, canonical_1.digestRuntimeValue)(replay.events) !== plan.eventDigest) {
@@ -523,6 +526,7 @@ function createIndexEntry(sessionId, store, plan) {
         importDigest: plan.receipt.importDigest,
         eventDigest: plan.eventDigest,
         projectionDigest: plan.projection.digest,
+        projectionDigestVersion: thread_projection_1.CURRENT_THREAD_PROJECTION_DIGEST_VERSION_V1,
         cursor: plan.events.length,
         eventLogFile: (0, path_1.basename)(store.logPath),
         projectionFile: (0, path_1.basename)(store.projectionPath),
@@ -530,6 +534,14 @@ function createIndexEntry(sessionId, store, plan) {
         cutoverAt: plan.receipt.sourceTimestamp,
     };
 }
+function sameCutoverEntry(existing, next, projection) {
+    const { projectionDigest: existingProjectionDigest, projectionDigestVersion: existingProjectionDigestVersion, ...existingIdentity } = existing;
+    const { projectionDigest: _nextProjectionDigest, projectionDigestVersion: _nextProjectionDigestVersion, ...nextIdentity } = next;
+    void _nextProjectionDigest;
+    void _nextProjectionDigestVersion;
+    return ((0, canonical_1.canonicalRuntimeJson)(existingIdentity) === (0, canonical_1.canonicalRuntimeJson)(nextIdentity) &&
+        (0, thread_projection_1.resolveThreadProjectionDigestVersionV1)(projection, existingProjectionDigest, existingProjectionDigestVersion) !== undefined);
+}
 function assertSourceUnchanged(projectPath, sessionId, expectedImportDigest) {
     const current = (0, legacy_session_importer_1.readLegacySessionMaterializationSnapshotV1)(projectPath, sessionId).receipt;
     if (current.importDigest !== expectedImportDigest) {

package/dist/runtime/orion-runtime-v1.d.ts

@@ -14,7 +14,7 @@ import { PromptRegistryV1 } from './prompts';
 import { ResourceScope, type ResourceScopeCloseReport } from './resource-scope';
 import { type RuntimeContributorSlots, type RuntimeContributors, type RuntimeServicePort, type RuntimeServices, type RuntimeServiceSlots } from './runtime-services';
 import { LazySkillRuntime, type LazySkillRuntimeOptions, type LazySkillRuntimeStatsV1 } from './skills';
-import { ExecutionService, type AuthoritySnapshotV1, type ToolBindingV1 } from './step-snapshot';
+import { ExecutionService, type AuthoritySnapshotV1, type ToolBindingV1, type WorkspaceMutationCoordinatorV1 } from './step-snapshot';
 import { ThreadCompactMaintenanceRunnerV1, ThreadCompactTransactionPersistenceV1, type ThreadCompactMaintenanceRunnerOptionsV1 } from './thread-compact-persistence';
 import { type TaskContextService, type TaskContextServiceOptions } from './task-context-service';
 import { ThreadEventStore, type ThreadEventStoreOptionsV1 } from './thread-event-store';
@@ -116,6 +116,7 @@ export interface OrionRuntimeV1Options {
     readonly mcp: Omit<LazyMcpRuntimeOptions, 'signal'>;
     readonly resolveCapabilityConfiguration: OrionCapabilityConfigurationResolverV1;
     readonly approvalHandler?: FirstPartyApprovalHandlerV1;
+    readonly workspaceMutationCoordinator?: WorkspaceMutationCoordinatorV1;
     readonly contributors?: RuntimeContributorSlots;
     readonly subagents?: OrionSubagentCompositionV1;
     readonly thread?: Omit<ThreadRuntimeOptionsV1, 'store' | 'runner' | 'maintenanceRunner' | 'projectPath' | 'requireTurnCommit'>;