renma 0.18.0 → 0.18.2

package/dist/commands/suggest-metadata.js

@@ -1,8 +1,12 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
+import { buildSkillParentIndex, resolveSkillSupportParent, withResolvedSkillParent, } from "../catalog.js";
+import { renmaCommand } from "../command-invocation.js";
 import { parseDocument } from "../markdown.js";
 import { parseAssetMetadata } from "../metadata.js";
-import { classifyAbsoluteSkillEntrypointPath, classifyRepositorySkillEntrypointPath, } from "../discovery.js";
+import { collectRepositorySnapshot } from "../repository-evidence.js";
+import { collectSecurityPolicyAssetEvidence } from "../security-policy-inventory.js";
+import { classifyAssetPath, classifyRepositorySkillEntrypointPath, repositoryClassificationPath, } from "../discovery.js";
 import { buildAgentSkillMigrationSuggestion, } from "../skill-migration.js";
 export class SuggestMetadataTargetError extends Error {
     constructor(target, cause) {
@@ -28,10 +32,20 @@ export async function buildMetadataSuggestion(target, options = {}) {
         throw new SuggestMetadataTargetError(target, error);
     }
     const outputPath = toPosix(target);
-    const entrypoint = classifySuggestionSkillEntrypointPath(outputPath);
-    const initialKind = classifyPath(outputPath, entrypoint);
+    const classificationContext = repositoryClassificationPath(target);
+    const classificationPath = classificationContext.state === "resolved"
+        ? classificationContext.relativePath
+        : "";
+    const repositoryRoot = classificationContext.state === "resolved"
+        ? classificationContext.root
+        : undefined;
+    const entrypoint = classificationPath
+        ? classifyRepositorySkillEntrypointPath(classificationPath)
+        : undefined;
+    const initialClassification = classifyAssetPath(classificationPath);
+    const initialKind = initialClassification.kind;
     const document = parseDocument({
-        path: outputPath,
+        path: classificationPath || outputPath,
         absolutePath,
         kind: initialKind,
         sizeBytes: Buffer.byteLength(content),
@@ -40,28 +54,35 @@ export async function buildMetadataSuggestion(target, options = {}) {
         content,
     });
     const { metadata } = parseAssetMetadata(document);
-    const kind = initialKind === "context" && metadata.type === "context_lens"
-        ? "context_lens"
-        : initialKind;
+    let classification = classifyAssetPath(classificationPath, {
+        ...(metadata.type ? { metadataType: metadata.type } : {}),
+    });
+    const kind = classification.kind;
     const explicitOwner = optionalText(options.owner);
     if (kind === "skill") {
-        const collisionBlock = entrypoint
-            ? await pathMigrationCollision(entrypoint, absolutePath)
+        const collisionBlock = entrypoint && repositoryRoot
+            ? await pathMigrationCollision(entrypoint, absolutePath, repositoryRoot)
             : undefined;
         const agentSkills = buildAgentSkillMigrationSuggestion(document, {
             ...(explicitOwner ? { explicitOwner } : {}),
             ...(entrypoint ? { entrypoint } : {}),
             ...(collisionBlock ? { additionalBlocks: [collisionBlock] } : {}),
         });
-        const metadataRetrofit = agentSkills.proposalKind === "canonical-metadata-retrofit";
         const noMigrationProposed = agentSkills.proposalKind === "none" &&
             agentSkills.sourceFormat === "agent-skills";
+        const metadataRetrofit = agentSkills.proposalKind === "canonical-metadata-retrofit";
+        const decision = skillDecision(agentSkills);
         return {
             path: outputPath,
             kind,
-            suggestedMode: metadataRetrofit
-                ? "agent-skills-metadata-retrofit"
-                : "agent-skills-migration",
+            suggestedMode: noMigrationProposed
+                ? "no-proposal"
+                : metadataRetrofit
+                    ? "agent-skills-metadata-retrofit"
+                    : "agent-skills-migration",
+            decisionStatus: decision.status,
+            decision: decision.decision,
+            classification,
             ownerProvided: Boolean(explicitOwner),
             instructions: noMigrationProposed
                 ? [
@@ -93,6 +114,7 @@ export async function buildMetadataSuggestion(target, options = {}) {
                     ],
             candidateMetadata: {},
             blockedMetadata: agentSkills.blocked,
+            nextActions: suggestionNextActions(outputPath, classification, repositoryRoot),
             agentSkills,
         };
     }
@@ -100,8 +122,120 @@ export async function buildMetadataSuggestion(target, options = {}) {
     const existingTitle = optionalText(metadataValueText(document.metadata.title));
     const existingOwner = optionalText(metadata.owner);
     const candidateMetadata = {};
-    const candidateId = inferCandidateId(kind, outputPath);
+    const candidateId = inferCandidateId(kind, classificationPath);
     const candidateTitle = mainHeadingTitle(document.headings);
+    if (classification.scope === "skill-local") {
+        const localContext = await resolveSkillLocalContext(classification, classificationPath, classificationContext.state === "resolved"
+            ? classificationContext.root
+            : undefined);
+        classification = localContext.classification;
+        if (localContext.parent.state !== "resolved") {
+            const parentState = localContext.parent.state === "not-applicable"
+                ? "structural-candidate"
+                : localContext.parent.state;
+            const blockedMetadata = [
+                {
+                    field: "parent_skill",
+                    reason: `The structural parent Skill is ${parentState}; inheritance is not established. Review the repository layout before adding local metadata.`,
+                },
+            ];
+            return {
+                path: outputPath,
+                kind,
+                suggestedMode: "no-proposal",
+                decisionStatus: "blocked",
+                decision: {
+                    reasonCode: "skill-local-parent-unresolved",
+                    summary: "Renma cannot confirm one parent Skill, so it cannot claim inherited governance or safely propose an independent local override.",
+                    question: "Resolve the missing or ambiguous parent Skill layout, then rerun this command.",
+                },
+                classification,
+                ownerProvided: Boolean(explicitOwner),
+                instructions: skillLocalInstructions(classification, false, true, false),
+                candidateMetadata: {},
+                blockedMetadata,
+                nextActions: suggestionNextActions(outputPath, classification, repositoryRoot),
+            };
+        }
+        const blockedMetadata = conflictingOwnerEvidence(existingOwner, explicitOwner);
+        if (!existingOwner && explicitOwner)
+            candidateMetadata.owner = explicitOwner;
+        const hasOverride = Object.keys(candidateMetadata).length > 0;
+        const hasLocalGovernance = Boolean(existingOwner) || localContext.hasLocalPolicyMetadata;
+        const inherited = localContext.ownershipSource === "inherited";
+        return {
+            path: outputPath,
+            kind,
+            suggestedMode: hasOverride ? "metadata-retrofit" : "no-proposal",
+            decisionStatus: blockedMetadata.length > 0
+                ? "blocked"
+                : hasOverride
+                    ? "deterministic"
+                    : "no-change-recommended",
+            decision: blockedMetadata.length > 0
+                ? {
+                    reasonCode: "conflicting-ownership-evidence",
+                    summary: "Renma cannot safely construct a local metadata override while declared and provided ownership evidence conflict.",
+                }
+                : hasOverride
+                    ? {
+                        reasonCode: "explicit-human-provided-override",
+                        summary: "The candidate is an explicit human-provided Skill-local metadata override; it is not required for ordinary local support.",
+                    }
+                    : hasLocalGovernance
+                        ? {
+                            reasonCode: "skill-local-existing-metadata-preserved",
+                            summary: "Existing explicit local governance metadata is preserved; no inherited-governance claim or retrofit is needed.",
+                        }
+                        : inherited
+                            ? {
+                                reasonCode: "skill-local-governance-inherited",
+                                summary: "One unambiguous parent Skill supplies effective governance, so no independent metadata retrofit is required.",
+                            }
+                            : {
+                                reasonCode: "skill-local-unowned",
+                                summary: "The parent Skill is resolved, but neither the local file nor its parent declares an owner; missing ownership remains allowed.",
+                            },
+            classification,
+            ownerProvided: Boolean(explicitOwner),
+            instructions: skillLocalInstructions(classification, hasOverride, false, hasLocalGovernance),
+            candidateMetadata,
+            blockedMetadata,
+            nextActions: suggestionNextActions(outputPath, classification, repositoryRoot),
+        };
+    }
+    if (classification.matchedRule === "repository-tool" ||
+        classification.matchedRule === "unknown") {
+        const unsafe = classificationContext.state === "unresolved";
+        return {
+            path: outputPath,
+            kind,
+            suggestedMode: "no-proposal",
+            decisionStatus: unsafe ? "blocked" : "no-change-recommended",
+            decision: unsafe
+                ? {
+                    reasonCode: classificationContext.reasonCode,
+                    summary: "Renma could not infer one safe repository-relative boundary for this target path.",
+                }
+                : {
+                    reasonCode: classification.matchedRule === "repository-tool"
+                        ? "repository-tool-not-context"
+                        : "outside-recognized-asset-boundary",
+                    summary: "No metadata proposal is generated because the target is not an independently governed Renma asset.",
+                    question: "Is this file intended to have independent ownership and lifecycle under a recognized asset root?",
+                },
+            classification,
+            ownerProvided: Boolean(explicitOwner),
+            instructions: [
+                "Preserve the existing file.",
+                "Do not infer that the target should become a Context Asset from its content or filename.",
+                "Do not move the file or add Renma metadata without a human repository-design decision.",
+            ],
+            candidateMetadata: {},
+            blockedMetadata: [],
+            nextActions: suggestionNextActions(outputPath, classification, repositoryRoot),
+        };
+    }
     if (!existingId && candidateId) {
         candidateMetadata.id = candidateId;
     }
@@ -111,56 +245,152 @@ export async function buildMetadataSuggestion(target, options = {}) {
     if (!existingOwner && explicitOwner) {
         candidateMetadata.owner = explicitOwner;
     }
-    const blockedMetadata = [];
+    const blockedMetadata = conflictingOwnerEvidence(existingOwner, explicitOwner);
     if (!existingOwner && !explicitOwner) {
         blockedMetadata.push({
             field: "owner",
             reason: "No owner was explicitly provided. Missing owner is allowed.",
         });
     }
-    if (existingOwner && explicitOwner && existingOwner !== explicitOwner) {
-        blockedMetadata.push({
-            field: "owner",
-            reason: `Existing owner "${existingOwner}" differs from explicitly provided owner "${explicitOwner}". Do not change ownership without human review.`,
-        });
-    }
+    const hasCandidate = Object.keys(candidateMetadata).length > 0;
+    const hasConflict = blockedMetadata.some((item) => item.reason.includes("differs from explicitly provided owner"));
     return {
         path: outputPath,
         kind,
-        suggestedMode: "metadata-retrofit",
+        suggestedMode: hasConflict || !hasCandidate ? "no-proposal" : "metadata-retrofit",
+        decisionStatus: hasConflict
+            ? "blocked"
+            : hasCandidate
+                ? classification.scope === "independent"
+                    ? "human-confirmation-required"
+                    : "deterministic"
+                : "no-change-recommended",
+        decision: hasConflict
+            ? {
+                reasonCode: "conflicting-ownership-evidence",
+                summary: "Renma cannot safely construct a metadata proposal.",
+            }
+            : hasCandidate && classification.scope === "independent"
+                ? {
+                    reasonCode: "independent-governance-intent-unconfirmed",
+                    summary: "Renma constructed only deterministic candidates; the intended owner, lifecycle, and source-of-truth evidence still require human confirmation.",
+                    question: "Confirm the intended owner, lifecycle, and source-of-truth evidence for this independent asset.",
+                }
+                : hasCandidate
+                    ? {
+                        reasonCode: "deterministic-metadata-candidate",
+                        summary: "The metadata candidate follows the classified repository boundary and explicit user evidence.",
+                    }
+                    : {
+                        reasonCode: "metadata-already-sufficient",
+                        summary: "Renma found no supported metadata change to propose.",
+                    },
+        classification,
         ownerProvided: Boolean(explicitOwner),
         instructions: buildInstructions({ existingOwner, explicitOwner }),
-        candidateMetadata,
+        candidateMetadata: hasConflict ? {} : candidateMetadata,
         blockedMetadata,
+        nextActions: suggestionNextActions(outputPath, classification, repositoryRoot),
     };
 }
 export function renderMetadataPrompt(suggestion) {
     if (suggestion.agentSkills)
         return renderAgentSkillMigrationPrompt(suggestion);
+    const blocked = suggestion.decisionStatus === "blocked";
+    const noChange = suggestion.decisionStatus === "no-change-recommended";
+    const noProposal = blocked || noChange;
+    const skillLocal = suggestion.classification.scope === "skill-local";
     return `${[
-        "# Renma Task: Safely Retrofit Renma Metadata",
+        blocked
+            ? "# Renma Result: Metadata Proposal Blocked"
+            : noProposal
+                ? "# Renma Result: No Metadata Proposal"
+                : "# Renma Task: Safely Retrofit Renma Metadata",
         "",
-        "Update this existing Renma asset metadata safely.",
+        blocked
+            ? "Renma cannot safely produce an applicable metadata patch."
+            : noProposal
+                ? "No independent metadata retrofit is required."
+                : "Review this existing Renma asset metadata candidate safely.",
         "",
         "Asset:",
         `- Path: \`${suggestion.path}\``,
         `- Kind: \`${suggestion.kind}\``,
         `- Mode: \`${suggestion.suggestedMode}\``,
+        `- Decision status: \`${suggestion.decisionStatus}\``,
+        "",
+        "Classification:",
+        ...classificationPromptLines(suggestion.classification),
+        "",
+        "Observed repository fact:",
+        observedRepositoryFact(suggestion.classification),
+        "",
+        "Deterministic Renma interpretation:",
+        deterministicInterpretation(suggestion.classification),
+        "",
+        noProposal ? "Recommendation:" : "Decision:",
+        suggestion.decision.summary,
+        ...(suggestion.decision.question
+            ? ["", "Remaining human decision:", suggestion.decision.question]
+            : []),
+        ...(skillLocal
+            ? suggestion.classification.parentResolution === "resolved"
+                ? [
+                    "",
+                    "This file is structurally Skill-local support with one resolved parent:",
+                    suggestion.classification.parentAssetPath ??
+                        "(resolved parent path unavailable)",
+                    "",
+                    ...skillLocalGovernancePromptLines(suggestion),
+                    "Preserve existing metadata if present.",
+                    "Do not add an owner, move the file, or create a patch solely to manufacture work.",
+                ]
+                : [
+                    "",
+                    "This file is structurally Skill-local support, but its parent governance is unresolved.",
+                    `Parent resolution: ${suggestion.classification.parentResolution ?? "structural-candidate"}.`,
+                    "Do not claim inheritance or add an independent local owner until the repository layout resolves to one parent Skill.",
+                ]
+            : []),
         "",
         "Rules:",
         ...suggestion.instructions.map((instruction) => `- ${instruction}`),
         "",
-        "Candidate Metadata:",
-        ...metadataLines(suggestion.candidateMetadata),
+        blocked
+            ? "Candidate Metadata (not applicable while blocked):"
+            : "Candidate Metadata:",
+        ...(blocked
+            ? ["- (suppressed because the decision is blocked)"]
+            : metadataLines(suggestion.candidateMetadata)),
         "",
         "Blocked Metadata:",
         ...blockedMetadataLines(suggestion.blockedMetadata),
         "",
         "Verification:",
-        "- Run `renma scan .`.",
-        "- Run `renma ownership .`.",
+        ...(blocked
+            ? suggestion.nextActions.length > 0
+                ? [
+                    "- Resolve the blocked evidence and rerun `renma suggest-metadata`.",
+                    "- Run only the structured safe action; do not apply a patch from this result.",
+                ]
+                : [
+                    "- Establish the repository root with an explicit root or repository marker, then rerun `renma suggest-metadata`.",
+                    "- No verification command is safe while the repository boundary is unresolved.",
+                ]
+            : noChange
+                ? ["- No verification change is required when no file change is made."]
+                : [
+                    "- Run `renma scan . --fail-on high --format json`.",
+                    "- Run `renma ownership .`.",
+                ]),
         "",
-        "Return a small reviewed patch. Do not rewrite the asset body.",
+        blocked
+            ? "Do not return or apply a patch while the decision is blocked. Preserve the existing source."
+            : noChange
+                ? "Stop without manufacturing work. Preserve the existing source."
+                : suggestion.decisionStatus === "human-confirmation-required"
+                    ? "After confirming the stated human decision, return only the reviewed candidate fields. Do not invent unresolved owner, lifecycle, or source-of-truth metadata, and do not rewrite the asset body."
+                    : "Return a small reviewed patch containing only the deterministic candidate. Do not rewrite the asset body.",
     ].join("\n")}\n`;
 }
 function renderAgentSkillMigrationPrompt(suggestion) {
@@ -170,7 +400,7 @@ function renderAgentSkillMigrationPrompt(suggestion) {
     const metadataRetrofit = migration.proposalKind === "canonical-metadata-retrofit";
     const noMigrationProposed = migration.proposalKind === "none" &&
         migration.sourceFormat === "agent-skills";
-    const candidate = migration.canonicalFrontmatter
+    const candidate = suggestion.decisionStatus !== "blocked" && migration.canonicalFrontmatter
         ? [
             "Canonical Frontmatter Candidate:",
             "",
@@ -183,9 +413,9 @@ function renderAgentSkillMigrationPrompt(suggestion) {
             "",
             "(not generated while migration is blocked or unnecessary)",
         ];
-    const promptState = suggestion.blockedMetadata.length > 0
+    const promptState = suggestion.decisionStatus === "blocked"
         ? "blocked"
-        : noMigrationProposed || !migration.canonicalFrontmatter
+        : suggestion.decisionStatus === "no-change-recommended"
             ? "no-proposal"
             : "candidate";
     const verification = renderSkillSuggestionVerification(promptState);
@@ -198,6 +428,10 @@ function renderAgentSkillMigrationPrompt(suggestion) {
                 : "# Renma Task: Review One-Way Agent Skills Migration",
         "",
         `Asset: \`${suggestion.path}\``,
+        `Decision status: \`${suggestion.decisionStatus}\``,
+        `Decision reason: \`${suggestion.decision.reasonCode}\``,
+        "Classification:",
+        ...classificationPromptLines(suggestion.classification),
         `Source format: \`${migration.sourceFormat}\``,
         `Direction: \`${migration.direction}\``,
         `Proposal: \`${migration.proposalKind}\``,
@@ -226,13 +460,20 @@ function renderAgentSkillMigrationPrompt(suggestion) {
         "",
         ...nextSteps,
         "",
-        migration.canonicalFrontmatter
-            ? migration.entrypointMigration === "none"
-                ? "Return a small reviewed frontmatter patch. Do not rewrite the Skill body."
-                : "Return one small reviewed patch containing both the entrypoint path migration and frontmatter migration. Do not rewrite the Skill body."
-            : migration.blocked.length > 0
-                ? "Do not return or apply a frontmatter patch while migration is blocked. Preserve the existing source until every blocked item is resolved with human review."
-                : "No frontmatter patch is proposed. Do not return or apply a frontmatter patch; preserve the existing source.",
+        promptState === "blocked"
+            ? "Do not return or apply a frontmatter patch while the decision is blocked. Preserve the existing source until every blocked item is resolved with human review."
+            : promptState === "no-proposal"
+                ? "No frontmatter patch is proposed. Do not return or apply a frontmatter patch; preserve the existing source."
+                : suggestion.decisionStatus === "human-confirmation-required" &&
+                    migration.canonicalFrontmatter
+                    ? migration.entrypointMigration === "none"
+                        ? "After a human confirms the intended Skill semantics, return only the reviewed canonical frontmatter candidate. Do not invent unresolved fields or rewrite the Skill body."
+                        : "After a human confirms the intended Skill semantics, return one reviewed patch containing only the entrypoint path migration and canonical frontmatter candidate. Do not invent unresolved fields or rewrite the Skill body."
+                    : migration.canonicalFrontmatter
+                        ? migration.entrypointMigration === "none"
+                            ? "Return a small reviewed frontmatter patch. Do not rewrite the Skill body."
+                            : "Return one small reviewed patch containing both the entrypoint path migration and frontmatter migration. Do not rewrite the Skill body."
+                        : "Do not return a patch because no canonical candidate was generated.",
     ].join("\n")}\n`;
 }
 function renderSkillSuggestionVerification(state) {
@@ -313,37 +554,243 @@ function blockedMetadataLines(blockedMetadata) {
     }
     return blockedMetadata.map((item) => `- ${item.field}: ${item.reason}`);
 }
-function classifyPath(filePath, entrypoint) {
-    if (entrypoint)
-        return "skill";
-    const parts = pathParts(filePath);
-    const basename = parts.at(-1) ?? "";
-    if (parts.includes("lenses"))
-        return "context_lens";
-    if (parts.includes("contexts") || parts.includes("context"))
-        return "context";
-    if (parts.includes("profiles"))
-        return "profile";
-    if (parts.includes("references"))
-        return "reference";
-    if (parts.includes("examples"))
-        return "example";
-    if (basename === "AGENTS.md" || parts.includes(".agents"))
-        return "agent";
-    if (basename === "renma.config.json" || basename === ".renma.json") {
-        return "config";
-    }
-    return "unknown";
-}
-function classifySuggestionSkillEntrypointPath(filePath) {
-    return isAbsoluteLike(filePath)
-        ? classifyAbsoluteSkillEntrypointPath(filePath)
-        : classifyRepositorySkillEntrypointPath(filePath);
-}
-async function pathMigrationCollision(entrypoint, sourceAbsolutePath) {
+function skillLocalGovernancePromptLines(suggestion) {
+    switch (suggestion.decision.reasonCode) {
+        case "skill-local-governance-inherited":
+            return [
+                "Effective governance is inherited from this one resolved parent Skill.",
+            ];
+        case "skill-local-existing-metadata-preserved":
+            return [
+                "Existing explicit local governance is preserved and is not relabeled as inherited.",
+            ];
+        case "skill-local-unowned":
+            return [
+                "The parent is resolved, but no effective owner is declared locally or by the parent.",
+            ];
+        case "explicit-human-provided-override":
+            return [
+                "The parent is resolved; the local candidate is an explicit human-provided override.",
+            ];
+        default:
+            return [
+                "Governance provenance remains separate from this structural parent resolution.",
+            ];
+    }
+}
+function skillDecision(migration) {
+    if (migration.blocked.length > 0) {
+        return {
+            status: "blocked",
+            decision: {
+                reasonCode: "conflicting-or-incomplete-skill-evidence",
+                summary: "Renma cannot safely construct the Agent Skills proposal until the blocked evidence is resolved by a human.",
+            },
+        };
+    }
+    if (migration.proposalKind === "none" &&
+        migration.sourceFormat === "agent-skills") {
+        return {
+            status: "no-change-recommended",
+            decision: {
+                reasonCode: "canonical-agent-skill-no-change",
+                summary: "The target is already a canonical Agent Skill and no metadata or migration change is recommended.",
+            },
+        };
+    }
+    if (migration.proposalKind === "canonical-metadata-retrofit" &&
+        migration.canonicalFrontmatter !== undefined &&
+        Object.keys(migration.candidateRenmaMetadata).length > 0) {
+        return {
+            status: "deterministic",
+            decision: {
+                reasonCode: "explicit-human-provided-override",
+                summary: "The metadata candidate uses the owner explicitly supplied by the human; Renma inferred no owner.",
+            },
+        };
+    }
+    return {
+        status: "human-confirmation-required",
+        decision: {
+            reasonCode: "agent-skills-migration-review-required",
+            summary: "Renma constructed a deterministic migration candidate, but a human must confirm the intended Skill semantics before applying it.",
+        },
+    };
+}
+function conflictingOwnerEvidence(existingOwner, explicitOwner) {
+    if (!existingOwner || !explicitOwner || existingOwner === explicitOwner) {
+        return [];
+    }
+    return [
+        {
+            field: "owner",
+            reason: `Existing owner "${existingOwner}" differs from explicitly provided owner "${explicitOwner}". Do not change ownership without human review.`,
+        },
+    ];
+}
+function skillLocalInstructions(classification, hasOverride, parentBlocked, hasLocalGovernance) {
+    return [
+        "Preserve the existing Skill-local file and any explicitly declared supported metadata.",
+        parentBlocked
+            ? "Do not claim inherited governance until exactly one parent Skill resolves."
+            : hasLocalGovernance
+                ? "Keep existing explicit local governance separate from parent inheritance."
+                : `Treat ${classification.parentAssetPath ?? "the resolved parent Skill"} as the default governance source.`,
+        "Independent metadata is not required merely because this is a Skill-local file.",
+        hasOverride
+            ? "Apply only the explicit human-provided override; do not describe it as mandatory local metadata."
+            : "Do not add metadata, move the file, or create a patch solely to manufacture work.",
+        "Never infer owner from the path, prose, Git history, or author.",
+    ];
+}
+function suggestionNextActions(targetPath, classification, repositoryRoot) {
+    if (!repositoryRoot)
+        return [];
+    const actions = [];
+    const scanTarget = repositoryRoot;
+    if (classification.parentResolution === "resolved" &&
+        classification.parentAssetPath) {
+        actions.push({
+            kind: "inspect-parent",
+            invocation: renmaCommand([
+                "inspect",
+                path.join(repositoryRoot, classification.parentAssetPath),
+                "--format",
+                "json",
+            ]),
+        });
+    }
+    else if (classification.scope === "skill-local" &&
+        classification.parentResolution !== "resolved") {
+        actions.push({
+            kind: "review-layout",
+            invocation: renmaCommand([
+                "scan",
+                scanTarget,
+                "--fail-on",
+                "high",
+                "--format",
+                "json",
+            ]),
+        });
+        return actions;
+    }
+    else {
+        actions.push({
+            kind: "inspect-target",
+            invocation: renmaCommand(["inspect", targetPath, "--format", "json"]),
+        });
+    }
+    actions.push({
+        kind: "verify",
+        invocation: renmaCommand([
+            "scan",
+            scanTarget,
+            "--fail-on",
+            "high",
+            "--format",
+            "json",
+        ]),
+    });
+    return actions;
+}
+async function resolveSkillLocalContext(classification, relativePath, repositoryRoot) {
+    if (!repositoryRoot) {
+        return {
+            classification,
+            parent: { state: "not-applicable" },
+            ownershipSource: "unowned",
+            hasLocalPolicyMetadata: false,
+        };
+    }
+    try {
+        const snapshot = await collectRepositorySnapshot(repositoryRoot);
+        const skillParents = buildSkillParentIndex(snapshot.documents);
+        const parent = resolveSkillSupportParent(relativePath, skillParents);
+        const resolvedClassification = withResolvedSkillParent(classification, relativePath, skillParents);
+        const entry = snapshot.catalog.entries.find((candidate) => candidate.sourcePath === relativePath);
+        const policy = collectSecurityPolicyAssetEvidence(snapshot.artifacts, snapshot.config.security).find((candidate) => candidate.path === relativePath);
+        return {
+            classification: resolvedClassification,
+            parent,
+            ownershipSource: entry?.ownership.source ??
+                (parent.state === "resolved" && parent.parent.owner
+                    ? "inherited"
+                    : "unowned"),
+            hasLocalPolicyMetadata: policy?.hasLocalPolicyMetadata ?? false,
+        };
+    }
+    catch {
+        return {
+            classification,
+            parent: { state: "not-applicable" },
+            ownershipSource: "unowned",
+            hasLocalPolicyMetadata: false,
+        };
+    }
+}
+function classificationPromptLines(classification) {
+    return [
+        `- kind: \`${classification.kind}\``,
+        `- scope: \`${classification.scope}\``,
+        `- matched rule: \`${classification.matchedRule}\``,
+        `- reason code: \`${classification.reasonCode}\``,
+        ...(classification.recognizedRoot
+            ? [`- recognized root: \`${classification.recognizedRoot}\``]
+            : []),
+        ...(classification.parentAssetPath
+            ? [`- parent asset: \`${classification.parentAssetPath}\``]
+            : []),
+        ...(classification.parentAssetCandidatePath
+            ? [
+                `- parent candidate: \`${classification.parentAssetCandidatePath}\``,
+                `- parent resolution: \`${classification.parentResolution ?? "structural-candidate"}\``,
+            ]
+            : []),
+        ...(classification.parentAssetCandidates?.length
+            ? [
+                `- parent candidates: ${classification.parentAssetCandidates.map((candidate) => `\`${candidate}\``).join(", ")}`,
+            ]
+            : []),
+        ...(classification.supportDirectory
+            ? [`- support directory: \`${classification.supportDirectory}\``]
+            : []),
+        ...(classification.ignoredNestedSegments?.length
+            ? [
+                `- ignored nested segments: ${classification.ignoredNestedSegments.map((segment) => `\`${segment}\``).join(", ")}`,
+            ]
+            : []),
+        `- reason: ${classification.reason}`,
+    ];
+}
+function observedRepositoryFact(classification) {
+    if (classification.matchedRule === "skill-local-support") {
+        return `The target is under a canonical ${classification.supportDirectory}/ directory within a recognized Skill-root path shape.`;
+    }
+    if (classification.matchedRule === "context-root" ||
+        classification.matchedRule === "context-root-legacy") {
+        return `The target is under ${classification.recognizedRoot}/**.`;
+    }
+    return classification.reason;
+}
+function deterministicInterpretation(classification) {
+    if (classification.scope === "skill-local") {
+        return classification.parentResolution === "resolved"
+            ? `The target is structurally Skill-local support and its parent resolves to ${classification.parentAssetPath}; governance provenance is evaluated separately.`
+            : "The target is structurally Skill-local support, but inherited governance is unresolved.";
+    }
+    if (classification.scope === "independent") {
+        return `The target is an independently governed ${classification.kind} asset.`;
+    }
+    if (classification.scope === "repository-support") {
+        return "The target is repository support, not an independently governed Context Asset.";
+    }
+    return "Renma does not classify the target as an independently governed asset.";
+}
+async function pathMigrationCollision(entrypoint, sourceAbsolutePath, repositoryRoot) {
     if (entrypoint.kind === "canonical")
         return undefined;
-    const targetAbsolutePath = path.resolve(entrypoint.targetPath);
+    const targetAbsolutePath = path.resolve(repositoryRoot, entrypoint.targetPath);
     try {
         await lstat(targetAbsolutePath);
     }
@@ -378,9 +825,6 @@ async function pathMigrationCollision(entrypoint, sourceAbsolutePath) {
         };
     }
 }
-function isAbsoluteLike(filePath) {
-    return path.isAbsolute(filePath) || /^[A-Za-z]:\//.test(filePath);
-}
 function isMissingFileError(error) {
     return (typeof error === "object" &&
         error !== null &&