@orion-agents/orion-code 0.3.22 → 0.3.24

package/dist/product/paths.js

@@ -7,7 +7,7 @@
  * of concatenating ".orion-code" directly.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECT_CONFIG_CANDIDATES = void 0;
+exports.PROJECT_CONFIG_CANDIDATES = exports.ProjectStorageIdentityUnavailableError = void 0;
 exports.getConfigHome = getConfigHome;
 exports.getConfigDir = getConfigDir;
 exports.getGlobalConfigPath = getGlobalConfigPath;
@@ -20,7 +20,10 @@ exports.getMcpConfigPath = getMcpConfigPath;
 exports.getProjectsDir = getProjectsDir;
 exports.getGlobalEnvPath = getGlobalEnvPath;
 exports.encodeProjectPath = encodeProjectPath;
+exports.resolveProjectStorageIdentityAsync = resolveProjectStorageIdentityAsync;
+exports.assertProjectStorageIdentity = assertProjectStorageIdentity;
 exports.resolveProjectStoragePath = resolveProjectStoragePath;
+exports.resolveProjectStoragePathAsync = resolveProjectStoragePathAsync;
 exports.getCanonicalProjectKey = getCanonicalProjectKey;
 exports.getProjectDir = getProjectDir;
 exports.getProjectMetadataPath = getProjectMetadataPath;
@@ -46,6 +49,7 @@ exports.getMemoryPath = getMemoryPath;
 exports.getExistingMemoryPaths = getExistingMemoryPaths;
 exports.ensureConfigDir = ensureConfigDir;
 exports.ensureProjectDir = ensureProjectDir;
+exports.ensureResolvedProjectDir = ensureResolvedProjectDir;
 exports.getProjectInstructionsPath = getProjectInstructionsPath;
 exports.getProjectSkillsDir = getProjectSkillsDir;
 const os_1 = require("os");
@@ -108,30 +112,296 @@ function encodeProjectPath(projectPath) {
     const suffix = (0, crypto_1.createHash)('sha256').update(normalized).digest('hex').slice(0, 8);
     return `${encoded || 'root'}-${suffix}`;
 }
-/** Resolve a project path for storage identity. */
+const projectStorageIdentities = new Map();
+const MAX_PROJECT_STORAGE_IDENTITIES = 256;
+const pendingProjectStorageIdentities = new Map();
+/** Interactive Hosts must not persist an unverified Git project identity. */
+class ProjectStorageIdentityUnavailableError extends Error {
+    constructor(message = 'Git 项目身份暂时无法确认，请检查本地 Git 后重试；未创建会话。') {
+        super(message);
+        this.code = 'project_storage_identity_unavailable';
+        this.name = 'ProjectStorageIdentityUnavailableError';
+    }
+}
+exports.ProjectStorageIdentityUnavailableError = ProjectStorageIdentityUnavailableError;
+function gitIdentityFileFingerprint(path) {
+    try {
+        const file = (0, fs_1.statSync)(path);
+        return [file.dev, file.ino, file.mode, file.size, file.mtimeMs, file.ctimeMs].join(':');
+    }
+    catch {
+        return 'missing';
+    }
+}
+/** Git's small pointer files, not repository contents, identify external gitdirs. */
+function readGitIdentityPointer(path) {
+    try {
+        const file = (0, fs_1.statSync)(path);
+        if (!file.isFile() || file.size > 4096)
+            return undefined;
+        return (0, fs_1.readFileSync)(path, 'utf-8').trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Track the nearest Git boundary without spawning Git. New nested repos,
+ * removed/replaced .git markers, root-affecting Git configuration and symlink
+ * retargeting invalidate identities; ordinary Git object/ref writes do not.
+ */
+function projectStorageFingerprint(canonicalPath) {
+    let directory = canonicalPath;
+    while (true) {
+        try {
+            const markerPath = (0, path_1.join)(directory, '.git');
+            const marker = (0, fs_1.statSync)(markerPath);
+            const markerIdentity = marker.isDirectory()
+                ? [marker.dev, marker.ino, marker.mode]
+                : [marker.dev, marker.ino, marker.mode, marker.size, marker.mtimeMs, marker.ctimeMs];
+            const pointer = marker.isDirectory() ? undefined : readGitIdentityPointer(markerPath);
+            const gitDirectory = marker.isDirectory()
+                ? markerPath
+                : pointer?.startsWith('gitdir: ')
+                    ? (0, path_1.resolve)(directory, pointer.slice('gitdir: '.length))
+                    : undefined;
+            const configIdentity = [];
+            if (gitDirectory) {
+                configIdentity.push(gitDirectory, gitIdentityFileFingerprint((0, path_1.join)(gitDirectory, 'config')), gitIdentityFileFingerprint((0, path_1.join)(gitDirectory, 'config.worktree')));
+                // Linked worktrees keep shared configuration outside their own gitdir.
+                // Track both the pointer and shared config, including enabling/disabling
+                // extensions.worktreeConfig, without running another Git subprocess.
+                const commonPointerPath = (0, path_1.join)(gitDirectory, 'commondir');
+                const commonPointer = readGitIdentityPointer(commonPointerPath);
+                configIdentity.push(gitIdentityFileFingerprint(commonPointerPath));
+                if (commonPointer) {
+                    const commonDirectory = (0, path_1.resolve)(gitDirectory, commonPointer);
+                    configIdentity.push(commonDirectory, gitIdentityFileFingerprint((0, path_1.join)(commonDirectory, 'config')));
+                }
+            }
+            return {
+                fingerprint: `${directory}:${markerIdentity.join(':')}|${configIdentity.join('|')}`,
+                hasGitBoundary: true,
+            };
+        }
+        catch {
+            // No readable Git marker at this level; check its parent.
+        }
+        const parent = (0, path_1.dirname)(directory);
+        if (parent === directory)
+            return { fingerprint: 'folder', hasGitBoundary: false };
+        directory = parent;
+    }
+}
+function storageOperationFingerprintUnchecked(projectPath) {
+    const absolute = (0, path_1.resolve)(projectPath);
+    const exists = (0, fs_1.existsSync)(absolute);
+    const canonical = exists ? (0, fs_1.realpathSync)(absolute) : absolute;
+    const directory = exists ? (0, fs_1.statSync)(canonical) : undefined;
+    const gitEnvironment = Object.entries(process.env)
+        .filter(([key]) => key.startsWith('GIT_'))
+        .sort(([left], [right]) => left.localeCompare(right));
+    const external = ['GIT_DIR', 'GIT_COMMON_DIR', 'GIT_WORK_TREE'].map(key => {
+        const value = process.env[key];
+        if (!value)
+            return '';
+        const path = (0, path_1.resolve)(canonical, value);
+        const target = (0, fs_1.existsSync)(path) ? (0, fs_1.realpathSync)(path) : path;
+        const common = readGitIdentityPointer((0, path_1.join)(target, 'commondir'));
+        return [
+            target,
+            gitIdentityFileFingerprint((0, path_1.join)(target, 'config')),
+            gitIdentityFileFingerprint((0, path_1.join)(target, 'config.worktree')),
+            gitIdentityFileFingerprint((0, path_1.join)(target, 'commondir')),
+            common ? gitIdentityFileFingerprint((0, path_1.join)((0, path_1.resolve)(target, common), 'config')) : '',
+        ].join('|');
+    });
+    return JSON.stringify([
+        canonical,
+        directory ? [directory.dev, directory.ino, directory.mode] : 'missing',
+        projectStorageFingerprint(canonical).fingerprint,
+        gitEnvironment,
+        external,
+    ]);
+}
+function storageOperationFingerprint(projectPath) {
+    try {
+        return storageOperationFingerprintUnchecked(projectPath);
+    }
+    catch {
+        throw new ProjectStorageIdentityUnavailableError('Project storage path changed or became unavailable. Retry.');
+    }
+}
+async function resolveProjectStorageIdentityAsync(projectPath) {
+    const requestedPath = (0, path_1.resolve)(projectPath);
+    const before = storageOperationFingerprint(requestedPath);
+    const canonicalPath = await resolveProjectStoragePathAsync(requestedPath);
+    if (storageOperationFingerprint(requestedPath) !== before) {
+        throw new ProjectStorageIdentityUnavailableError('Project storage identity changed. Retry.');
+    }
+    return Object.freeze({
+        requestedPath,
+        canonicalPath,
+        projectKey: encodeProjectPath(canonicalPath),
+        fingerprint: JSON.stringify([before, storageOperationFingerprint(canonicalPath)]),
+    });
+}
+/** Cheap lock-admission validation: filesystem/environment only, no Git spawn. */
+function assertProjectStorageIdentity(identity) {
+    if (JSON.stringify([
+        storageOperationFingerprint(identity.requestedPath),
+        storageOperationFingerprint(identity.canonicalPath),
+    ]) !== identity.fingerprint) {
+        throw new ProjectStorageIdentityUnavailableError('Project storage identity changed while waiting. Retry.');
+    }
+}
+/** Resolve a project path for storage identity with bounded, invalidatable reuse. */
 function resolveProjectStoragePath(projectPath) {
     const absolute = (0, path_1.resolve)(projectPath);
     if ((0, fs_1.existsSync)(absolute)) {
+        let canonical = absolute;
+        try {
+            canonical = (0, fs_1.realpathSync)(absolute);
+        }
+        catch {
+            return absolute;
+        }
+        // Explicit external Git configuration can change identity independently of
+        // the local .git boundary. Preserve its live Git semantics rather than cache it.
+        const cacheable = !process.env.GIT_DIR && !process.env.GIT_WORK_TREE && !process.env.GIT_COMMON_DIR;
+        const boundary = projectStorageFingerprint(canonical);
+        const fingerprint = [
+            boundary.fingerprint,
+            process.env.GIT_CEILING_DIRECTORIES ?? '',
+            process.env.GIT_DISCOVERY_ACROSS_FILESYSTEM ?? '',
+        ].join('|');
+        const cached = cacheable ? projectStorageIdentities.get(canonical) : undefined;
+        if (cached?.fingerprint === fingerprint && (0, fs_1.existsSync)(cached.path)) {
+            projectStorageIdentities.delete(canonical);
+            projectStorageIdentities.set(canonical, cached);
+            return cached.path;
+        }
+        let resolvedPath = canonical;
+        let gitResolved = false;
         try {
             const root = (0, child_process_1.execFileSync)('git', ['-C', absolute, 'rev-parse', '--show-toplevel'], {
                 encoding: 'utf-8',
                 stdio: ['ignore', 'pipe', 'ignore'],
+                timeout: 250,
+                killSignal: 'SIGKILL',
+                maxBuffer: 4096,
+                env: process.env,
             }).trim();
-            if (root)
-                return (0, fs_1.realpathSync)(root);
+            if (root) {
+                resolvedPath = (0, fs_1.realpathSync)(root);
+                gitResolved = true;
+            }
         }
         catch {
-            // Not a git worktree.
+            // Unavailable Git falls back to the existing canonical-folder identity.
         }
-        try {
-            return (0, fs_1.realpathSync)(absolute);
-        }
-        catch {
-            return absolute;
+        // A failure under a real Git boundary may be transient. Do not pin its
+        // fallback folder identity; a later successful probe must recover the root.
+        if (cacheable && (gitResolved || !boundary.hasGitBoundary)) {
+            projectStorageIdentities.set(canonical, { fingerprint, path: resolvedPath });
+            if (projectStorageIdentities.size > MAX_PROJECT_STORAGE_IDENTITIES) {
+                const oldest = projectStorageIdentities.keys().next().value;
+                if (oldest)
+                    projectStorageIdentities.delete(oldest);
+            }
         }
+        return resolvedPath;
     }
     return absolute;
 }
+/** Pre-resolve interactive Host identities without blocking its event loop. */
+async function resolveProjectStoragePathAsync(projectPath) {
+    const absolute = (0, path_1.resolve)(projectPath);
+    if (!(0, fs_1.existsSync)(absolute))
+        return absolute;
+    let canonical;
+    try {
+        canonical = (0, fs_1.realpathSync)(absolute);
+    }
+    catch {
+        throw new ProjectStorageIdentityUnavailableError('Project storage path became unavailable. Retry.');
+    }
+    const cacheable = !process.env.GIT_DIR && !process.env.GIT_WORK_TREE && !process.env.GIT_COMMON_DIR;
+    const boundary = projectStorageFingerprint(canonical);
+    const operationFingerprint = storageOperationFingerprint(absolute);
+    const fingerprint = [
+        boundary.fingerprint,
+        process.env.GIT_CEILING_DIRECTORIES ?? '',
+        process.env.GIT_DISCOVERY_ACROSS_FILESYSTEM ?? '',
+    ].join('|');
+    const cached = cacheable ? projectStorageIdentities.get(canonical) : undefined;
+    if (cached?.fingerprint === fingerprint && (0, fs_1.existsSync)(cached.path))
+        return cached.path;
+    const pendingKey = `${canonical}|${fingerprint}`;
+    const pending = cacheable ? pendingProjectStorageIdentities.get(pendingKey) : undefined;
+    if (pending)
+        return pending;
+    const probe = new Promise((resolveIdentity, rejectIdentity) => {
+        (0, child_process_1.execFile)('git', ['-C', absolute, 'rev-parse', '--show-toplevel'], {
+            encoding: 'utf-8',
+            timeout: 250,
+            killSignal: 'SIGKILL',
+            maxBuffer: 4096,
+            env: process.env,
+        }, (error, stdout) => {
+            let currentFingerprint;
+            try {
+                currentFingerprint = storageOperationFingerprint(absolute);
+            }
+            catch (failure) {
+                rejectIdentity(failure);
+                return;
+            }
+            if (currentFingerprint !== operationFingerprint) {
+                rejectIdentity(new ProjectStorageIdentityUnavailableError('Project storage identity changed during Git discovery. Retry.'));
+                return;
+            }
+            if (boundary.hasGitBoundary && (error || !stdout.trim())) {
+                rejectIdentity(new ProjectStorageIdentityUnavailableError());
+                return;
+            }
+            let result = canonical;
+            let gitResolved = false;
+            if (!error && stdout.trim()) {
+                try {
+                    result = (0, fs_1.realpathSync)(stdout.trim());
+                    gitResolved = true;
+                }
+                catch {
+                    if (boundary.hasGitBoundary) {
+                        rejectIdentity(new ProjectStorageIdentityUnavailableError());
+                        return;
+                    }
+                }
+            }
+            // Never seed a completed probe under a boundary changed while it ran.
+            if (cacheable && (gitResolved || !boundary.hasGitBoundary)) {
+                projectStorageIdentities.set(canonical, { fingerprint, path: result });
+                if (projectStorageIdentities.size > MAX_PROJECT_STORAGE_IDENTITIES) {
+                    const oldest = projectStorageIdentities.keys().next().value;
+                    if (oldest)
+                        projectStorageIdentities.delete(oldest);
+                }
+            }
+            resolveIdentity(result);
+        });
+    });
+    if (cacheable)
+        pendingProjectStorageIdentities.set(pendingKey, probe);
+    try {
+        return await probe;
+    }
+    finally {
+        if (pendingProjectStorageIdentities.get(pendingKey) === probe) {
+            pendingProjectStorageIdentities.delete(pendingKey);
+        }
+    }
+}
 function getCanonicalProjectKey(projectPath) {
     return encodeProjectPath(resolveProjectStoragePath(projectPath));
 }
@@ -246,6 +516,19 @@ function ensureProjectDir(projectPath) {
     const { updateProjectMetadata } = require('../services/config-dir');
     updateProjectMetadata(projectPath);
 }
+/** Use the already-verified identity; do not re-probe Git under explicit env. */
+function ensureResolvedProjectDir(identity) {
+    assertProjectStorageIdentity(identity);
+    ensureConfigDir();
+    const projectDir = (0, path_1.join)(getProjectsDir(), identity.projectKey);
+    const sessionsDir = (0, path_1.join)(projectDir, 'sessions');
+    (0, fs_1.mkdirSync)(sessionsDir, { recursive: true, mode: 0o700 });
+    sweepStorageDirectory(projectDir);
+    sweepStorageDirectory(sessionsDir);
+    const { updateProjectMetadata } = require('../services/config-dir');
+    updateProjectMetadata(identity.canonicalPath, new Date(), identity);
+    return sessionsDir;
+}
 // ── Project filesystem scanning ─────────────────────────────────────────────
 /** Ordered project config candidate files (relative to project root). */
 exports.PROJECT_CONFIG_CANDIDATES = [

package/dist/runtime/release-receipts.d.ts

@@ -7,7 +7,7 @@ export declare const WEB_E2E_LEGACY_SCENARIOS_V1: readonly ["E2E-P0-01", "E2E-P0
 export declare const WEB_E2E_WEB31_SCENARIOS_V1: readonly ["WEB31-P0-01", "WEB31-P0-02", "WEB31-P0-03", "WEB31-P0-04", "WEB31-P0-05", "WEB31-P0-06", "WEB31-P0-07", "WEB31-P0-08", "WEB31-P0-09", "WEB31-P0-10", "WEB31-P0-11", "WEB31-P0-12"];
 export declare const WEB_E2E_WEB32_SCENARIOS_V1: readonly ["WEB32-P0-01", "WEB32-P0-02", "WEB32-P0-03", "WEB32-P0-04", "WEB32-P0-05", "WEB32-P0-06", "WEB32-P0-07", "WEB32-P0-08", "WEB32-P0-09", "WEB32-P0-10", "WEB32-P0-11", "WEB32-P0-12"];
 export declare const WEB_E2E_WEB33_THEME_SCENARIOS_V1: readonly ["WEB33-P0-01", "WEB33-P0-02", "WEB33-P0-03", "WEB33-P0-04", "WEB33-P0-05", "WEB33-P0-06", "WEB33-P0-07", "WEB33-P0-08", "WEB33-P0-09", "WEB33-P0-10", "WEB33-P0-11", "WEB33-P0-12"];
-export declare const WEB_E2E_WEB33_SESSION_SCENARIOS_V1: readonly ["WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-19", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-22", "WEB33-P0-23", "WEB33-P0-24"];
+export declare const WEB_E2E_WEB33_SESSION_SCENARIOS_V1: readonly ["WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-19", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-22", "WEB33-P0-23", "WEB33-P0-24", "WEB33-P0-44", "WEB33-P0-45", "WEB33-P0-46", "WEB33-P0-47", "WEB33-P0-48", "WEB33-P0-49", "WEB33-P0-50", "WEB33-P0-51", "WEB33-P0-52", "WEB33-P0-53", "WEB33-P0-54", "WEB33-P0-55", "WEB33-P0-56", "WEB33-P0-57"];
 /**
  * v0.3.20 — the WEB33 scenarios whose specs shipped between v0.3.13 and
  * v0.3.15 (rail, transcript navigator, brand, files editor, resource layout)
@@ -37,7 +37,7 @@ export declare const WEB_E2E_WEB38_SCENARIOS_V1: readonly ["WEB38-P0-01", "WEB38
  * actually verify; the per-stage unit suites are registered separately.
  */
 export declare const WEB_E2E_WEB317_SCENARIOS_V1: readonly string[];
-export declare const WEB_E2E_WEB33_SCENARIOS_V1: readonly ("WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24" | "WEB33-P0-13" | "WEB33-P0-14" | "WEB33-P0-15" | "WEB33-P0-25" | "WEB33-P0-26" | "WEB33-P0-27" | "WEB33-P0-28" | "WEB33-P0-29" | "WEB33-P0-30" | "WEB33-P0-31" | "WEB33-P0-32" | "WEB33-P0-34" | "WEB33-P0-41" | "WEB33-P0-42" | "WEB33-P0-43")[];
+export declare const WEB_E2E_WEB33_SCENARIOS_V1: readonly ("WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24" | "WEB33-P0-44" | "WEB33-P0-45" | "WEB33-P0-46" | "WEB33-P0-47" | "WEB33-P0-48" | "WEB33-P0-49" | "WEB33-P0-50" | "WEB33-P0-51" | "WEB33-P0-52" | "WEB33-P0-53" | "WEB33-P0-54" | "WEB33-P0-55" | "WEB33-P0-56" | "WEB33-P0-57" | "WEB33-P0-13" | "WEB33-P0-14" | "WEB33-P0-15" | "WEB33-P0-25" | "WEB33-P0-26" | "WEB33-P0-27" | "WEB33-P0-28" | "WEB33-P0-29" | "WEB33-P0-30" | "WEB33-P0-31" | "WEB33-P0-32" | "WEB33-P0-34" | "WEB33-P0-41" | "WEB33-P0-42" | "WEB33-P0-43")[];
 /**
  * v0.3.19 — closing the v0.3.17 G317 assertion backlog.
  *
@@ -51,7 +51,7 @@ export declare const WEB_E2E_FULL_SCENARIOS_V1: readonly string[];
 export declare const WEB_E2E_SETTINGS_SCENARIOS_V1: readonly string[];
 export declare const WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1: readonly ["WEB31-P0-01", "WEB31-P0-02", "WEB31-P0-08", "WEB31-P0-09", "WEB31-P0-10", "WEB31-P0-12"];
 export declare const WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1: readonly ["WEB32-P0-01", "WEB32-P0-04", "WEB32-P0-05", "WEB32-P0-06", "WEB32-P0-09", "WEB32-P0-11", "WEB32-P0-12"];
-export declare const WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1: readonly ["WEB33-P0-01", "WEB33-P0-03", "WEB33-P0-08", "WEB33-P0-10", "WEB33-P0-12", "WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-23", "WEB33-P0-24"];
+export declare const WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1: readonly ["WEB33-P0-01", "WEB33-P0-03", "WEB33-P0-08", "WEB33-P0-10", "WEB33-P0-12", "WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-23", "WEB33-P0-24", "WEB33-P0-44", "WEB33-P0-45", "WEB33-P0-46", "WEB33-P0-47", "WEB33-P0-48", "WEB33-P0-49", "WEB33-P0-50", "WEB33-P0-51", "WEB33-P0-52", "WEB33-P0-53", "WEB33-P0-54", "WEB33-P0-55", "WEB33-P0-56", "WEB33-P0-57"];
 export declare const WEB_E2E_CRITICAL_SCENARIOS_V1: readonly string[];
 export type ReleaseGateDecisionV1 = 'GO' | 'NO_GO';
 export interface TarballArtifactReceiptV1 {

package/dist/runtime/release-receipts.js

@@ -96,6 +96,21 @@ exports.WEB_E2E_WEB33_SESSION_SCENARIOS_V1 = Object.freeze([
     'WEB33-P0-22',
     'WEB33-P0-23',
     'WEB33-P0-24',
+    // v0.3.24 — admission-window, creation and warm-switch regressions.
+    'WEB33-P0-44',
+    'WEB33-P0-45',
+    'WEB33-P0-46',
+    'WEB33-P0-47',
+    'WEB33-P0-48',
+    'WEB33-P0-49',
+    'WEB33-P0-50',
+    'WEB33-P0-51',
+    'WEB33-P0-52',
+    'WEB33-P0-53',
+    'WEB33-P0-54',
+    'WEB33-P0-55',
+    'WEB33-P0-56',
+    'WEB33-P0-57',
 ]);
 /**
  * v0.3.20 — the WEB33 scenarios whose specs shipped between v0.3.13 and
@@ -226,6 +241,20 @@ exports.WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1 = Object.freeze([
     'WEB33-P0-21',
     'WEB33-P0-23',
     'WEB33-P0-24',
+    'WEB33-P0-44',
+    'WEB33-P0-45',
+    'WEB33-P0-46',
+    'WEB33-P0-47',
+    'WEB33-P0-48',
+    'WEB33-P0-49',
+    'WEB33-P0-50',
+    'WEB33-P0-51',
+    'WEB33-P0-52',
+    'WEB33-P0-53',
+    'WEB33-P0-54',
+    'WEB33-P0-55',
+    'WEB33-P0-56',
+    'WEB33-P0-57',
 ]);
 exports.WEB_E2E_CRITICAL_SCENARIOS_V1 = Object.freeze([
     ...exports.WEB_E2E_LEGACY_SCENARIOS_V1.slice(0, 4),

package/dist/services/config-dir.d.ts

@@ -4,7 +4,7 @@
  * Re-exports from src/product/paths.ts for backward compatibility.
  * All new code should import directly from src/product/paths.ts.
  */
-export { getConfigHome, getConfigDir, getGlobalConfigPath, getSettingsPath, getUsageStatePath, getUsageLedgerPath, getUserMemoryPath, getHistoryPath, getMcpConfigPath, getProjectsDir, getGlobalEnvPath, encodeProjectPath, resolveProjectStoragePath, getCanonicalProjectKey, getProjectDir, getProjectMetadataPath, getProjectSessionsDir, getProjectSessionMetaPath, getProjectSessionMessagesPath, getProjectSessionHarnessPath, getProjectSessionCompactPath, getProjectSessionTracePath, getProjectSessionGoalPath, getProjectMemoryDir, getLegacyProjectMemoryDir, getProjectArtifactsDir, getProjectCheckpointsDir, getProjectIndexesDir, getCostDir, getDailyCostPath, getCacheDir, getMemoryPath, getExistingMemoryPaths, ensureConfigDir, ensureProjectDir, PROJECT_CONFIG_CANDIDATES, getProjectInstructionsPath, getProjectSkillsDir, type MemoryType, } from '../product/paths';
+export { getConfigHome, getConfigDir, getGlobalConfigPath, getSettingsPath, getUsageStatePath, getUsageLedgerPath, getUserMemoryPath, getHistoryPath, getMcpConfigPath, getProjectsDir, getGlobalEnvPath, encodeProjectPath, resolveProjectStoragePath, resolveProjectStoragePathAsync, getCanonicalProjectKey, getProjectDir, getProjectMetadataPath, getProjectSessionsDir, getProjectSessionMetaPath, getProjectSessionMessagesPath, getProjectSessionHarnessPath, getProjectSessionCompactPath, getProjectSessionTracePath, getProjectSessionGoalPath, getProjectMemoryDir, getLegacyProjectMemoryDir, getProjectArtifactsDir, getProjectCheckpointsDir, getProjectIndexesDir, getCostDir, getDailyCostPath, getCacheDir, getMemoryPath, getExistingMemoryPaths, ensureConfigDir, ensureProjectDir, PROJECT_CONFIG_CANDIDATES, getProjectInstructionsPath, getProjectSkillsDir, type MemoryType, } from '../product/paths';
 export declare const PROJECT_METADATA_SCHEMA_VERSION = 1;
 export interface ProjectMetadata {
     schemaVersion: number;
@@ -13,6 +13,7 @@ export interface ProjectMetadata {
     createdAt: string;
     lastSeenAt: string;
 }
+import { type ProjectStorageIdentity } from '../product/paths';
 export declare function readProjectMetadata(projectPath: string): ProjectMetadata | null;
-export declare function updateProjectMetadata(projectPath: string, now?: Date): ProjectMetadata;
+export declare function updateProjectMetadata(projectPath: string, now?: Date, identity?: ProjectStorageIdentity): ProjectMetadata;
 //# sourceMappingURL=config-dir.d.ts.map

package/dist/services/config-dir.js

@@ -6,11 +6,10 @@
  * All new code should import directly from src/product/paths.ts.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECT_METADATA_SCHEMA_VERSION = exports.getProjectSkillsDir = exports.getProjectInstructionsPath = exports.PROJECT_CONFIG_CANDIDATES = exports.ensureProjectDir = exports.ensureConfigDir = exports.getExistingMemoryPaths = exports.getMemoryPath = exports.getCacheDir = exports.getDailyCostPath = exports.getCostDir = exports.getProjectIndexesDir = exports.getProjectCheckpointsDir = exports.getProjectArtifactsDir = exports.getLegacyProjectMemoryDir = exports.getProjectMemoryDir = exports.getProjectSessionGoalPath = exports.getProjectSessionTracePath = exports.getProjectSessionCompactPath = exports.getProjectSessionHarnessPath = exports.getProjectSessionMessagesPath = exports.getProjectSessionMetaPath = exports.getProjectSessionsDir = exports.getProjectMetadataPath = exports.getProjectDir = exports.getCanonicalProjectKey = exports.resolveProjectStoragePath = exports.encodeProjectPath = exports.getGlobalEnvPath = exports.getProjectsDir = exports.getMcpConfigPath = exports.getHistoryPath = exports.getUserMemoryPath = exports.getUsageLedgerPath = exports.getUsageStatePath = exports.getSettingsPath = exports.getGlobalConfigPath = exports.getConfigDir = exports.getConfigHome = void 0;
+exports.PROJECT_METADATA_SCHEMA_VERSION = exports.getProjectSkillsDir = exports.getProjectInstructionsPath = exports.PROJECT_CONFIG_CANDIDATES = exports.ensureProjectDir = exports.ensureConfigDir = exports.getExistingMemoryPaths = exports.getMemoryPath = exports.getCacheDir = exports.getDailyCostPath = exports.getCostDir = exports.getProjectIndexesDir = exports.getProjectCheckpointsDir = exports.getProjectArtifactsDir = exports.getLegacyProjectMemoryDir = exports.getProjectMemoryDir = exports.getProjectSessionGoalPath = exports.getProjectSessionTracePath = exports.getProjectSessionCompactPath = exports.getProjectSessionHarnessPath = exports.getProjectSessionMessagesPath = exports.getProjectSessionMetaPath = exports.getProjectSessionsDir = exports.getProjectMetadataPath = exports.getProjectDir = exports.getCanonicalProjectKey = exports.resolveProjectStoragePathAsync = exports.resolveProjectStoragePath = exports.encodeProjectPath = exports.getGlobalEnvPath = exports.getProjectsDir = exports.getMcpConfigPath = exports.getHistoryPath = exports.getUserMemoryPath = exports.getUsageLedgerPath = exports.getUsageStatePath = exports.getSettingsPath = exports.getGlobalConfigPath = exports.getConfigDir = exports.getConfigHome = void 0;
 exports.readProjectMetadata = readProjectMetadata;
 exports.updateProjectMetadata = updateProjectMetadata;
 const fs_1 = require("fs");
-const child_process_1 = require("child_process");
 const path_1 = require("path");
 const atomic_write_1 = require("./atomic-write");
 const debug_log_1 = require("../utils/debug-log");
@@ -28,6 +27,7 @@ Object.defineProperty(exports, "getProjectsDir", { enumerable: true, get: functi
 Object.defineProperty(exports, "getGlobalEnvPath", { enumerable: true, get: function () { return paths_1.getGlobalEnvPath; } });
 Object.defineProperty(exports, "encodeProjectPath", { enumerable: true, get: function () { return paths_1.encodeProjectPath; } });
 Object.defineProperty(exports, "resolveProjectStoragePath", { enumerable: true, get: function () { return paths_1.resolveProjectStoragePath; } });
+Object.defineProperty(exports, "resolveProjectStoragePathAsync", { enumerable: true, get: function () { return paths_1.resolveProjectStoragePathAsync; } });
 Object.defineProperty(exports, "getCanonicalProjectKey", { enumerable: true, get: function () { return paths_1.getCanonicalProjectKey; } });
 Object.defineProperty(exports, "getProjectDir", { enumerable: true, get: function () { return paths_1.getProjectDir; } });
 Object.defineProperty(exports, "getProjectMetadataPath", { enumerable: true, get: function () { return paths_1.getProjectMetadataPath; } });
@@ -75,33 +75,10 @@ function readProjectMetadata(projectPath) {
         return null;
     }
 }
-function updateProjectMetadata(projectPath, now = new Date()) {
-    const resolvedPath = (() => {
-        const absolute = (0, path_1.resolve)(projectPath);
-        if ((0, fs_1.existsSync)(absolute)) {
-            try {
-                const root = (0, child_process_1.execFileSync)('git', ['-C', absolute, 'rev-parse', '--show-toplevel'], {
-                    encoding: 'utf-8',
-                    stdio: ['ignore', 'pipe', 'ignore'],
-                }).trim();
-                if (root)
-                    return (0, fs_1.realpathSync)(root);
-            }
-            catch (error) {
-                // Not a git worktree, or git is unavailable: fall back to the path.
-                (0, debug_log_1.debugError)('config-dir.resolveGitRoot', error, absolute);
-            }
-            try {
-                return (0, fs_1.realpathSync)(absolute);
-            }
-            catch (error) {
-                // Broken symlink or a race with a deletion; the literal path is
-                // still a usable project key.
-                (0, debug_log_1.debugError)('config-dir.realpath', error, absolute);
-            }
-        }
-        return absolute;
-    })();
+function updateProjectMetadata(projectPath, now = new Date(), identity) {
+    if (identity)
+        (0, paths_2.assertProjectStorageIdentity)(identity);
+    const resolvedPath = identity?.canonicalPath ?? (0, paths_2.resolveProjectStoragePath)(projectPath);
     const projectKey = (0, paths_2.encodeProjectPath)(resolvedPath);
     const projectDir = (0, path_1.join)((0, paths_2.getProjectsDir)(), projectKey);
     if (!(0, fs_1.existsSync)(projectDir)) {

package/dist/services/repo-intelligence/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * v0.3.23 T23-B — Repo Intelligence facade: symbol index, incremental
+ * maintenance, task-relevant recall with sourced reasons, and budget-aware
+ * selection. Feature-flagged at the integration seam (ORION_CODE_REPO_INTELLIGENCE)
+ * so the prompt assembly can adopt it incrementally.
+ */
+export { RepoSymbolIndexV1, type RepoSymbolEntryV1, type RepoFileRecordV1, type RepoIndexStatsV1, type RepoSymbolIndexOptionsV1, } from './symbol-index';
+export { recallFiles, selectWithinBudget, type RecallCandidateV1, type RecallOptionsV1, } from './recall';
+/** The runtime integration flag: 'on' enables harness wiring; default off. */
+export declare function isRepoIntelligenceEnabled(env?: Readonly<Record<string, string | undefined>>): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/repo-intelligence/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectWithinBudget = exports.recallFiles = exports.RepoSymbolIndexV1 = void 0;
+exports.isRepoIntelligenceEnabled = isRepoIntelligenceEnabled;
+/**
+ * v0.3.23 T23-B — Repo Intelligence facade: symbol index, incremental
+ * maintenance, task-relevant recall with sourced reasons, and budget-aware
+ * selection. Feature-flagged at the integration seam (ORION_CODE_REPO_INTELLIGENCE)
+ * so the prompt assembly can adopt it incrementally.
+ */
+var symbol_index_1 = require("./symbol-index");
+Object.defineProperty(exports, "RepoSymbolIndexV1", { enumerable: true, get: function () { return symbol_index_1.RepoSymbolIndexV1; } });
+var recall_1 = require("./recall");
+Object.defineProperty(exports, "recallFiles", { enumerable: true, get: function () { return recall_1.recallFiles; } });
+Object.defineProperty(exports, "selectWithinBudget", { enumerable: true, get: function () { return recall_1.selectWithinBudget; } });
+/** The runtime integration flag: 'on' enables harness wiring; default off. */
+function isRepoIntelligenceEnabled(env = process.env) {
+    return env.ORION_CODE_REPO_INTELLIGENCE === 'on';
+}
+//# sourceMappingURL=index.js.map

package/dist/services/repo-intelligence/recall.d.ts

@@ -0,0 +1,44 @@
+/**
+ * v0.3.23 T23-B3 — task-relevant context recall over the symbol index.
+ *
+ * Given the user intent, the currently active files, and (optionally) recently
+ * changed files, produce a bounded, ranked candidate list. Every candidate
+ * carries explicit `reasons[]` — the recall result is evidence, not a black
+ * box — and the caller can log it into the Harness ledger.
+ *
+ * Scoring (heuristic, evaluated by the Recall@K suite — not claimed as
+ * semantic understanding):
+ *   +50 direct mention: the intent names the path or its basename
+ *   +30 symbol match:   a quoted/known symbol from the intent is defined here
+ *   +20 import adjacency: an active file imports this file (or vice versa)
+ *   +15 test pairing:    tests/<x>.test.* <-> src/<x>.*
+ *   +10 recent change:   the file appears in the changed set
+ */
+import type { RepoSymbolIndexV1 } from './symbol-index';
+export interface RecallCandidateV1 {
+    readonly path: string;
+    readonly score: number;
+    readonly reasons: readonly string[];
+}
+export interface RecallOptionsV1 {
+    /** Free-text user intent (task description). */
+    readonly intent: string;
+    /** Files the user or the current turn is already working with. */
+    readonly activeFiles: readonly string[];
+    /** Files changed in the current change-set (git diff), if available. */
+    readonly changedFiles?: readonly string[];
+    /** Maximum number of candidates returned. */
+    readonly limit?: number;
+}
+export declare function recallFiles(index: RepoSymbolIndexV1, options: RecallOptionsV1): readonly RecallCandidateV1[];
+/**
+ * Budget-aware selection: rank candidates, deduplicate by directory concentration
+ * (at most `maxPerDirectory` per immediate directory), and always keep explicitly
+ * active files (the user touched them — they are never dropped for budget).
+ */
+export declare function selectWithinBudget(candidates: readonly RecallCandidateV1[], options: {
+    readonly activeFiles: readonly string[];
+    readonly maxFiles?: number;
+    readonly maxPerDirectory?: number;
+}): readonly RecallCandidateV1[];
+//# sourceMappingURL=recall.d.ts.map