@agentxm/workspace-lint 0.28.4-bootstrap.0

package/dist/src/catalog/workspace/skills-integrity-valid.js

@@ -0,0 +1,95 @@
+/**
+ * `workspace/skills-integrity-valid` — each installed skill listed in the
+ * lockfile is present on disk.
+ *
+ * For each accepted skill lock entry, verify that its canonical acquired
+ * package is present in the scope's canonical root. Missing-package entries
+ * each emit one finding.
+ * Configured findings are autofixable via `install-skill` with
+ * `force: true`; pack-provided implicit findings are advisory because the
+ * repair is a pack-level reinstall.
+ *
+ * This rule owns only the missing-package arm. Package-tree integrity is
+ * evaluated by canonical observations against `treeIntegrity`; local edits,
+ * including formatter changes, are drift and block affected reads and
+ * mutation closures until explicit recovery.
+ *
+ * A skill whose `sourceHash` is undefined in the lockfile (e.g., git-hosted
+ * sources without pinned hash) is not checked.
+ *
+ * One finding per affected entity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import {} from "@agentxm/workspace-state";
+import { EMPTY_LINT_FINDINGS } from "./helpers/empty.js";
+import { lockfileDisplayPath } from "./display-paths.js";
+const RULE_ID = "workspace/skills-integrity-valid";
+const simpleName = (name) => name.split("/").at(-1) ?? name;
+const hasSourceActual = (actual, name) => actual.some((occurrence) => occurrence.key.name === simpleName(name) &&
+    (occurrence.origin._tag === "canonical-axm-skill" ||
+        occurrence.origin._tag === "external-axm-skill"));
+const integrityFinding = (name, reason, lockfilePath) => ({
+    kind: "advisory",
+    ruleId: RULE_ID,
+    severity: "error",
+    message: `Skill '${name}' has an accepted resolution, but ${reason}.`,
+    location: { file: lockfilePath },
+});
+/**
+ * Presence probe for the skill's acquired package tree. Integrity drift is a
+ * separate canonical-observation fact, so this helper owns only absence.
+ */
+const integrityReason = (lockEntry, probeExists) => {
+    if (!probeExists) {
+        return Option.some("its installed source directory is missing");
+    }
+    return Option.none();
+};
+const collectIntegrityFindings = (desiredNames, probes, lockfilePath) => {
+    const findings = [];
+    for (const { name, entry, exists } of probes) {
+        if (!desiredNames.has(name))
+            continue;
+        const reason = integrityReason(entry, exists);
+        if (Option.isNone(reason)) {
+            continue;
+        }
+        findings.push(integrityFinding(name, reason.value, lockfilePath));
+    }
+    return findings;
+};
+export const skillsIntegrityValidRule = {
+    id: RULE_ID,
+    description: "Installed skills listed in the lockfile are present on disk.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const scoped = context.workspace;
+        const lockfileResult = yield* Effect.result(scoped.state.lockfile);
+        if (Result.isFailure(lockfileResult) || context.health === undefined) {
+            return EMPTY_LINT_FINDINGS;
+        }
+        const graphResult = yield* Effect.result(context.health.desiredState);
+        if (Result.isFailure(graphResult)) {
+            return EMPTY_LINT_FINDINGS;
+        }
+        const lockOption = lockfileResult.success;
+        if (Option.isNone(lockOption)) {
+            return EMPTY_LINT_FINDINGS;
+        }
+        const actual = yield* scoped.skills.actual;
+        const probes = Object.entries(lockOption.value.skills).map(([name, entry]) => ({
+            name,
+            entry,
+            exists: hasSourceActual(actual, name),
+        }));
+        const desiredNames = new Set(graphResult.success.nodes.filter((node) => node.type === "skill").map((node) => node.name));
+        return collectIntegrityFindings(desiredNames, probes, lockfileDisplayPath(context.subject.scope));
+    }),
+};
+//# sourceMappingURL=skills-integrity-valid.js.map

package/dist/src/catalog/workspace/skills-lockfile-aligned.d.ts

@@ -0,0 +1,5 @@
+/** Reports alignment between desired external Skills and accepted resolutions. */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const skillsLockfileAlignedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=skills-lockfile-aligned.d.ts.map

package/dist/src/catalog/workspace/skills-lockfile-aligned.js

@@ -0,0 +1,64 @@
+/** Reports alignment between desired external Skills and accepted resolutions. */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { parseRegistrySourceRef } from "@agentxm/extension-model/unstable/extensions/registry-source";
+import {} from "@agentxm/workspace-state";
+import { isWorkspaceSourceLocator } from "@agentxm/extension-model/unstable/sources/workspace";
+import { versionSatisfiesRange } from "@agentxm/extension-model/unstable/version-constraints";
+import { lockfileDisplayPath } from "./display-paths.js";
+const RULE_ID = "workspace/skills-lockfile-aligned";
+const finding = (message, path) => ({
+    kind: "advisory",
+    ruleId: RULE_ID,
+    severity: "error",
+    message,
+    location: { file: path },
+});
+const externalSkills = (nodes) => nodes.filter((node) => node.type === "skill" && node.source !== undefined && !isWorkspaceSourceLocator(node.source));
+const collectFindings = (nodes, lockfile, lockfilePath) => {
+    const desired = externalSkills(nodes);
+    const desiredNames = new Set(desired.map((node) => node.name));
+    const findings = [];
+    for (const node of desired) {
+        if (node.source === undefined)
+            continue;
+        const accepted = lockfile.skills[node.name];
+        if (accepted === undefined) {
+            findings.push(finding(`Skill '${node.name}' has desired external content but no accepted resolution.`, lockfilePath));
+            continue;
+        }
+        if (accepted.type !== "registry")
+            continue;
+        const parsed = parseRegistrySourceRef(node.source);
+        const constraint = parsed?.versionRange;
+        if (constraint !== undefined && !versionSatisfiesRange(accepted.resolvedVersion, constraint)) {
+            findings.push(finding(`Skill '${node.name}' accepts Registry version ${accepted.resolvedVersion}, which does not satisfy desired constraint ${constraint}.`, lockfilePath));
+        }
+    }
+    for (const name of Object.keys(lockfile.skills)) {
+        if (!desiredNames.has(name)) {
+            findings.push(finding(`Skill '${name}' has an accepted resolution but is not desired.`, lockfilePath));
+        }
+    }
+    return findings;
+};
+export const skillsLockfileAlignedRule = {
+    id: RULE_ID,
+    description: "Desired external Skills and accepted resolutions stay aligned.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        if (context.health === undefined)
+            return [];
+        const graph = yield* Effect.result(context.health.desiredState);
+        const lockfile = yield* Effect.result(context.workspace.state.lockfile);
+        if (Result.isFailure(graph) ||
+            Result.isFailure(lockfile) ||
+            Option.isNone(lockfile.success)) {
+            return [];
+        }
+        return collectFindings(graph.success.nodes, lockfile.success.value, lockfileDisplayPath(context.subject.scope));
+    }),
+};
+//# sourceMappingURL=skills-lockfile-aligned.js.map

package/dist/src/catalog/workspace/source-endpoints-aligned.d.ts

@@ -0,0 +1,5 @@
+/** Reports configured source hosts that diverge from accepted lock authority. */
+import type { WorkspaceRuleContext } from "../../workspace-context.js";
+import type { AdvisoryRule } from "@agentxm/registry-protocol/unstable/lint/rule";
+export declare const sourceEndpointsAlignedRule: AdvisoryRule<WorkspaceRuleContext>;
+//# sourceMappingURL=source-endpoints-aligned.d.ts.map

package/dist/src/catalog/workspace/source-endpoints-aligned.js

@@ -0,0 +1,75 @@
+/** Reports configured source hosts that diverge from accepted lock authority. */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import { settingsDisplayPath } from "./display-paths.js";
+const RULE_ID = "workspace/source-endpoints-aligned";
+const configuredEndpoint = (source) => source.type === "registry" ? source.location : source.url;
+const lockedEntries = (lockfile) => [
+    ...Object.entries(lockfile.skills).map(([name, entry]) => ({
+        extension: `skill:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.mcpServers ?? {}).map(([name, entry]) => ({
+        extension: `mcp-server:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.subagents ?? {}).map(([name, entry]) => ({
+        extension: `subagent:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.rules ?? {}).map(([name, entry]) => ({
+        extension: `rule:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.hooks ?? {}).map(([name, entry]) => ({
+        extension: `hook:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.knowledge ?? {}).map(([name, entry]) => ({
+        extension: `knowledge:${name}`,
+        entry,
+    })),
+    ...Object.entries(lockfile.packs ?? {}).map(([name, entry]) => ({
+        extension: `pack:${name}`,
+        entry,
+    })),
+];
+const collectFindings = (lockfile, configuredSources, settingsPath) => {
+    const findings = [];
+    for (const { extension, entry } of lockedEntries(lockfile)) {
+        if (entry.type === "local" || entry.type === "git")
+            continue;
+        const configured = configuredSources.find((source) => source.name === entry.sourceName);
+        if (configured === undefined)
+            continue;
+        const endpoint = configuredEndpoint(configured);
+        if (configured.type === entry.sourceType && endpoint.href === entry.endpoint.href)
+            continue;
+        findings.push({
+            kind: "advisory",
+            ruleId: RULE_ID,
+            severity: "error",
+            message: `Accepted resolution '${extension}' binds source '${entry.sourceName}' to ${entry.sourceType} ${entry.endpoint.href}, but the configured source now resolves to ${configured.type} ${endpoint.href}. Use an explicit source transition before syncing.`,
+            location: { file: settingsPath },
+        });
+    }
+    return findings;
+};
+export const sourceEndpointsAlignedRule = {
+    id: RULE_ID,
+    description: "Configured source endpoints remain aligned with accepted lock authority.",
+    kind: "advisory",
+    severity: "error",
+    check: (context) => Effect.gen(function* () {
+        const lockfile = yield* Effect.result(context.workspace.state.lockfile);
+        const sources = yield* Effect.result(context.workspace.sourceHosts.declared);
+        if (Result.isFailure(lockfile) ||
+            Option.isNone(lockfile.success) ||
+            Result.isFailure(sources)) {
+            return [];
+        }
+        return collectFindings(lockfile.success.value, sources.success, settingsDisplayPath(context.subject.scope));
+    }),
+};
+//# sourceMappingURL=source-endpoints-aligned.js.map

package/dist/src/catalog/workspace-fixtures/fixture-state.d.ts

@@ -0,0 +1,8 @@
+import type { FixtureSpec, ScopeFiles } from "@agentxm/workspace-state";
+import type { WorkspaceState } from "./interpret-ops.js";
+export declare const scopeFilesFromWorkspaceState: (state: WorkspaceState) => ScopeFiles;
+export declare const fixtureSpecFromWorkspaceState: (state: WorkspaceState, scope: "project" | "user", roots: {
+    readonly workspaceRoot: string;
+    readonly userHome: string;
+}) => FixtureSpec;
+//# sourceMappingURL=fixture-state.d.ts.map

package/dist/src/catalog/workspace-fixtures/fixture-state.js

@@ -0,0 +1,120 @@
+import { AGENTS } from "@agentxm/extension-model/unstable/agents/registry";
+const pathSegments = (relativePath) => relativePath.split("/").filter((segment) => segment.length > 0);
+const firstPathSegment = (relativePath) => pathSegments(relativePath)[0];
+const agentRootForSkillsDir = (skillsDir) => firstPathSegment(skillsDir);
+const relativeUnderAgentRoot = (agentRoot, relativePath) => {
+    if (relativePath === agentRoot)
+        return "";
+    const prefix = `${agentRoot}/`;
+    if (!relativePath.startsWith(prefix))
+        return undefined;
+    return relativePath.slice(prefix.length);
+};
+const skillNameFromPath = (skillsDir, relativePath) => {
+    const prefix = `${skillsDir}/`;
+    if (!relativePath.startsWith(prefix))
+        return undefined;
+    const afterSkillsDir = relativePath.slice(prefix.length);
+    return firstPathSegment(afterSkillsDir);
+};
+const literalFileFor = (relativePath) => {
+    const segments = pathSegments(relativePath);
+    const name = segments.at(-2) ?? segments.at(-1) ?? "fixture";
+    const lower = relativePath.toLowerCase();
+    if (lower.endsWith(".md"))
+        return `# ${name}\n`;
+    if (lower.endsWith(".json"))
+        return "{}\n";
+    if (lower.endsWith(".yaml") || lower.endsWith(".yml"))
+        return "{}\n";
+    return "";
+};
+const addTreeFile = (tree, relativePath, contents = literalFileFor(relativePath)) => {
+    tree[relativePath] = contents;
+};
+const addAgentSkillArtifact = (agentDirs, agentId, relativePath) => {
+    const agent = AGENTS[agentId];
+    const skills = agent.skills;
+    if (skills === undefined)
+        return;
+    const agentRoot = agentRootForSkillsDir(skills.dir);
+    if (agentRoot === undefined)
+        return;
+    const relative = relativeUnderAgentRoot(agentRoot, relativePath);
+    if (relative === undefined)
+        return;
+    const skillName = skillNameFromPath(skills.dir, relativePath);
+    const materializedPath = skillName === undefined
+        ? relative
+        : `${skills.dir.slice(agentRoot.length + 1)}/${skillName}/SKILL.md`;
+    if (materializedPath.length === 0)
+        return;
+    const tree = agentDirs[agentId] ?? {};
+    agentDirs[agentId] = tree;
+    addTreeFile(tree, materializedPath);
+};
+const isKnownAgentId = (id) => Object.hasOwn(AGENTS, id);
+const fileSpecFor = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== "object" || raw === null) {
+        throw new Error(`Fixture state expected an object for settings/lockfile; got ${typeof raw}`);
+    }
+    return { _tag: "valid", contents: raw };
+};
+export const scopeFilesFromWorkspaceState = (state) => {
+    const axmExtensions = {};
+    const agentDirs = {};
+    const agentSettings = {};
+    const agents = Object.values(AGENTS);
+    const addExistingPath = (relativePath) => {
+        const acquiredPrefix = "agent_extensions/";
+        if (relativePath.startsWith(acquiredPrefix)) {
+            addTreeFile(axmExtensions, relativePath.slice(acquiredPrefix.length));
+            return;
+        }
+        const axmPrefix = "agent_extensions/";
+        if (relativePath.startsWith(axmPrefix)) {
+            addTreeFile(axmExtensions, relativePath.slice(axmPrefix.length));
+            return;
+        }
+        for (const agent of agents) {
+            if (agent.skills !== undefined &&
+                skillNameFromPath(agent.skills.dir, relativePath) !== undefined) {
+                addAgentSkillArtifact(agentDirs, agent.id, relativePath);
+            }
+        }
+    };
+    for (const relativePath of state.existingPaths) {
+        addExistingPath(relativePath);
+    }
+    for (const [dir, entries] of state.listings) {
+        for (const entry of entries) {
+            addExistingPath(`${dir}/${entry}`);
+        }
+    }
+    for (const agentId of state.detectedProjectAgents) {
+        if (isKnownAgentId(agentId)) {
+            agentSettings[agentId] = { _tag: "valid", contents: {} };
+        }
+    }
+    const settings = fileSpecFor(state.settings);
+    const lockfile = fileSpecFor(state.lockfile);
+    return {
+        ...(settings === undefined ? {} : { settings }),
+        ...(lockfile === undefined ? {} : { lockfile }),
+        ...(Object.keys(axmExtensions).length === 0 ? {} : { axmExtensions }),
+        ...(Object.keys(agentDirs).length === 0 ? {} : { agentDirs }),
+        ...(Object.keys(agentSettings).length === 0 ? {} : { agentSettings }),
+    };
+};
+export const fixtureSpecFromWorkspaceState = (state, scope, roots) => {
+    const scopeFiles = scopeFilesFromWorkspaceState(state);
+    return {
+        workspaceRoot: roots.workspaceRoot,
+        userHome: roots.userHome,
+        ...(scope === "project" ? { project: scopeFiles } : {}),
+        ...(scope === "user" ? { user: scopeFiles } : {}),
+    };
+};
+//# sourceMappingURL=fixture-state.js.map

package/dist/src/catalog/workspace-fixtures/interpret-ops.d.ts

@@ -0,0 +1,11 @@
+/** Mutable workspace-state fixture shared by read-only lint rule tests. */
+export interface WorkspaceState {
+    settings: unknown;
+    lockfile: unknown;
+    readonly existingPaths: Set<string>;
+    readonly writablePaths: Set<string>;
+    readonly listings: Map<string, Array<string>>;
+    readonly detectedProjectAgents: Set<string>;
+}
+export declare const emptyWorkspaceState: () => WorkspaceState;
+//# sourceMappingURL=interpret-ops.d.ts.map

package/dist/src/catalog/workspace-fixtures/interpret-ops.js

@@ -0,0 +1,9 @@
+export const emptyWorkspaceState = () => ({
+    settings: undefined,
+    lockfile: undefined,
+    existingPaths: new Set(),
+    writablePaths: new Set(),
+    listings: new Map(),
+    detectedProjectAgents: new Set(),
+});
+//# sourceMappingURL=interpret-ops.js.map

package/dist/src/catalog/workspace-read-model/lint-workspace.d.ts

@@ -0,0 +1,191 @@
+/**
+ * `LintWorkspace` — single helper that produces both the per-rule
+ * `WorkspaceRuleContext` and the flat `LintWorkspaceView` projection a lint
+ * run needs, sharing one `WorkspaceReadModelLive` setup.
+ *
+ * `LintWorkspaceView` exposes `installedSkills: InstalledSkillInfo[]` and
+ * `installedPacks: InstalledPackInfo[]` with per-provenance `displayRoot`s:
+ *
+ *   Registry-installed native skill: `agent_extensions/<source>/<@owner>/skills/<name>/src/`
+ *   Portable acquired skill:         `agent_extensions/<source>/<source-full-name>/`
+ *   Registry pack:                   `agent_extensions/<source>/<@owner>/packs/<name>/`
+ *                                    (NO `src/` — matches the on-disk layout.)
+ *
+ * The companion `WorkspaceRuleContext` is scoped to project or user.
+ * User-scope resolution uses `.axm/workspace/` under `$AXM_USER_HOME` when set,
+ * otherwise under `$HOME`; a follow-up owns the broader XDG story.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import type { LockfileReadError, SettingsReadError, WorkspaceRootEscape } from "@agentxm/workspace-state";
+import type { HookRuleContext, KnowledgeRuleContext, McpServerRuleContext, RuleRuleContext, SubagentRuleContext } from "@agentxm/registry-protocol/unstable/lint/context";
+import type { WorkspaceProjectionsAccessor, WorkspaceRuleContext } from "../../workspace-context.js";
+import type { InstalledSkillInfo } from "@agentxm/registry-protocol/unstable/lint/catalog/skill-accessor/contexts";
+import type { InstalledPackInfo } from "@agentxm/registry-protocol/unstable/lint/catalog/pack-accessor/contexts";
+import type { SkillLockEntry } from "@agentxm/workspace-state";
+import type { KnowledgeInspection } from "@agentxm/registry-protocol/unstable/knowledge/okf";
+import type { AxmSkillCompatibilityPolicyService } from "@agentxm/extension-workspace";
+import type { Handle } from "@agentxm/extension-model/unstable/extensions/handle";
+/**
+ * Flat projection of the workspace read model that the lint accessor builders
+ * consume. `buildSkillRuleContexts` reads `installedSkills`;
+ * `buildPackRuleContexts` reads `installedPacks`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface LintWorkspaceView {
+    readonly installedSkills: ReadonlyArray<InstalledSkillInfo>;
+    readonly installedPacks: ReadonlyArray<InstalledPackInfo>;
+    readonly subagentContexts: ReadonlyArray<SubagentRuleContext>;
+    readonly mcpServerContexts: ReadonlyArray<McpServerRuleContext>;
+    readonly hookContexts: ReadonlyArray<HookRuleContext>;
+    readonly ruleContexts: ReadonlyArray<RuleRuleContext>;
+    readonly knowledgeContexts: ReadonlyArray<KnowledgeRuleContext>;
+}
+/**
+ * Argument shape for `buildLintWorkspace`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface BuildLintWorkspaceArgs {
+    readonly platform: {
+        readonly fs: FileSystem.FileSystem;
+        readonly path: Path.Path;
+    };
+    readonly workspaceRoot: string;
+    /**
+     * User home directory used by {@link makeWorkspaceReadModel} to validate
+     * the alternate scope's root against `allowedRoot`. Supplied even when
+     * only one scope is queried so root-escape checks stay symmetric.
+     */
+    readonly userHome: string;
+    readonly scope: "project" | "user";
+    /** The filesystem is a materialized Git-index snapshot, not the live workspace. */
+    readonly gitIndexView?: boolean;
+    /**
+     * Optional `displayRoot` override for the `WorkspaceRuleContext`. Defaults
+     * to `""` (accessor-relative paths render under the workspace root).
+     */
+    readonly displayRoot?: string;
+    /** Runtime-pinned evaluator used by status and the compatibility lint rule. */
+    readonly axmSkillCompatibilityPolicy?: AxmSkillCompatibilityPolicyService;
+    /** Caller-bound effective workspace owner accessor. */
+    readonly owner?: Effect.Effect<Option.Option<Handle>>;
+    /** Caller-bound read-back currency for aggregate managed output units. */
+    readonly projections?: WorkspaceProjectionsAccessor;
+    /** Test seam for proving one package inspection per selected bundle. */
+    readonly inspectKnowledge?: (packageRoot: string) => Effect.Effect<{
+        readonly inspection: KnowledgeInspection;
+    }, unknown, FileSystem.FileSystem | Path.Path>;
+}
+/**
+ * The combined output of `buildLintWorkspace`: the per-rule
+ * `WorkspaceRuleContext` plus the flat `LintWorkspaceView`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface LintWorkspace {
+    readonly rule: WorkspaceRuleContext;
+    readonly view: LintWorkspaceView;
+}
+/**
+ * Build the per-rule `WorkspaceRuleContext` and the flat `LintWorkspaceView`
+ * via a single {@link makeWorkspaceReadModel} invocation.
+ *
+ * `WorkspaceRootEscape` is surfaced in the error channel by the factory when
+ * `workspaceRoot` or `userHome` escape the filesystem root.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildLintWorkspace: (args: BuildLintWorkspaceArgs) => Effect.Effect<LintWorkspace, WorkspaceRootEscape | SettingsReadError | LockfileReadError>;
+/**
+ * Compute the `displayRoot` for a registry-installed native skill.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const registryNativeSkillDisplayRoot: (scope: "project" | "user", sourceName: string, owner: string, name: string) => string;
+/**
+ * Compute the content `displayRoot` for a source-qualified acquired skill.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const acquiredSkillDisplayRoot: (scope: "project" | "user", entry: SkillLockEntry, name: string) => string;
+/**
+ * Compute the `displayRoot` for a registry-installed pack.
+ *
+ * **No `src/` segment** — matches the on-disk layout at
+ * `packages/workspace-state/src/workspace/pack-paths.ts#computePackPathsForLayout`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const registryPackDisplayRoot: (scope: "project" | "user", sourceName: string, owner: string, name: string) => string;
+/**
+ * Options for building an `InstalledSkillInfo` for a registry-installed
+ * native skill. `owner` and `name` pin the on-disk layout.
+ */
+export interface BuildInstalledSkillInfoNativeArgs {
+    readonly platform: {
+        readonly fs: FileSystem.FileSystem;
+        readonly path: Path.Path;
+    };
+    readonly workspaceRoot: string;
+    readonly scope: "project" | "user";
+    readonly sourceName: string;
+    readonly owner: string;
+    readonly name: string;
+    readonly skillJson: unknown;
+}
+/**
+ * Build an `InstalledSkillInfo` rooted at `agent_extensions/<owner>/skills/<name>/src/`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildNativeInstalledSkillInfo: (args: BuildInstalledSkillInfoNativeArgs) => InstalledSkillInfo;
+/**
+ * Options for building an `InstalledSkillInfo` from an accepted acquired skill.
+ */
+export interface BuildAcquiredInstalledSkillInfoArgs {
+    readonly platform: {
+        readonly fs: FileSystem.FileSystem;
+        readonly path: Path.Path;
+    };
+    readonly workspaceRoot: string;
+    readonly scope: "project" | "user";
+    readonly lockEntry: SkillLockEntry;
+    readonly name: string;
+}
+/**
+ * Build an `InstalledSkillInfo` rooted at its exact accepted source-qualified path.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildAcquiredInstalledSkillInfo: (args: BuildAcquiredInstalledSkillInfoArgs) => InstalledSkillInfo;
+/**
+ * Options for building an `InstalledPackInfo` for a registry-installed pack.
+ */
+export interface BuildInstalledPackInfoArgs {
+    readonly platform: {
+        readonly fs: FileSystem.FileSystem;
+        readonly path: Path.Path;
+    };
+    readonly workspaceRoot: string;
+    readonly scope: "project" | "user";
+    readonly sourceName: string;
+    readonly owner: string;
+    readonly name: string;
+    readonly packJson: unknown;
+}
+/**
+ * Build an `InstalledPackInfo` rooted at `agent_extensions/<owner>/packs/<name>/`.
+ *
+ * **No `src/` segment** — matches the on-disk pack layout.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const buildInstalledPackInfo: (args: BuildInstalledPackInfoArgs) => InstalledPackInfo;
+//# sourceMappingURL=lint-workspace.d.ts.map