@aiwg/cli 2026.10.5 → 2026.10.6

package/dist/src/artifacts/fortemi-core-sync.js

@@ -5,9 +5,9 @@ import { fileURLToPath } from "node:url";
 import { parse as parseYaml } from "yaml";
 import { GRAPH_CONFIGS, getProjectIndexRoot, loadGlobalGraphConfigs } from "./types.js";
 import { buildAiwgFortemiIndexExport, } from "./browser-export.js";
-import { loadGraphIndexFile } from "./index-reader.js";
+import { loadGraphIndexFile, publishIndexFiles } from "./index-reader.js";
 import { getFrameworkIndexBaseDir } from './framework-index-paths.js';
-function syncDir(cwd, graph) {
+export function getFortemiCoreIndexDir(cwd, graph) {
     loadGlobalGraphConfigs();
     if (graph === 'framework')
         return path.join(getFrameworkIndexBaseDir(cwd), 'fortemi-core', graph);
@@ -180,14 +180,15 @@ function writeExport(file, exported, maxChars) {
 }
 export function syncFortemiCoreIndex(cwd, options = {}) {
     const graph = options.graph ?? "project";
-    const dir = syncDir(cwd, graph);
+    const dir = getFortemiCoreIndexDir(cwd, graph);
     const exportPath = path.join(dir, "aiwg-fortemi-index-v2.json");
     const manifestPath = path.join(dir, "manifest.json");
     const maxChars = options.maxChunkChars ?? 64 * 1024;
     if (!Number.isSafeInteger(maxChars) || maxChars < 64)
         throw new Error("maxChunkChars must be an integer of at least 64");
     fs.mkdirSync(dir, { recursive: true });
-    const temporaryPath = path.join(dir, `.export-${randomUUID()}.tmp`);
+    const staging = fs.mkdtempSync(path.join(dir, ".sync-"));
+    const temporaryPath = path.join(staging, `.export-${randomUUID()}.tmp`);
     const previous = readManifest(manifestPath);
     const sourceBuiltAt = sourceIndexBuiltAt(cwd, graph);
     const buildExport = (generatedAt) => {
@@ -200,10 +201,25 @@ export function syncFortemiCoreIndex(cwd, options = {}) {
         });
         const checksum = writeExport(temporaryPath, exported, maxChars);
         const recordsWithConcepts = exported.items.filter((item) => (item.skos_concepts?.length ?? 0) > 0).length;
+        const shortTextThreshold = 200;
+        let shortTextCount = 0;
+        let filenameTitleCount = 0;
+        for (const item of exported.items) {
+            if (item.text.trim().length < shortTextThreshold)
+                shortTextCount++;
+            if (item.title.trim() === path.posix.basename(item.source.path))
+                filenameTitleCount++;
+        }
         return {
             generatedAt,
             checksum,
             itemCount: exported.items.length,
+            textQuality: {
+                short_text_threshold_chars: shortTextThreshold,
+                short_text_count: shortTextCount,
+                filename_title_count: filenameTitleCount,
+                degenerate: exported.items.length === 0 || shortTextCount / exported.items.length >= 0.8,
+            },
             skosCoverage: {
                 records_with_concepts: recordsWithConcepts,
                 total_records: exported.items.length,
@@ -228,7 +244,7 @@ export function syncFortemiCoreIndex(cwd, options = {}) {
                 }
             }
         }
-        fs.renameSync(temporaryPath, exportPath);
+        fs.renameSync(temporaryPath, path.join(staging, path.basename(exportPath)));
         const manifest = {
             schema_version: "aiwg.fortemi.core-sync.v1",
             backend: "fortemi-core",
@@ -238,19 +254,21 @@ export function syncFortemiCoreIndex(cwd, options = {}) {
             export_schema_version: "aiwg.fortemi.index.export.v2",
             export_checksum: built.checksum,
             item_count: built.itemCount,
+            text_quality: built.textQuality,
             skos_coverage: built.skosCoverage,
             status,
             source_index_built_at: sourceBuiltAt,
         };
-        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+        fs.writeFileSync(path.join(staging, path.basename(manifestPath)), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+        publishIndexFiles(staging, dir);
         return manifest;
     }
     finally {
-        fs.rmSync(temporaryPath, { force: true });
+        fs.rmSync(staging, { recursive: true, force: true });
     }
 }
 export function getFortemiCoreSyncStatus(cwd, graph = "project") {
-    const dir = syncDir(cwd, graph);
+    const dir = getFortemiCoreIndexDir(cwd, graph);
     const manifestPath = path.join(dir, "manifest.json");
     const exportPath = path.join(dir, "aiwg-fortemi-index-v2.json");
     const { manifest, reason: manifestReadReason } = readManifestResult(manifestPath);

package/dist/src/artifacts/graph-query.js

@@ -9,8 +9,17 @@
  * @tests @test/unit/artifacts/graph-query.test.ts
  */
 import { normalizeEdges } from './types.js';
-import { buildFortemiCoreDependencyGraph } from './fortemi-core-query-adapter.js';
+import { buildFortemiCoreDependencyGraph, loadFortemiCoreMetadataEntries } from './fortemi-core-query-adapter.js';
 import { closeGraphBackend, openGraphBackend } from './backend-runtime.js';
+import { loadGraphIndexFile } from './index-reader.js';
+import { isOrdinaryMemoryEntry } from './query-engine.js';
+function graphMemoryMetadata(cwd, graph, backend) {
+    const local = loadGraphIndexFile(cwd, 'metadata.json', graph)?.entries ?? {};
+    if (backend === 'fortemi-core') {
+        return { ...Object.fromEntries(loadFortemiCoreMetadataEntries(cwd, graph).entries.map(entry => [entry.path, entry])), ...local };
+    }
+    return local;
+}
 /**
  * Get neighbors of a node in a dependency graph.
  *
@@ -20,15 +29,15 @@ import { closeGraphBackend, openGraphBackend } from './backend-runtime.js';
  * @param edgeType - Optional filter by edge type
  * @returns Array of neighbor paths
  */
-export function getNeighbors(graph, node, direction = 'both', edgeType) {
+export function getNeighbors(graph, node, direction = 'both', edgeType, metadata = {}) {
     const entry = graph[node];
-    if (!entry)
+    if (!entry || (metadata[node] && !isOrdinaryMemoryEntry(metadata[node])))
         return [];
     const results = new Set();
     if (direction === 'in' || direction === 'both') {
         const edges = normalizeEdges(entry.upstream);
         for (const edge of edges) {
-            if (!edgeType || edge.type === edgeType) {
+            if ((!edgeType || edge.type === edgeType) && (!metadata[edge.path] || isOrdinaryMemoryEntry(metadata[edge.path]))) {
                 results.add(edge.path);
             }
         }
@@ -36,7 +45,7 @@ export function getNeighbors(graph, node, direction = 'both', edgeType) {
     if (direction === 'out' || direction === 'both') {
         const edges = normalizeEdges(entry.downstream);
         for (const edge of edges) {
-            if (!edgeType || edge.type === edgeType) {
+            if ((!edgeType || edge.type === edgeType) && (!metadata[edge.path] || isOrdinaryMemoryEntry(metadata[edge.path]))) {
                 results.add(edge.path);
             }
         }
@@ -134,7 +143,7 @@ export async function showNeighbors(cwd, options) {
         }
         process.exit(1);
     }
-    const neighbors = getNeighbors(graph, resolved, direction, edgeType);
+    const neighbors = getNeighbors(graph, resolved, direction, edgeType, graphMemoryMetadata(cwd, graphType, backend));
     if (json) {
         console.log(JSON.stringify({
             graph: graphType,
@@ -208,8 +217,9 @@ export async function executeSetQuery(cwd, options) {
         console.error(`Error: Node '${nodeB}' not found in graph '${graphType}'.`);
         process.exit(1);
     }
-    const neighborsA = getNeighbors(graph, resolvedA, direction, edgeType);
-    const neighborsB = getNeighbors(graph, resolvedB, direction, edgeType);
+    const metadata = graphMemoryMetadata(cwd, graphType, backend);
+    const neighborsA = getNeighbors(graph, resolvedA, direction, edgeType, metadata);
+    const neighborsB = getNeighbors(graph, resolvedB, direction, edgeType, metadata);
     let result;
     switch (op) {
         case 'intersection':

package/dist/src/artifacts/index-adapters.js

@@ -0,0 +1,339 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getUserStateDir } from '../config/user-state.js';
+import { projectAiwgPath, projectControlPath } from '../config/project-artifacts.js';
+import { validateIndexConfig } from '../config/aiwg-config.js';
+import { collectGraphIndexFiles, findArtifactFiles, INDEX_SCRATCH_DIRS } from './index-files.js';
+import { writeIndexFile } from './index-reader.js';
+import { GRAPH_CONFIGS, INDEX_VERSION, INDEX_EXTRACTOR_VERSION, getGraphIndexDir, resolveGraphBackendType, resolveGraphScanDir } from './types.js';
+import { acquireDirectoryLock, DirectoryLockContentionError } from './prebuilt-build-lock.js';
+import { resolveFrameworkIndexRoot } from './framework-index-paths.js';
+import { resolveProjectLocalSearchRoots } from '../extensions/project-local-paths.js';
+import { getFortemiCoreIndexDir } from './fortemi-core-sync.js';
+function json(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function canonical(root) {
+    try {
+        return fs.realpathSync(root);
+    }
+    catch {
+        return path.resolve(root);
+    }
+}
+function hashFiles(files, context) {
+    const hash = createHash('sha256').update(JSON.stringify(context));
+    for (const file of [...new Set(files)].sort()) {
+        hash.update('\0').update(file).update('\0').update(fs.readFileSync(file));
+    }
+    return hash.digest('hex');
+}
+/** Same authorized source set as the builder, including links and bundle roots. */
+export async function graphIndexDigest(cwd, graph, observation = {}) {
+    const fileStats = observation.fileStats ?? new Map();
+    const files = observation.files ? [...observation.files]
+        : graph === 'source' ? (await import('./source-graph.js')).collectSourceFiles(cwd, true)
+            : await collectGraphIndexFiles(cwd, graph, { selection: observation.selection, fileStats });
+    const ignoreRoots = graph && GRAPH_CONFIGS[graph]?.shared && graph !== 'framework' ? [] : [cwd];
+    if (graph)
+        ignoreRoots.push(...GRAPH_CONFIGS[graph].scanDirs.map(dir => resolveGraphScanDir(cwd, dir)));
+    for (const root of ignoreRoots) {
+        const ignoreFile = path.join(root, '.gitignore');
+        if (fs.existsSync(ignoreFile))
+            files.push(ignoreFile);
+    }
+    if (graph === 'source')
+        for (const file of ['tsconfig.json', 'package.json']) {
+            if (fs.existsSync(path.join(cwd, file)))
+                files.push(path.join(cwd, file));
+        }
+    // Supplements affect graph entries even though they are outside scanDirs.
+    for (const supplement of (graph ? GRAPH_CONFIGS[graph]?.metadataSupplements : undefined) ?? []) {
+        files.push(...findArtifactFiles(resolveGraphScanDir(cwd, supplement.scanDir)));
+    }
+    const inputs = [...new Set(files)].sort().map(file => {
+        const stat = fileStats.get(file) ?? fs.statSync(file);
+        return [file, stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs];
+    });
+    return createHash('sha256').update(JSON.stringify([graph && GRAPH_CONFIGS[graph]?.shared ? null : canonical(cwd), INDEX_VERSION, INDEX_EXTRACTOR_VERSION,
+        graph ? GRAPH_CONFIGS[graph] : null, resolveGraphBackendType(graph), inputs])).digest('hex');
+}
+export function resolveFreshnessPolicy(cwd, adapter) {
+    const config = json(projectControlPath(cwd, 'aiwg.config'))?.index;
+    const errors = validateIndexConfig(config && { freshness: config.freshness });
+    if (errors.length)
+        throw new Error(errors.join('; '));
+    const defaults = {
+        graphs: 3_600_000, sessions: 900_000, caches: 86_400_000, runtime: 21_600_000,
+        models: 86_400_000, issues: 300_000, datasets: 86_400_000,
+    };
+    return { index: adapter.name, targetStaleAfterMs: defaults[adapter.group], maxRetriesPerDay: 3,
+        measureConvergence: true, ...config?.freshness?.[adapter.group], ...config?.freshness?.[adapter.name] };
+}
+/** Registry is bounded by graph registrations and existing owner scopes. No host discovery. */
+export function indexAdapterRegistry(cwd) {
+    const adapters = [];
+    const add = (definition) => {
+        const adapter = { ...definition,
+            probe: (workspace, nowMs) => probeIndexAdapter(adapter, workspace, nowMs),
+            refresh: async (opts) => {
+                const { refreshIndexes } = await import('./index-refresh.js');
+                return refreshIndexes({ cwd: opts.cwd, only: adapter.name, full: opts.full,
+                    dryRun: opts.dryRun, signal: opts.signal });
+            },
+            convergence: last => {
+                const jobs = last.jobs.filter(job => definition.group === 'graphs' ? job.kind === 'graph' && job.graph === definition.graph
+                    : definition.group === 'caches' ? job.kind === 'cache' && job.graph === definition.graph : job.kind === definition.name);
+                return { converged: jobs.length > 0 && jobs.every(job => job.freshness?.status === 'fresh'
+                        && job.freshness.convergence?.converged !== false), wallMs: last.totals.wallMs,
+                    residualJobs: jobs.filter(job => job.freshness?.status !== 'fresh').length };
+            },
+        };
+        adapters.push(adapter);
+    };
+    for (const [graph, config] of Object.entries(GRAPH_CONFIGS)) {
+        const directory = getGraphIndexDir(cwd, graph);
+        const outputs = ['metadata.json', 'dependencies.json', 'tags.json', 'stats.json'];
+        if (resolveGraphBackendType(graph) === 'sqlite')
+            outputs.push('graph.db');
+        if (graph === 'framework')
+            outputs.push('relations.json');
+        add({ name: graph, graph, group: 'graphs', identity: canonical(directory),
+            backend: resolveGraphBackendType(graph), operation: 'buildIndex', supported: true,
+            exclusions: [...INDEX_SCRATCH_DIRS, 'symlinks', 'gitignored', 'hidden directories'],
+            roots: workspace => [...new Set([
+                    ...config.scanDirs.map(dir => canonical(resolveGraphScanDir(graph === 'framework' ? resolveFrameworkIndexRoot(workspace) : workspace, dir))),
+                    ...(graph === 'project' ? [canonical(workspace), ...resolveProjectLocalSearchRoots(workspace).map(root => canonical(root.rootPath))] : []),
+                ])],
+            outputPaths: outputs.map(file => path.join(directory, file)), statePath: path.join(directory, 'freshness.json') });
+        if (graph === 'framework') {
+            const owner = adapters[adapters.length - 1];
+            add({ ...owner, name: 'relationships', operation: 'buildIndex(framework):relations',
+                reason: 'Relationship projection shares the framework snapshot and owner lock' });
+        }
+        const cacheDirectory = getFortemiCoreIndexDir(cwd, graph);
+        if (fs.existsSync(cacheDirectory))
+            add({ name: `caches:${graph}`, graph, group: 'caches',
+                identity: canonical(cacheDirectory), backend: 'fortemi-core', operation: 'syncFortemiCoreIndex',
+                supported: true, exclusions: ['remote mutation'], roots: () => [canonical(directory)],
+                outputPaths: ['manifest.json', 'aiwg-fortemi-index-v2.json'].map(file => path.join(cacheDirectory, file)),
+                statePath: path.join(cacheDirectory, 'freshness.json') });
+    }
+    const scopes = [
+        { name: 'sessions', directory: path.join(cwd, '.aiwg/sessions'), backend: 'sqlite',
+            operation: 'refreshSessionCatalog', outputs: ['catalog.sqlite'] },
+        { name: 'runtime', directory: projectAiwgPath(cwd, 'smiths/toolsmith'), backend: 'json',
+            operation: 'RuntimeDiscovery', outputs: ['runtime.json', 'runtime-info.md'] },
+        { name: 'issues', directory: projectAiwgPath(cwd, 'issues'), backend: 'json',
+            operation: 'LocalIssueProviderCore.rebuildIssueIndex', outputs: ['index/issues.index.json'] },
+    ];
+    for (const scope of scopes) {
+        // Absent opt-in scopes are visible as unavailable; planning still respects opt-in.
+        add({ name: scope.name, group: scope.name, identity: canonical(scope.directory), backend: scope.backend,
+            operation: scope.operation, supported: true, exclusions: ['undeclared provider roots', 'auth and token files'],
+            roots: workspace => {
+                if (scope.name !== 'sessions')
+                    return [canonical(scope.directory)];
+                let config;
+                try {
+                    config = json(projectControlPath(workspace, 'aiwg.config'));
+                }
+                catch {
+                    return [];
+                }
+                const manifests = [path.join(workspace, '.aiwg/sessions/discovery-manifest.json'),
+                    ...(config?.sessions?.discovery_manifests ?? []).map(file => path.resolve(workspace, file))];
+                return [...new Set(manifests.flatMap(file => {
+                        try {
+                            const manifest = json(file);
+                            return Object.values(manifest?.authorizedRoots ?? {}).flat().map(canonical);
+                        }
+                        catch {
+                            return [];
+                        }
+                    }))];
+            }, outputPaths: scope.outputs.map(file => path.join(scope.directory, file)),
+            statePath: path.join(scope.directory, '.index', 'freshness.json') });
+    }
+    for (const name of ['models', 'datasets'])
+        add({ name, group: name,
+            identity: `${name}:${canonical(cwd)}`, backend: 'remote', operation: name === 'models'
+                ? 'resolveDynamicModelCatalog' : 'dataset owner', supported: false,
+            reason: `${name} has no local deterministic freshness probe; use its owning operation`,
+            roots: () => [], outputPaths: [], exclusions: ['remote-only owners'],
+            statePath: projectAiwgPath(cwd, '.index', `${name}-freshness.json`) });
+    return adapters;
+}
+export function selectIndexAdapters(adapters, only = 'all') {
+    if (only === 'all')
+        return adapters;
+    const selected = adapters.filter(adapter => adapter.name === only || adapter.group === only);
+    if (!selected.length && !['sessions', 'issues', 'caches'].includes(only))
+        throw new Error(`Unknown index: ${only}`);
+    return selected;
+}
+async function adapterDigest(adapter, cwd) {
+    if (adapter.group === 'graphs')
+        return graphIndexDigest(adapter.graph === 'framework' ? resolveFrameworkIndexRoot(cwd) : cwd, adapter.graph);
+    if (adapter.group === 'caches')
+        return hashFiles(['metadata.json', 'dependencies.json'].map(file => path.join(getGraphIndexDir(cwd, adapter.graph), file)), adapter.identity);
+    if (adapter.group === 'issues')
+        return hashFiles(['items', 'events', 'comments'].flatMap(dir => findArtifactFiles(projectAiwgPath(cwd, 'issues', dir), ['.md', '.json', '.jsonl'])), adapter.identity);
+    if (adapter.group === 'sessions') {
+        const { readDiscoveryManifest, discoverWorkspaceHistories } = await import('../sessions/workspace-discovery.js');
+        const config = json(projectControlPath(cwd, 'aiwg.config'));
+        const manifests = [path.join(cwd, '.aiwg/sessions/discovery-manifest.json'),
+            ...(config?.sessions?.discovery_manifests ?? []).map(file => path.resolve(cwd, file))];
+        const inputs = [];
+        for (const file of [...new Set(manifests)])
+            if (fs.existsSync(file)) {
+                const previous = await readDiscoveryManifest(file);
+                if (previous.workspaceId !== canonical(cwd))
+                    throw new Error('discovery manifest workspace mismatch');
+                const authorizedRoots = previous.authorizedRoots ?? {};
+                if (!previous.authorizedRoots)
+                    for (const source of previous.sources) {
+                        const roots = authorizedRoots[source.provider] ??= [];
+                        if (!roots.includes(source.authorizedRoot))
+                            roots.push(source.authorizedRoot);
+                    }
+                const current = await discoverWorkspaceHistories({ workspace: cwd,
+                    refreshFrom: { ...previous, authorizedRoots }, knownSources: previous.sources,
+                    exclude: config?.sessions?.import?.exclude });
+                inputs.push(current.manifestId);
+            }
+        if (!inputs.length)
+            throw new Error('no authorized discovery manifest');
+        return createHash('sha256').update(JSON.stringify([adapter.identity, inputs])).digest('hex');
+    }
+    // RuntimeDiscovery owns environmental discovery; its input receipt bounds this probe.
+    const runtime = json(adapter.outputPaths[0]);
+    if (!runtime?.inputFingerprint)
+        throw new Error('runtime input fingerprint unavailable');
+    return hashFiles([projectControlPath(cwd, 'aiwg.config')].filter(file => fs.existsSync(file)), runtime.inputFingerprint);
+}
+function outputDigest(adapter) {
+    if (!adapter.outputPaths.every(file => fs.existsSync(file)))
+        return undefined;
+    // The owner may renew stats on an unchanged build. Snapshot identity follows primary output.
+    const stat = fs.statSync(adapter.outputPaths[0], { bigint: true });
+    // Rename changes ctime during publication; inode, mtime and size survive it.
+    return createHash('sha256').update(JSON.stringify([adapter.identity, String(stat.dev), String(stat.ino),
+        String(stat.size), String(stat.mtimeNs)])).digest('hex');
+}
+/** Synchronous persisted view for existing reader callers; CLI/daemon also probe inputs. */
+export function indexFreshnessSnapshot(adapter, cwd, nowMs = Date.now(), digest) {
+    const fallback = { index: adapter.name, targetStaleAfterMs: 3_600_000,
+        maxRetriesPerDay: 3, measureConvergence: true };
+    let policy = fallback;
+    try {
+        policy = resolveFreshnessPolicy(cwd, adapter);
+        if (!adapter.supported)
+            return { name: adapter.name, status: 'unsupported', policy,
+                lastVerifiedDigest: null, lastVerifiedAt: null, dirtySince: null, dirtyAgeMs: null,
+                pendingWork: 0, lastError: null, reason: adapter.reason };
+        const state = json(adapter.statePath);
+        const outputs = outputDigest(adapter);
+        const age = state?.lastVerifiedAt ? Math.max(0, nowMs - Date.parse(state.lastVerifiedAt)) : Infinity;
+        const changed = !state || !outputs || outputs !== state.outputDigest || (digest !== undefined && state.lastVerifiedDigest !== digest);
+        const dirtySince = state?.dirtySince ?? (changed ? new Date(nowMs).toISOString()
+            : age > policy.targetStaleAfterMs ? new Date(Date.parse(state.lastVerifiedAt) + policy.targetStaleAfterMs).toISOString() : null);
+        return { name: adapter.name, policy,
+            status: !outputs ? 'unavailable' : state?.lastError ? 'degraded'
+                : changed || state?.pendingWork || age > policy.targetStaleAfterMs ? 'stale' : 'fresh',
+            lastVerifiedDigest: state?.lastVerifiedDigest ?? null, lastVerifiedAt: state?.lastVerifiedAt ?? null,
+            dirtySince, dirtyAgeMs: dirtySince ? Math.max(0, nowMs - Date.parse(dirtySince)) : null,
+            pendingWork: changed ? Math.max(1, state?.pendingWork ?? 0) : state?.pendingWork ?? 0,
+            lastError: state?.lastError ?? null, convergence: policy.measureConvergence && state?.convergence
+                ? { ...state.convergence, converged: state.convergence.residualJobs === 0
+                        && state.convergence.wallMs <= policy.targetStaleAfterMs } : undefined };
+    }
+    catch (error) {
+        return { name: adapter.name, status: 'degraded', policy, lastVerifiedDigest: null, lastVerifiedAt: null,
+            dirtySince: null, dirtyAgeMs: null, pendingWork: 1, lastError: String(error) };
+    }
+}
+export async function probeIndexAdapter(adapter, cwd, nowMs = Date.now()) {
+    const persisted = indexFreshnessSnapshot(adapter, cwd, nowMs);
+    if (!adapter.supported || persisted.status === 'unavailable')
+        return persisted;
+    try {
+        if (adapter.group === 'sessions') {
+            const { sessionRefreshAvailable } = await import('../sessions/refresh.js');
+            if (!sessionRefreshAvailable())
+                return { ...persisted, status: 'unavailable', pendingWork: 1,
+                    reason: 'sqlite unavailable' };
+        }
+        if (adapter.group === 'caches') {
+            const { getFortemiCoreSyncStatus } = await import('./fortemi-core-sync.js');
+            const cache = getFortemiCoreSyncStatus(cwd, adapter.graph);
+            if (cache.stale && !cache.sourceIndexNewer)
+                return { ...persisted, status: 'degraded',
+                    pendingWork: 1, lastError: cache.reason };
+        }
+        const digest = await adapterDigest(adapter, cwd);
+        let snapshot = indexFreshnessSnapshot(adapter, cwd, nowMs, digest);
+        // Preserve the first measured dirty observation without racing a publisher.
+        // Probe never builds or creates an absent index.
+        if (fs.existsSync(adapter.statePath)
+            && snapshot.status === 'stale' && snapshot.lastVerifiedDigest !== digest) {
+            let release;
+            try {
+                release = await acquireDirectoryLock(adapter.group === 'graphs'
+                    ? `${path.dirname(adapter.statePath)}.build.lock` : path.join(getUserStateDir(), 'index-refresh.lock'), { timeoutMs: 0 });
+                const state = json(adapter.statePath);
+                if (state && !state.dirtySince && state.lastVerifiedDigest !== digest) {
+                    writeIndexFile(cwd, path.basename(adapter.statePath), { ...state,
+                        dirtySince: new Date(nowMs).toISOString(), pendingWork: 1 }, path.dirname(adapter.statePath));
+                }
+                snapshot = indexFreshnessSnapshot(adapter, cwd, nowMs, digest);
+            }
+            catch (error) {
+                if (!(error instanceof DirectoryLockContentionError))
+                    throw error;
+            }
+            finally {
+                await release?.();
+            }
+        }
+        return snapshot;
+    }
+    catch (error) {
+        return { ...indexFreshnessSnapshot(adapter, cwd, nowMs), status: 'degraded',
+            pendingWork: 1, lastError: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function indexAdapterDigest(adapter, cwd) {
+    if (!adapter.supported)
+        return undefined;
+    return adapterDigest(adapter, cwd);
+}
+/** Call under the existing owner lock; failure never advances verification. */
+export function recordIndexVerification(adapter, cwd, opts, publicationDir) {
+    const now = opts.nowMs ?? Date.now();
+    let prior;
+    try {
+        prior = json(adapter.statePath);
+    }
+    catch { /* Replace corrupt receipt, never the snapshot. */ }
+    const complete = !opts.error && !!opts.before && opts.before === opts.after && !opts.pendingWork;
+    const policy = resolveFreshnessPolicy(cwd, adapter);
+    const state = { lastVerifiedDigest: complete ? opts.after : prior?.lastVerifiedDigest ?? null,
+        lastVerifiedAt: complete ? new Date(now).toISOString() : prior?.lastVerifiedAt ?? null,
+        dirtySince: complete ? null : prior?.dirtySince ?? new Date(now).toISOString(),
+        pendingWork: complete ? 0 : Math.max(1, opts.pendingWork ?? 0), lastError: opts.error ?? null,
+        outputDigest: complete ? outputDigest(publicationDir ? { ...adapter, outputPaths: adapter.outputPaths.map(file => fs.existsSync(path.join(publicationDir, path.basename(file))) ? path.join(publicationDir, path.basename(file)) : file) } : adapter) : prior?.outputDigest,
+        ...(policy.measureConvergence ? { convergence: { converged: complete && opts.wallMs <= policy.targetStaleAfterMs,
+                wallMs: opts.wallMs, residualJobs: complete ? 0 : Math.max(1, opts.pendingWork ?? 0) } } : {}) };
+    writeIndexFile(cwd, path.basename(adapter.statePath), state, publicationDir ?? path.dirname(adapter.statePath));
+    return indexFreshnessSnapshot(adapter, cwd, now, opts.after);
+}
+//# sourceMappingURL=index-adapters.js.map