weavatrix 0.3.13 → 1.0.0

package/src/mcp/actions/graph-lifecycle.mjs

@@ -1,148 +0,0 @@
-import {existsSync, readFileSync, realpathSync, statSync, writeFileSync} from 'node:fs'
-import {dirname, isAbsolute, join} from 'node:path'
-import {diffGraphs, formatGraphDiff, prevGraphPathFor} from '../graph-context.mjs'
-import {buildGraphForRepo, defaultPrecisionMode, precisionStatusLine} from '../../build-graph.js'
-import {graphHomeDir, graphOutDirForModule, graphOutDirForRepo} from '../../graph/layout.js'
-import {liveRepositoryRecords, registerRepository} from '../../graph/repo-registry.js'
-import {precisionSemanticInputsMatch, readPrecisionOverlay} from '../../precision/lsp-overlay.js'
-
-export async function tRebuildGraph(g, args, ctx) {
-    if (!ctx.repoRoot) return 'Rebuild needs the repo root (not provided to this server).'
-    const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode)
-        ? args.mode
-        : ['no-tests', 'tests-only', 'full'].includes(g?.graphBuildMode) ? g.graphBuildMode : 'full'
-    const precision = args.precision === 'off' ? 'off' : args.precision === 'lsp' ? 'lsp' : (g?.graphPrecisionMode || defaultPrecisionMode())
-    const scope = String(args.scope || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '')
-    if (scope) {
-        const scopedDir = graphOutDirForModule(ctx.repoRoot, scope)
-        const scoped = await buildGraphForRepo(ctx.repoRoot, {mode, scope, precision, outDir: scopedDir})
-        if (!scoped || !scoped.ok) return `Scoped graph build failed: ${(scoped && scoped.error) || 'unknown error'}`
-        return [
-            `Built an isolated scoped graph for ${scope} (${mode}). ${scoped.log || ''}.`,
-            `The active full-repository graph was not replaced, so this operation cannot report a false full→scope structural delta.`,
-            `Scoped graph: ${join(scopedDir, 'graph.json')}`,
-        ].join('\n')
-    }
-    // snapshot the outgoing state: bytes → graph.prev.json (for graph_diff later), struct → inline delta
-    let prevBytes = null
-    try { prevBytes = readFileSync(ctx.graphPath) } catch { /* first build — nothing to diff against */ }
-    let before = null
-    try { before = prevBytes ? JSON.parse(prevBytes.toString('utf8')) : null } catch { before = null }
-    const res = await buildGraphForRepo(ctx.repoRoot, {mode, scope: '', precision, outDir: ctx.graphPath ? dirname(ctx.graphPath) : undefined})
-    if (!res || !res.ok) return `Graph rebuild failed: ${(res && res.error) || 'unknown error'}`
-    if (prevBytes) { try { writeFileSync(prevGraphPathFor(ctx.graphPath), prevBytes) } catch { /* snapshot is best-effort */ } }
-    const fresh = ctx.reload() // refresh THIS server's in-memory graph so subsequent tool calls see the new graph
-    let afterStatic = null
-    try { afterStatic = JSON.parse(readFileSync(ctx.graphPath, 'utf8')) } catch { /* reload already reports the failure */ }
-    const beforeMode = ['full', 'no-tests', 'tests-only'].includes(before?.graphBuildMode) ? before.graphBuildMode : 'full'
-    const afterMode = ['full', 'no-tests', 'tests-only'].includes(afterStatic?.graphBuildMode) ? afterStatic.graphBuildMode : 'full'
-    const delta = before && afterStatic
-        ? beforeMode === afterMode
-            ? formatGraphDiff(diffGraphs(before, afterStatic))
-            : `Structural delta not computed: build mode changed from ${beforeMode} to ${afterMode}, so the node/edge universes are not comparable.`
-        : null
-    return [
-        `Rebuilt the graph (${mode}). ${res.log || ''}. In-memory graph reloaded — graph tools now reflect it.`,
-        delta
-    ].filter(Boolean).join('\n\n')
-}
-
-// Retarget this server at ANOTHER local repository at runtime — one weavatrix registration serves any
-// repo. Loads <parent>/weavatrix-graphs/<name>/graph.json (the central layout graphs
-// always live in), building it first when missing. On a failed load the previous repo stays active.
-export async function tOpenRepo(g, args, ctx) {
-
-    const requestedPath = String(args.path || '').trim()
-    if (!requestedPath) return 'Provide "path" — an absolute path to a local repository folder.'
-    if (!isAbsolute(requestedPath)) return 'open_repo requires an absolute repository path.'
-    let repoPath
-    try { repoPath = realpathSync.native(requestedPath) } catch { return `Path not found: ${requestedPath}` }
-    try { if (!statSync(repoPath).isDirectory()) return `Not a directory: ${requestedPath}` } catch { return `Path not found: ${requestedPath}` }
-    if (!existsSync(join(repoPath, '.git'))) return `Not a Git repository: ${requestedPath}`
-    const graphPath = join(graphOutDirForRepo(repoPath), 'graph.json')
-    const graphExists = existsSync(graphPath)
-    const requestedMode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : null
-    const requestedPrecision = ['lsp', 'off'].includes(args.precision) ? args.precision : null
-    let built = false
-    let upgrade = false
-    let schemaUpgrade = false
-    let precisionUpgrade = false
-    let savedMode = 'full'
-    let savedPrecision = defaultPrecisionMode()
-    if (graphExists) {
-        try {
-            const saved = JSON.parse(readFileSync(graphPath, 'utf8'))
-            savedMode = ['no-tests', 'tests-only', 'full'].includes(saved.graphBuildMode) ? saved.graphBuildMode : 'full'
-            savedPrecision = ['lsp', 'off'].includes(saved.graphPrecisionMode) ? saved.graphPrecisionMode : defaultPrecisionMode()
-            schemaUpgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
-                || !Number.isInteger(saved.edgeProvenanceV) || saved.edgeProvenanceV < 1
-                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 7
-                || !Number.isInteger(saved.reExportOccurrencesV) || saved.reExportOccurrencesV < 1
-                || !Number.isInteger(saved.symbolSpacesV) || saved.symbolSpacesV < 1
-                || !Number.isInteger(saved.physicalFileLocV) || saved.physicalFileLocV < 1
-            if (savedPrecision === 'lsp') {
-                const overlay = readPrecisionOverlay(graphPath, saved)
-                precisionUpgrade = !overlay || (typeof overlay.semanticInputFingerprint === 'string'
-                    && !precisionSemanticInputsMatch(overlay, repoPath, saved))
-            }
-            upgrade = schemaUpgrade || precisionUpgrade
-        } catch {
-            upgrade = true
-        }
-    }
-    const modeMismatch = graphExists && requestedMode != null && requestedMode !== savedMode
-    const precisionMismatch = graphExists && requestedPrecision != null && requestedPrecision !== savedPrecision
-    if (!graphExists || upgrade || modeMismatch || precisionMismatch) {
-        if (args.build === false) {
-            if (modeMismatch && !upgrade) {
-                return `The existing graph for ${repoPath} was built in ${savedMode}, but ${requestedMode} was requested. Re-call without build:false to rebuild it before switching.`
-            }
-            if (precisionMismatch && !upgrade) {
-                return `The existing graph for ${repoPath} uses semantic precision ${savedPrecision}, but ${requestedPrecision} was requested. Re-call without build:false to rebuild it before switching.`
-            }
-            return upgrade
-                ? precisionUpgrade && !schemaUpgrade
-                    ? `The existing graph for ${repoPath} lacks current revision-matched semantic precision evidence. Re-call without build:false to refresh it before switching.`
-                    : `The existing graph for ${repoPath} predates current graph metadata (typed edges, provenance, or physical file LOC). Re-call without build:false to upgrade it before switching.`
-                : `No graph yet for ${repoPath} (expected at ${graphPath}). Re-call without build:false to build one — large repos can take minutes.`
-        }
-        const mode = requestedMode || (graphExists ? savedMode : 'full')
-        const precision = requestedPrecision || (graphExists ? savedPrecision : defaultPrecisionMode())
-        const res = await buildGraphForRepo(repoPath, {mode, scope: '', precision})
-        if (!res || !res.ok) return `Graph build failed for ${repoPath}: ${(res && res.error) || 'unknown error'}`
-        built = true
-    }
-    const prev = {graphPath: ctx.graphPath, repoRoot: ctx.repoRoot}
-    ctx.graphPath = graphPath
-    ctx.repoRoot = repoPath
-    const loaded = ctx.reload()
-    if (!loaded) {
-        ctx.graphPath = prev.graphPath
-        ctx.repoRoot = prev.repoRoot
-        ctx.reload()
-        return `Failed to load ${graphPath} — still targeting the previous repo (${prev.repoRoot || 'none'}).`
-    }
-    registerRepository({repoPath, graphDir: graphOutDirForRepo(repoPath), graphHome: graphHomeDir()})
-    const buildNote = built ? (upgrade ? ' (graph upgraded to current edge/precision metadata)' : modeMismatch ? ' (graph rebuilt in the requested mode)' : precisionMismatch ? ' (semantic precision mode updated)' : ' (graph built fresh)') : ''
-    return [
-        `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`,
-        `Graph: ${graphPath}`,
-        `Build mode: ${loaded.graphBuildMode || 'full'}`,
-        precisionStatusLine(loaded.precision),
-    ].join('\n')
-}
-
-// Sibling repos that already have a built graph in the central weavatrix-graphs folder — open_repo candidates.
-export function tListKnownRepos(g, args, ctx) {
-    const root = graphHomeDir()
-    const norm = (p) => String(p).replace(/[\\/]+/g, '/').toLowerCase()
-    const rows = liveRepositoryRecords(root).map((record) => ({
-        ...record,
-        builtAt: statSync(join(record.graphDir, 'graph.json')).mtime.toISOString(),
-    }))
-    if (!rows.length) return `No registered graphs under ${root}. Build a repository once with open_repo or rebuild_graph.`
-    return [
-        `Known repositories (${rows.length}) in ${root}:`,
-        ...rows.map((r) => `  ${norm(r.repoPath) === norm(ctx.repoRoot) ? '»' : ' '} ${r.label} [${r.repositoryId}] — graph built ${r.builtAt}  (${r.repoPath})`),
-    ].join('\n')
-}

package/src/mcp/architecture-bootstrap.mjs

@@ -1,168 +0,0 @@
-// Explicit two-step local architecture bootstrap. Preview is pure; approval writes only the exact
-// previewed contract with a short-lived one-time token and never overwrites an active policy.
-import {createHash, randomBytes} from 'node:crypto'
-import {existsSync, mkdirSync, writeFileSync} from 'node:fs'
-import {join} from 'node:path'
-import {
-    loadArchitectureContract, normalizeArchitectureContract, verifyArchitecture,
-} from '../analysis/architecture-contract.js'
-import {createRepoBoundary} from '../repo-path.js'
-import {detectRepoStack} from '../scan/discover.js'
-import {toolResult} from './tool-result.mjs'
-
-const version = new URL(import.meta.url).search
-const starter = await import(new URL(`./architecture-starter.mjs${version}`, import.meta.url).href)
-const {createArchitectureStarter, proposeObservedDependencyDirections} = starter
-
-const PREVIEW_TTL_MS = 5 * 60_000
-const previews = new Map()
-
-const stackIds = (repoRoot) => {
-    try {
-        const stack = detectRepoStack(repoRoot)
-        return ['languages', 'runtimes', 'tests', 'infra', 'deploy']
-            .flatMap((category) => Array.isArray(stack?.[category]) ? stack[category] : [])
-            .map((item) => String(item?.id || '')).filter(Boolean)
-    } catch { return [] }
-}
-const sha256 = (value) => createHash('sha256').update(value).digest('hex')
-
-function currentFingerprints(verification) {
-    return [...verification.new, ...verification.existing]
-        .map((item) => item.fingerprint).sort((a, b) => a.localeCompare(b))
-}
-
-function baselineMetrics(verification) {
-    return Object.fromEntries(['runtimeCycles', 'violations', 'componentDependencies', 'mappedComponents']
-        .map((key) => [key, verification.metrics?.[key]])
-        .filter(([, value]) => Number.isFinite(value)))
-}
-
-function materializeCandidate(candidate, verification, baselineMode) {
-    if (baselineMode !== 'accept-current') return normalizeArchitectureContract(candidate)
-    return normalizeArchitectureContract({
-        ...candidate,
-        ratchet: {baseline: {
-            fingerprints: currentFingerprints(verification),
-            metrics: baselineMetrics(verification),
-        }},
-    })
-}
-
-export function activeArchitectureContract(ctx) {
-    if (!ctx?.repoRoot) return {contract: null, source: null, error: 'no repository root is active'}
-    return loadArchitectureContract(ctx.repoRoot, ctx.graphPath)
-}
-
-function preview(g, args, ctx) {
-    const active = activeArchitectureContract(ctx)
-    if (active.contract) return toolResult(
-        `Architecture bootstrap refused: an active contract already exists at ${active.source}.`,
-        {state: 'ALREADY_CONFIGURED', source: active.source, contractHash: active.contract.contractHash},
-    )
-    if (active.error) return toolResult(
-        `Architecture bootstrap refused: ${active.source || 'contract'} is invalid (${active.error}).`,
-        {state: 'ERROR', source: active.source, error: active.error},
-    )
-    const baselineMode = args?.baseline_mode === 'accept-current' ? 'accept-current' : 'none'
-    let candidate, starterProposal = null
-    try {
-        starterProposal = args?.candidate_contract ? null : createArchitectureStarter(g, ctx?.repoRoot)
-        candidate = args?.candidate_contract
-            ? normalizeArchitectureContract(args.candidate_contract)
-            : starterProposal.contract
-    } catch (error) {
-        return toolResult(`Candidate architecture contract is invalid: ${error.message}`, {state: 'INVALID', error: error.message})
-    }
-    const technologies = stackIds(ctx?.repoRoot)
-    const candidateVerification = verifyArchitecture({graph: g, contract: candidate, technologies})
-    const materializedContract = materializeCandidate(candidate, candidateVerification, baselineMode)
-    const materializedVerification = verifyArchitecture({graph: g, contract: materializedContract, technologies})
-    const contents = `${JSON.stringify(materializedContract, null, 2)}\n`
-    const contentHash = sha256(contents)
-    const token = randomBytes(12).toString('hex')
-    const expiresAt = new Date(Date.now() + PREVIEW_TTL_MS).toISOString()
-    previews.set(token, {
-        repoRoot: String(ctx?.repoRoot || ''), graphPath: String(ctx?.graphPath || ''),
-        contract: materializedContract, contents, contentHash,
-        verificationHash: materializedVerification.verificationHash,
-        expiresAt: Date.parse(expiresAt),
-    })
-    return toolResult([
-        `Architecture bootstrap PREVIEW only; no file was written. Candidate verification: ${candidateVerification.status}.`,
-        baselineMode === 'accept-current'
-            ? `Explicit accept-current baseline would record ${currentFingerprints(candidateVerification).length} current finding fingerprint(s).`
-            : 'No current findings were added to the baseline.',
-        `Review the materialized contract and then approve with confirm_token "${token}" before ${expiresAt}.`,
-    ].join('\n'), {
-        state: 'PREVIEW', wrote: false, baselineMode,
-        candidateVerification, materializedVerification, materializedContract,
-        observedDependencyProposals: proposeObservedDependencyDirections(g, materializedContract.components),
-        budgetProposals: starterProposal?.budgetProposals || [],
-        starterMethodology: starterProposal?.methodology,
-        patch: {operation: 'create', path: '.weavatrix/architecture.json', contentHash, contents},
-        confirmToken: token, expiresAt,
-    })
-}
-
-function approve(g, args, ctx) {
-    const token = String(args?.confirm_token || '')
-    const pending = previews.get(token)
-    if (!pending) return toolResult(
-        'Architecture approval refused: run a fresh preview and provide its exact confirm_token.',
-        {state: 'CONFIRMATION_REQUIRED', wrote: false},
-    )
-    previews.delete(token)
-    if (pending.expiresAt < Date.now()) return toolResult(
-        'Architecture approval refused: the preview expired; run preview again.',
-        {state: 'PREVIEW_EXPIRED', wrote: false},
-    )
-    if (pending.repoRoot !== String(ctx?.repoRoot || '') || pending.graphPath !== String(ctx?.graphPath || '')) {
-        return toolResult('Architecture approval refused: the active repository changed after preview.', {
-            state: 'REPOSITORY_CHANGED', wrote: false,
-        })
-    }
-    const active = activeArchitectureContract(ctx)
-    if (active.contract || active.error) return toolResult(
-        `Architecture approval refused: ${active.source || 'a contract'} appeared or changed after preview.`,
-        {state: active.error ? 'ERROR' : 'ALREADY_CONFIGURED', wrote: false, source: active.source, error: active.error || undefined},
-    )
-    const verification = verifyArchitecture({
-        graph: g, contract: pending.contract, technologies: stackIds(ctx?.repoRoot),
-    })
-    if (verification.verificationHash !== pending.verificationHash) return toolResult(
-        'Architecture approval refused: graph evidence changed after preview; review a fresh preview.',
-        {state: 'GRAPH_CHANGED', wrote: false, previewVerificationHash: pending.verificationHash, currentVerificationHash: verification.verificationHash},
-    )
-    const boundary = createRepoBoundary(ctx?.repoRoot)
-    if (!boundary.root) return toolResult('Architecture approval refused: the repository boundary is unavailable.', {
-        state: 'PATH_REFUSED', wrote: false,
-    })
-    try { mkdirSync(join(boundary.root, '.weavatrix'), {recursive: true}) }
-    catch (error) { return toolResult(`Architecture approval could not create its policy directory: ${error.message}`, {
-        state: 'WRITE_FAILED', wrote: false, error: error.message,
-    }) }
-    const policyDirectory = boundary.resolve('.weavatrix')
-    if (!policyDirectory.ok) return toolResult('Architecture approval refused: the policy directory resolves outside the active repository.', {
-        state: 'PATH_REFUSED', wrote: false,
-    })
-    const targetPath = join(policyDirectory.path, 'architecture.json')
-    if (existsSync(targetPath)) return toolResult('Architecture approval refused: the target contract already exists.', {
-        state: 'ALREADY_CONFIGURED', wrote: false, source: '.weavatrix/architecture.json',
-    })
-    try {
-        writeFileSync(targetPath, pending.contents, {encoding: 'utf8', flag: 'wx'})
-    } catch (error) {
-        return toolResult(`Architecture approval failed without overwriting policy: ${error.message}`, {
-            state: 'WRITE_FAILED', wrote: false, error: error.message,
-        })
-    }
-    return toolResult(
-        `Architecture contract approved and created at .weavatrix/architecture.json (${pending.contentHash.slice(0, 12)}).`,
-        {state: 'APPROVED', wrote: true, source: '.weavatrix/architecture.json', contentHash: pending.contentHash, contract: pending.contract, verification},
-    )
-}
-
-export function tBootstrapArchitecture(g, args = {}, ctx) {
-    return args.action === 'approve' ? approve(g, args, ctx) : preview(g, args, ctx)
-}

package/src/mcp/architecture-starter.mjs

@@ -1,234 +0,0 @@
-// Adaptive, source-free architecture starter. It proposes component territories and separately
-// reports observed dependency directions; observations never become enforceable policy implicitly.
-import {normalizeArchitectureContract} from '../analysis/architecture-contract.js'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-
-export const PROVISIONAL_BUDGETS = Object.freeze({
-    runtimeCycles: 0,
-    maxFileLoc: 300,
-    maxFunctionLoc: 120,
-    maxCyclomatic: 15,
-    maxModuleFiles: 80,
-    minModuleCohesion: .5,
-    maxModuleBoundaryRatio: .65,
-})
-
-const STARTER_BUDGETS = Object.freeze({
-    runtimeCycles: PROVISIONAL_BUDGETS.runtimeCycles,
-    maxFileLoc: PROVISIONAL_BUDGETS.maxFileLoc,
-})
-
-const BUDGET_PROPOSALS = Object.freeze(Object.entries(PROVISIONAL_BUDGETS)
-    .filter(([key]) => !(key in STARTER_BUDGETS))
-    .map(([key, value]) => ({
-        key, value, state: 'CANDIDATE_NOT_ENFORCED',
-        reason: 'Generic review threshold; adopt only after inspecting repository-specific evidence.',
-    })))
-
-const SOURCE_ROOTS = new Set(['src', 'app', 'lib', 'packages', 'services'])
-const CODE_EXTENSIONS = new Set([
-    '.cjs', '.cs', '.css', '.go', '.htm', '.html', '.java', '.js', '.jsx', '.less', '.mjs', '.py', '.pyi',
-    '.rs', '.scss', '.sol', '.sql', '.ts', '.tsx',
-])
-const CLASSIFIED = ['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
-const EDGE_RELATIONS = new Set(['imports', 're_exports', 'calls', 'references'])
-
-const slash = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')
-const extension = (file) => {
-    const name = slash(file).split('/').at(-1) || ''
-    const dot = name.lastIndexOf('.')
-    return dot >= 0 ? name.slice(dot).toLowerCase() : ''
-}
-const safeId = (value, fallback) => String(value || '').toLowerCase()
-    .replace(/[^a-z0-9._:-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 100) || fallback
-
-function productFiles(graph, repoRoot) {
-    const classifier = createPathClassifier(repoRoot)
-    return [...new Set((graph?.nodes || [])
-        .filter((node) => !String(node.id).includes('#'))
-        .map((node) => slash(node.source_file || node.id))
-        .filter((file) => file && CODE_EXTENSIONS.has(extension(file))))]
-        .filter((file) => {
-            const explanation = classifier.explain(file)
-            return !explanation.excluded && !hasPathClass(explanation, ...CLASSIFIED)
-        })
-        .sort((a, b) => a.localeCompare(b))
-}
-
-function commonDirectoryPrefix(entries) {
-    if (!entries.length) return []
-    const first = entries[0].directories
-    let length = first.length
-    for (const entry of entries.slice(1)) {
-        let index = 0
-        while (index < length && index < entry.directories.length && first[index] === entry.directories[index]) index++
-        length = index
-    }
-    // Keep at least one package segment available as an actual component territory.
-    const shortest = Math.min(...entries.map((entry) => entry.directories.length))
-    return first.slice(0, Math.min(length, Math.max(0, shortest - 1)))
-}
-
-function javaTerritories(files) {
-    const byRoot = new Map()
-    for (const file of files) {
-        const match = /^(.*?)(?:\/)?src\/main\/java\/(.+\.java)$/i.exec(file)
-        if (!match) continue
-        const root = `${match[1] ? `${match[1]}/` : ''}src/main/java`
-        const tail = match[2].split('/')
-        const entry = {file, root, directories: tail.slice(0, -1)}
-        const entries = byRoot.get(root) || []
-        entries.push(entry)
-        byRoot.set(root, entries)
-    }
-    const paths = new Map()
-    for (const [root, entries] of byRoot) {
-        const common = commonDirectoryPrefix(entries)
-        for (const entry of entries) {
-            const next = entry.directories[common.length]
-            const path = next ? `${root}/${[...common, next].join('/')}` : entry.file
-            paths.set(entry.file, {key: path, name: path, path})
-        }
-    }
-    let refined = true
-    while (refined) {
-        refined = false
-        const groups = new Map()
-        for (const [file, territory] of paths) {
-            const entries = groups.get(territory.key) || []
-            entries.push({file, territory})
-            groups.set(territory.key, entries)
-        }
-        for (const entries of groups.values()) {
-            if (entries.length <= PROVISIONAL_BUDGETS.maxModuleFiles) continue
-            const base = entries[0].territory.path
-            if (!entries.every((entry) => entry.territory.path === base)) continue
-            const nested = entries.map((entry) => ({...entry, rest: entry.file.slice(base.length + 1).split('/')}))
-            const childDirectories = new Set(nested.filter((entry) => entry.rest.length > 1).map((entry) => entry.rest[0]))
-            if (childDirectories.size < 2) continue
-            for (const entry of nested) {
-                if (entry.rest.length > 1) {
-                    const path = `${base}/${entry.rest[0]}`
-                    paths.set(entry.file, {key: path, name: path, path})
-                } else {
-                    paths.set(entry.file, {key: `${base}::root`, name: `${base} (root files)`, path: entry.file})
-                }
-            }
-            refined = true
-        }
-    }
-    return paths
-}
-
-function nestedSourceTerritory(file) {
-    const match = /^(.*?)\/src\/(.+)$/.exec(file)
-    if (!match || !match[1]) return null
-    const tail = match[2].split('/')
-    // Java's src/main/java package tree is handled with a package-aware common prefix above.
-    if (tail[0] === 'main' && tail[1] === 'java') return null
-    return tail.length > 1 ? `${match[1]}/src/${tail[0]}` : file
-}
-
-function genericTerritory(file) {
-    const parts = file.split('/').filter(Boolean)
-    if (parts.length === 1) return {key: 'root-code', name: 'root code', path: file}
-    if (SOURCE_ROOTS.has(parts[0]) && parts.length === 2) {
-        return {key: `${parts[0]}-root`, name: `${parts[0]} (root files)`, path: file}
-    }
-    const path = parts.slice(0, SOURCE_ROOTS.has(parts[0]) ? 2 : 1).join('/')
-    return {key: path, name: path, path}
-}
-
-function componentsFor(graph, repoRoot) {
-    const files = productFiles(graph, repoRoot)
-    const java = javaTerritories(files)
-    const groups = new Map()
-    for (const file of files) {
-        const adaptive = java.get(file) || nestedSourceTerritory(file)
-        const territory = adaptive
-            ? typeof adaptive === 'string' ? {key: adaptive, name: adaptive, path: adaptive} : adaptive
-            : genericTerritory(file)
-        const group = groups.get(territory.key) || {name: territory.name, paths: new Set(), files: 0}
-        group.paths.add(territory.path)
-        group.files++
-        groups.set(territory.key, group)
-    }
-    return [...groups]
-        .sort((a, b) => b[1].files - a[1].files || a[0].localeCompare(b[0]))
-        .slice(0, 200)
-        .map(([key, group], index) => ({
-            id: safeId(key, `component-${index + 1}`),
-            name: group.name,
-            paths: [...group.paths].sort((a, b) => a.localeCompare(b)),
-        }))
-}
-
-function componentFor(file, components) {
-    const normalized = slash(file)
-    let best = null
-    for (const component of components) for (const prefix of component.paths) {
-        if (normalized !== prefix && !normalized.startsWith(`${prefix}/`)) continue
-        if (!best || prefix.length > best.prefix.length) best = {id: component.id, prefix}
-    }
-    return best?.id || null
-}
-
-const endpoint = (value) => value && typeof value === 'object' ? String(value.id) : String(value || '')
-function fileOf(id, byId) {
-    const node = byId.get(id)
-    return slash(node?.source_file || id.split('#')[0])
-}
-function edgeKind(link) {
-    return link.typeOnly === true ? 'type-only' : link.compileOnly === true ? 'compile-only' : 'runtime'
-}
-
-function observedDirections(graph, components) {
-    const byId = new Map((graph?.nodes || []).map((node) => [String(node.id), node]))
-    const pairs = new Set(), directions = new Map()
-    for (const link of graph?.links || []) {
-        if (!EDGE_RELATIONS.has(link.relation) || link.barrelProxy === true) continue
-        const fromFile = fileOf(endpoint(link.source), byId), toFile = fileOf(endpoint(link.target), byId)
-        const from = componentFor(fromFile, components), to = componentFor(toFile, components)
-        if (!from || !to || from === to) continue
-        const kind = edgeKind(link), pair = `${fromFile}\0${toFile}\0${kind}`
-        if (pairs.has(pair)) continue
-        pairs.add(pair)
-        const key = `${from}\0${to}\0${kind}`
-        const item = directions.get(key) || {from, to, kind, count: 0, samples: []}
-        item.count++
-        if (item.samples.length < 3) item.samples.push(`${fromFile} -> ${toFile}`)
-        directions.set(key, item)
-    }
-    return [...directions.values()]
-        .sort((a, b) => b.count - a.count || a.from.localeCompare(b.from) || a.to.localeCompare(b.to))
-        .slice(0, 100)
-        .map((item, index) => ({
-            ...item,
-            state: 'OBSERVED_NOT_ENFORCED',
-            suggestedRule: {
-                id: safeId(`observed-${item.from}-to-${item.to}-${item.kind}`, `observed-${index + 1}`),
-                action: 'allow', kinds: [item.kind], from: [item.from], to: [item.to],
-                reason: `Observed in ${item.count} unique file dependency pair(s); review before adopting as policy.`,
-            },
-        }))
-}
-
-export function proposeObservedDependencyDirections(graph, components) {
-    return observedDirections(graph, components)
-}
-
-export function createArchitectureStarter(graph, repoRoot) {
-    const components = componentsFor(graph, repoRoot)
-    const contract = normalizeArchitectureContract({
-        name: 'Proposed no-regressions baseline', style: 'custom', enforcement: 'ratchet', components,
-        dependencyRules: [], budgets: STARTER_BUDGETS,
-        technologies: {required: [], forbidden: []}, exceptions: [],
-        ratchet: {baseline: {fingerprints: [], metrics: {}}},
-    })
-    return {
-        contract,
-        observedDependencyProposals: proposeObservedDependencyDirections(graph, contract.components),
-        budgetProposals: BUDGET_PROPOSALS,
-        methodology: 'adaptive product territories; only universal runtime-cycle/file-size guards are active; observed directions and generic quality thresholds are review-only',
-    }
-}