@deftai/directive-core 0.92.0 → 0.93.0

package/dist/init-deposit/skill-discovery-deposit.js

@@ -0,0 +1,287 @@
+/**
+ * Multi-host thin skill discovery deposit (#75 residual).
+ *
+ * Mirrors the consumer skill inventory already written to `.agents/skills/`
+ * into additional host paths (`.claude/skills/`, `.codex/skills/`,
+ * `.github/skills/`, `.cursor/skills/`). Thin pointers only — no full skill
+ * body copies. Windows-safe file writes (no elevated symlink requirement).
+ *
+ * Distinct from epic #55 slash-command deposit (#3054).
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { containedWrite } from "../fs/contained-write.js";
+import { assertDestinationNotSymlink } from "../fs/projection-containment.js";
+import { hostSkillRelativePath, isHostSkillDiscoveryEnabled, listSkillDiscoveryHosts, loadHostSkillDiscoveryPolicyFromProject, loadHostSkillDiscoveryRawFromProject, resolveHostSkillDiscoveryPolicyDetailed, SKILL_DISCOVERY_HOSTS, validateHostSkillDiscovery, } from "./skill-discovery-hosts.js";
+/**
+ * Consumer skill discovery inventory shared by `.agents/skills/` and multi-host
+ * deposit. Each entry is a thin SKILL.md pointer into `.deft/core/…` — never a
+ * full skill body. Keep this list the single SoT for install-time discovery.
+ */
+export const CONSUMER_SKILL_DISCOVERY_INVENTORY = [
+    {
+        dir: "deft",
+        content: `---
+name: deft
+description: Apply deft framework standards for AI-assisted development. Use when starting projects, writing code, running tests, making commits, or when the user references deft, project standards, or coding guidelines.
+---
+
+Read and follow: .deft/core/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-setup",
+        content: `---
+name: deft-directive-setup
+description: >-
+  Set up a new project with Deft framework standards. Use when the user wants
+  to bootstrap user preferences, configure a project, or generate a project
+  specification. Walks through setup conversationally — no separate CLI needed.
+---
+
+Read and follow: .deft/core/skills/deft-directive-setup/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-build",
+        content: `---
+name: deft-directive-build
+description: >-
+  Build a project from scope vBRIEFs following Deft framework standards.
+  Use after deft-directive-setup has generated the project definition, or when
+  the user has scope vBRIEFs ready to implement. Handles scaffolding,
+  implementation, testing, and quality checks phase by phase.
+---
+
+Read and follow: .deft/core/skills/deft-directive-build/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-review-cycle",
+        content: `---
+name: deft-directive-review-cycle
+description: >-
+  Greptile bot reviewer response workflow. Use when running a review cycle
+  on a PR — to audit process prerequisites, fetch bot findings, fix all
+  issues in a single batch commit, and exit cleanly when no P0/P1 issues
+  remain. Enables cloud agents to run autonomous PR review cycles.
+---
+
+Read and follow: .deft/core/skills/deft-directive-review-cycle/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-refinement",
+        content: `---
+name: deft-directive-refinement
+description: >-
+  Structured refinement workflow. Compares open GitHub issues against
+  the roadmap, triages new issues one-at-a-time with human review, and updates
+  the roadmap with phase placement, analysis comments, and index entries.
+---
+
+Read and follow: .deft/core/skills/deft-directive-refinement/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-swarm",
+        content: `---
+name: deft-directive-swarm
+description: >-
+  Parallel local agent orchestration. Use when running multiple agents
+  on roadmap items simultaneously — to select non-overlapping tasks, set up
+  isolated worktrees, launch agents with proven prompts, monitor progress,
+  handle stalled review cycles, and close out PRs cleanly.
+---
+
+Read and follow: .deft/core/skills/deft-directive-swarm/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-interview",
+        content: `---
+name: deft-directive-interview
+description: >-
+  Deterministic structured Q&A interview skill. Use when a skill or workflow
+  needs to collect structured answers from the user — one question per turn,
+  numbered options, default acceptance, and a confirmation gate.
+---
+
+Read and follow: .deft/core/skills/deft-directive-interview/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-pre-pr",
+        content: `---
+name: deft-directive-pre-pr
+description: >-
+  Iterative pre-PR quality loop (Read-Write-Lint-Diff-Loop). Use before
+  pushing a branch for PR creation — structured self-review that agents run
+  to catch issues before they reach the bot reviewer.
+---
+
+Read and follow: .deft/core/skills/deft-directive-pre-pr/SKILL.md
+`,
+    },
+    {
+        dir: "deft-directive-sync",
+        content: `---
+name: deft-directive-sync
+description: >-
+  Session-start framework sync skill. Use at the beginning of a session to
+  pull latest framework updates, validate project files, and confirm alignment
+  before starting work.
+---
+
+Read and follow: .deft/core/skills/deft-directive-sync/SKILL.md
+`,
+    },
+];
+/** Max bytes for a thin pointer body — fat full-skill copies fail this guard. */
+export const MAX_THIN_SKILL_POINTER_BYTES = 1200;
+/**
+ * True when content is a thin discovery pointer (not an inlined skill body).
+ * Managed deposit must stay pointer-shaped so updates do not rot full copies.
+ */
+export function isThinSkillPointer(content) {
+    if (content.length > MAX_THIN_SKILL_POINTER_BYTES)
+        return false;
+    if (!content.includes("Read and follow:"))
+        return false;
+    // Canonical consumer target lives under the deposited framework root.
+    if (!content.includes(".deft/core/"))
+        return false;
+    // Reject bodies that look like full skill process docs.
+    if (/\n##\s+Phase\b/i.test(content))
+        return false;
+    if (/\n##\s+Anti-?[Pp]atterns\b/i.test(content))
+        return false;
+    return true;
+}
+function projectionTarget(projectDir, ...relSegments) {
+    const target = join(projectDir, ...relSegments);
+    assertDestinationNotSymlink(projectDir, target);
+    return target;
+}
+function containedProjectWrite(projectDir, target, data) {
+    containedWrite({
+        root: resolve(projectDir),
+        target,
+        data,
+        mode: "replace",
+    });
+}
+/**
+ * Deposit thin skill discovery pointers into enabled multi-host paths.
+ * Idempotent: skips write when on-disk content already matches. Never creates
+ * symlinks (Windows-safe without elevation).
+ */
+export function writeMultiHostSkillDiscovery(projectDir, io, options = {}) {
+    const rawPolicy = options.policy !== undefined
+        ? options.policy
+        : loadHostSkillDiscoveryRawFromProject(projectDir);
+    // Production validation surface (#75 SLizard P1): report malformed opt-outs
+    // before resolving the deposit enablement map.
+    for (const err of validateHostSkillDiscovery(rawPolicy)) {
+        io.printf(`WARNING: ${err}\n`);
+    }
+    const resolved = resolveHostSkillDiscoveryPolicyDetailed(rawPolicy);
+    for (const warning of resolved.warnings) {
+        io.printf(`WARNING: ${warning}\n`);
+    }
+    if (resolved.refuseAll) {
+        return {
+            changed: false,
+            changedPaths: [],
+            hostsTouched: [],
+            hostsSkipped: [...listSkillDiscoveryHosts()],
+        };
+    }
+    // Prefer the public project-root loader when reading disk so policy inspection
+    // and deposit share one production call path (not test-only exports).
+    const policy = options.policy !== undefined
+        ? resolved.policy
+        : loadHostSkillDiscoveryPolicyFromProject(projectDir);
+    const inventory = options.inventory ?? CONSUMER_SKILL_DISCOVERY_INVENTORY;
+    for (const skill of inventory) {
+        if (!isThinSkillPointer(skill.content)) {
+            throw new Error(`skill discovery inventory entry "${skill.dir}" is not a thin pointer; ` +
+                `refusing multi-host deposit (#75 non-inlining).`);
+        }
+    }
+    const changedPaths = [];
+    const hostsTouched = new Set();
+    const hostsSkipped = [];
+    for (const hostId of listSkillDiscoveryHosts()) {
+        if (!isHostSkillDiscoveryEnabled(hostId, policy)) {
+            hostsSkipped.push(hostId);
+            continue;
+        }
+        for (const skill of inventory) {
+            const rel = hostSkillRelativePath(hostId, skill.dir);
+            const segments = rel.split("/");
+            const abs = projectionTarget(projectDir, ...segments);
+            let existing = null;
+            if (existsSync(abs)) {
+                try {
+                    existing = readFileSync(abs, "utf8");
+                }
+                catch {
+                    existing = null;
+                }
+            }
+            if (existing === skill.content) {
+                continue;
+            }
+            // Never clobber consumer-authored host skills. Only create missing
+            // files or rewrite prior managed thin pointers (#75 Greptile P1).
+            if (existing !== null && !isThinSkillPointer(existing)) {
+                io.printf(`Skill discovery (#75): preserving consumer skill at ${rel} (not a managed thin pointer).\n`);
+                continue;
+            }
+            containedProjectWrite(projectDir, abs, skill.content);
+            changedPaths.push(rel.replace(/\\/g, "/"));
+            hostsTouched.add(hostId);
+        }
+    }
+    if (hostsSkipped.length > 0) {
+        io.printf(`Skill discovery multi-host opt-out (plan.policy.hostSkillDiscovery): skipped ${hostsSkipped.join(", ")}\n`);
+    }
+    if (changedPaths.length > 0) {
+        const hostList = [...hostsTouched].join(", ");
+        io.printf(`Multi-host skill discovery deposit (#75): wrote ${changedPaths.length} thin pointer(s) for host(s): ${hostList}\n`);
+    }
+    else if (hostsSkipped.length < SKILL_DISCOVERY_HOSTS.length) {
+        io.printf("Multi-host skill discovery deposit (#75): already current — skipping.\n");
+    }
+    return {
+        changed: changedPaths.length > 0,
+        changedPaths,
+        hostsTouched: [...hostsTouched],
+        hostsSkipped,
+    };
+}
+/**
+ * Shared inventory helper for `.agents/skills/` (canonical) deposit.
+ * Returns true when any pointer was created (matching writeAgentsSkills).
+ */
+export function writeAgentsSkillsFromInventory(projectDir, io, inventory = CONSUMER_SKILL_DISCOVERY_INVENTORY) {
+    projectionTarget(projectDir, ".agents");
+    const allExist = inventory.every((skill) => existsSync(join(projectDir, ".agents", "skills", skill.dir, "SKILL.md")));
+    if (allExist) {
+        io.printf(".agents/skills/ already present — skipping.\n");
+        return false;
+    }
+    for (const skill of inventory) {
+        if (!isThinSkillPointer(skill.content)) {
+            throw new Error(`skill discovery inventory entry "${skill.dir}" is not a thin pointer (#75).`);
+        }
+        const path = projectionTarget(projectDir, ".agents", "skills", skill.dir, "SKILL.md");
+        if (existsSync(path))
+            continue;
+        containedProjectWrite(projectDir, path, skill.content);
+    }
+    io.printf(".agents/skills/ created — deft skills will be auto-discovered.\n");
+    return true;
+}
+//# sourceMappingURL=skill-discovery-deposit.js.map

package/dist/init-deposit/skill-discovery-hosts.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Multi-host skill discovery layouts + per-host opt-out (#75 residual).
+ *
+ * Deposits **skill** discovery dirs (thin SKILL.md pointers). Distinct from
+ * epic #55 slash/command paths (`.claude/commands/`, `.codex/prompts/`, …).
+ *
+ * | Host id | Relative skills directory |
+ * |---------|---------------------------|
+ * | claude  | `.claude/skills`          |
+ * | cursor  | `.cursor/skills`          |
+ * | codex   | `.codex/skills`           |
+ * | github  | `.github/skills`          |
+ *
+ * Policy: `plan.policy.hostSkillDiscovery` — per-host boolean, default all true.
+ * Opt-out skips deposit for that host only.
+ */
+/** Hosts with a known residual skill-discovery path matrix (#75). */
+export declare const SKILL_DISCOVERY_HOSTS: readonly ["claude", "cursor", "codex", "github"];
+export type SkillDiscoveryHostId = (typeof SKILL_DISCOVERY_HOSTS)[number];
+/** Repo-relative layout for one host’s skill discovery tree. */
+export interface HostSkillDiscoveryLayout {
+    readonly hostId: SkillDiscoveryHostId;
+    /**
+     * Repo-relative directory (posix, no trailing slash).
+     * Example: `.claude/skills`
+     */
+    readonly relativeDir: string;
+    /** Typical agent product that scans this path. */
+    readonly typicalHost: string;
+    /**
+     * Filename under `{relativeDir}/{skillDir}/` (always `SKILL.md` for v1 —
+     * same thin-pointer format as `.agents/skills/`).
+     */
+    readonly skillFilename: string;
+}
+/**
+ * Documented host id → skills directory mapping (#75 residual matrix).
+ * Frozen; additive registration only.
+ */
+export declare const HOST_SKILL_DISCOVERY_LAYOUTS: Readonly<Record<SkillDiscoveryHostId, HostSkillDiscoveryLayout>>;
+export declare const FIELD_HOST_SKILL_DISCOVERY = "plan.policy.hostSkillDiscovery";
+export declare const FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS = "hostSkillDiscovery";
+/** Per-host skill discovery deposit toggles (#75). Default: all enabled. */
+export type HostSkillDiscoveryPolicy = Record<SkillDiscoveryHostId, boolean>;
+export declare const DEFAULT_HOST_SKILL_DISCOVERY_POLICY: HostSkillDiscoveryPolicy;
+export interface HostSkillDiscoveryPolicyField {
+    readonly name: string;
+    readonly current: HostSkillDiscoveryPolicy;
+    readonly default: HostSkillDiscoveryPolicy;
+    readonly source: string;
+}
+/** Type guard for {@link SkillDiscoveryHostId}. */
+export declare function isSkillDiscoveryHostId(value: string): value is SkillDiscoveryHostId;
+/** Stable list of residual skill-discovery hosts. */
+export declare function listSkillDiscoveryHosts(): readonly SkillDiscoveryHostId[];
+/** Look up the documented layout for a host, or throw. */
+export declare function getHostSkillDiscoveryLayout(hostId: SkillDiscoveryHostId): HostSkillDiscoveryLayout;
+export interface ResolvedHostSkillDiscoveryPolicy {
+    readonly policy: HostSkillDiscoveryPolicy;
+    /** Non-empty when raw policy was malformed; callers SHOULD surface these. */
+    readonly warnings: readonly string[];
+    /**
+     * True when the entire raw value is unusable (not an object). Deposit SHOULD
+     * skip all hosts rather than silently apply defaults after a bad opt-out.
+     */
+    readonly refuseAll: boolean;
+}
+/**
+ * Resolve typed host skill discovery policy from raw PROJECT-DEFINITION value.
+ * Fail-closed on malformed opt-outs (#75 Greptile P1): bad host values disable
+ * that host; wholly non-object values refuse all multi-host deposit.
+ */
+export declare function resolveHostSkillDiscoveryPolicyDetailed(raw: unknown): ResolvedHostSkillDiscoveryPolicy;
+/** Resolve typed host skill discovery policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostSkillDiscoveryPolicy(raw: unknown): HostSkillDiscoveryPolicy;
+export declare function validateHostSkillDiscovery(value: unknown): string[];
+export declare function isHostSkillDiscoveryEnabled(host: SkillDiscoveryHostId, policy?: HostSkillDiscoveryPolicy): boolean;
+/** Inspector row for `policy:show --field=hostSkillDiscovery`. */
+export declare function inspectHostSkillDiscovery(data: Record<string, unknown> | null): HostSkillDiscoveryPolicyField;
+/** Load raw hostSkillDiscovery value from PROJECT-DEFINITION, if present. */
+export declare function loadHostSkillDiscoveryRawFromProject(projectRoot: string): unknown;
+/** Resolve host skill discovery policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostSkillDiscoveryPolicyFromProject(projectRoot: string): HostSkillDiscoveryPolicy;
+/**
+ * Resolve policy + validation warnings from PROJECT-DEFINITION for deposit.
+ * Surfaces malformed opt-outs so init/update can report them (#75 Greptile P1).
+ */
+export declare function loadHostSkillDiscoveryPolicyDetailedFromProject(projectRoot: string): ResolvedHostSkillDiscoveryPolicy;
+/**
+ * Repo-relative posix path for one skill under a host layout.
+ * Example: `.claude/skills/deft-directive-build/SKILL.md`
+ */
+export declare function hostSkillRelativePath(hostId: SkillDiscoveryHostId, skillDir: string): string;
+//# sourceMappingURL=skill-discovery-hosts.d.ts.map

package/dist/init-deposit/skill-discovery-hosts.js

@@ -0,0 +1,217 @@
+/**
+ * Multi-host skill discovery layouts + per-host opt-out (#75 residual).
+ *
+ * Deposits **skill** discovery dirs (thin SKILL.md pointers). Distinct from
+ * epic #55 slash/command paths (`.claude/commands/`, `.codex/prompts/`, …).
+ *
+ * | Host id | Relative skills directory |
+ * |---------|---------------------------|
+ * | claude  | `.claude/skills`          |
+ * | cursor  | `.cursor/skills`          |
+ * | codex   | `.codex/skills`           |
+ * | github  | `.github/skills`          |
+ *
+ * Policy: `plan.policy.hostSkillDiscovery` — per-host boolean, default all true.
+ * Opt-out skips deposit for that host only.
+ */
+import { readPlanPolicy } from "../policy/plan-extensions.js";
+import { loadProjectDefinition } from "../policy/resolve.js";
+/** Hosts with a known residual skill-discovery path matrix (#75). */
+export const SKILL_DISCOVERY_HOSTS = ["claude", "cursor", "codex", "github"];
+/**
+ * Documented host id → skills directory mapping (#75 residual matrix).
+ * Frozen; additive registration only.
+ */
+export const HOST_SKILL_DISCOVERY_LAYOUTS = Object.freeze({
+    claude: Object.freeze({
+        hostId: "claude",
+        relativeDir: ".claude/skills",
+        typicalHost: "Claude Code",
+        skillFilename: "SKILL.md",
+    }),
+    cursor: Object.freeze({
+        hostId: "cursor",
+        relativeDir: ".cursor/skills",
+        typicalHost: "Cursor",
+        skillFilename: "SKILL.md",
+    }),
+    codex: Object.freeze({
+        hostId: "codex",
+        relativeDir: ".codex/skills",
+        typicalHost: "OpenAI Codex",
+        skillFilename: "SKILL.md",
+    }),
+    github: Object.freeze({
+        hostId: "github",
+        relativeDir: ".github/skills",
+        typicalHost: "GitHub Copilot",
+        skillFilename: "SKILL.md",
+    }),
+});
+export const FIELD_HOST_SKILL_DISCOVERY = "plan.policy.hostSkillDiscovery";
+export const FIELD_HOST_SKILL_DISCOVERY_CLI_ALIAS = "hostSkillDiscovery";
+export const DEFAULT_HOST_SKILL_DISCOVERY_POLICY = {
+    claude: true,
+    cursor: true,
+    codex: true,
+    github: true,
+};
+/** Type guard for {@link SkillDiscoveryHostId}. */
+export function isSkillDiscoveryHostId(value) {
+    return SKILL_DISCOVERY_HOSTS.includes(value);
+}
+/** Stable list of residual skill-discovery hosts. */
+export function listSkillDiscoveryHosts() {
+    return SKILL_DISCOVERY_HOSTS;
+}
+/** Look up the documented layout for a host, or throw. */
+export function getHostSkillDiscoveryLayout(hostId) {
+    const layout = HOST_SKILL_DISCOVERY_LAYOUTS[hostId];
+    if (layout === undefined) {
+        throw new Error(`No skill discovery layout for host: ${hostId}`);
+    }
+    return layout;
+}
+/**
+ * Resolve one host toggle. Malformed present values fail closed to **disabled**
+ * (do not silently enable deposit when the operator attempted an opt-out shape).
+ */
+function readHostBoolean(rec, host, fallback, warnings) {
+    if (!(host in rec)) {
+        return fallback;
+    }
+    const value = rec[host];
+    if (typeof value === "boolean") {
+        return value;
+    }
+    warnings.push(`${FIELD_HOST_SKILL_DISCOVERY}.${host} must be a boolean (got ${typeof value}); treating as disabled`);
+    return false;
+}
+/**
+ * Resolve typed host skill discovery policy from raw PROJECT-DEFINITION value.
+ * Fail-closed on malformed opt-outs (#75 Greptile P1): bad host values disable
+ * that host; wholly non-object values refuse all multi-host deposit.
+ */
+export function resolveHostSkillDiscoveryPolicyDetailed(raw) {
+    if (raw === null || raw === undefined) {
+        return {
+            policy: { ...DEFAULT_HOST_SKILL_DISCOVERY_POLICY },
+            warnings: [],
+            refuseAll: false,
+        };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return {
+            policy: {
+                claude: false,
+                cursor: false,
+                codex: false,
+                github: false,
+            },
+            warnings: [
+                `${FIELD_HOST_SKILL_DISCOVERY} must be an object; got ${typeof raw} — multi-host skill discovery deposit skipped`,
+            ],
+            refuseAll: true,
+        };
+    }
+    const rec = raw;
+    const warnings = [];
+    for (const key of Object.keys(rec)) {
+        if (!isSkillDiscoveryHostId(key)) {
+            warnings.push(`${FIELD_HOST_SKILL_DISCOVERY}.${key} is not a skill-discovery host (${SKILL_DISCOVERY_HOSTS.join(", ")})`);
+        }
+    }
+    const policy = {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_SKILL_DISCOVERY_POLICY.claude, warnings),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_SKILL_DISCOVERY_POLICY.cursor, warnings),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_SKILL_DISCOVERY_POLICY.codex, warnings),
+        github: readHostBoolean(rec, "github", DEFAULT_HOST_SKILL_DISCOVERY_POLICY.github, warnings),
+    };
+    return { policy, warnings, refuseAll: false };
+}
+/** Resolve typed host skill discovery policy from raw PROJECT-DEFINITION value. */
+export function resolveHostSkillDiscoveryPolicy(raw) {
+    return resolveHostSkillDiscoveryPolicyDetailed(raw).policy;
+}
+export function validateHostSkillDiscovery(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_SKILL_DISCOVERY} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of SKILL_DISCOVERY_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_SKILL_DISCOVERY}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!isSkillDiscoveryHostId(key)) {
+            errors.push(`${FIELD_HOST_SKILL_DISCOVERY}.${key} is not a skill-discovery host (${SKILL_DISCOVERY_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostSkillDiscoveryEnabled(host, policy = DEFAULT_HOST_SKILL_DISCOVERY_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_SKILL_DISCOVERY,
+        current: resolved,
+        default: DEFAULT_HOST_SKILL_DISCOVERY_POLICY,
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostSkillDiscovery`. */
+export function inspectHostSkillDiscovery(data) {
+    if (data === null) {
+        return fieldFromResolved(DEFAULT_HOST_SKILL_DISCOVERY_POLICY, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSkillDiscovery" in policyBlock)) {
+        return fieldFromResolved(DEFAULT_HOST_SKILL_DISCOVERY_POLICY, "default");
+    }
+    const resolved = resolveHostSkillDiscoveryPolicy(policyBlock.hostSkillDiscovery);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Load raw hostSkillDiscovery value from PROJECT-DEFINITION, if present. */
+export function loadHostSkillDiscoveryRawFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return undefined;
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostSkillDiscovery" in policyBlock)) {
+        return undefined;
+    }
+    return policyBlock.hostSkillDiscovery;
+}
+/** Resolve host skill discovery policy from PROJECT-DEFINITION on disk. */
+export function loadHostSkillDiscoveryPolicyFromProject(projectRoot) {
+    return resolveHostSkillDiscoveryPolicy(loadHostSkillDiscoveryRawFromProject(projectRoot));
+}
+/**
+ * Resolve policy + validation warnings from PROJECT-DEFINITION for deposit.
+ * Surfaces malformed opt-outs so init/update can report them (#75 Greptile P1).
+ */
+export function loadHostSkillDiscoveryPolicyDetailedFromProject(projectRoot) {
+    return resolveHostSkillDiscoveryPolicyDetailed(loadHostSkillDiscoveryRawFromProject(projectRoot));
+}
+/**
+ * Repo-relative posix path for one skill under a host layout.
+ * Example: `.claude/skills/deft-directive-build/SKILL.md`
+ */
+export function hostSkillRelativePath(hostId, skillDir) {
+    const layout = getHostSkillDiscoveryLayout(hostId);
+    return `${layout.relativeDir}/${skillDir}/${layout.skillFilename}`;
+}
+//# sourceMappingURL=skill-discovery-hosts.js.map

package/dist/init-deposit/slash-deposit.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Multi-host init/update deposit for native slash command files (#3054 / epic #55).
+ *
+ * Wires #3053 emitters into the init/update deposit path:
+ * - Default enabled set = hosts with real emitters (L6)
+ * - Per-host opt-out via `plan.policy.hostSlashCommands`
+ * - Idempotent managed rewrite (no duplicate pile-up)
+ * - Prefer commit of **managed product paths only** (L8) — exact allowlist, not whole dirs
+ *
+ * Parallel to agent-hooks deposit; does not touch hook JSON configs.
+ *
+ * Ownership: only create/update/remove files that are missing or still look like
+ * Directive thin wrappers (`isThinWrapperMarkdown`). Consumer-customized content
+ * at a product filename is left untouched.
+ */
+import { type HostSlashCommandsPolicy } from "../policy/host-slash-commands.js";
+import { type SlashEmitterHostId } from "../slash/index.js";
+import type { InitDepositIo } from "./constants.js";
+export interface SlashCommandDepositResult {
+    readonly changed: boolean;
+    /** Repo-relative paths written or updated. */
+    readonly writtenPaths: string[];
+    /** Repo-relative paths removed on opt-out (managed product files only). */
+    readonly removedPaths: string[];
+    /** Repo-relative paths skipped because consumer content is not managed. */
+    readonly preservedCustomPaths: string[];
+    /** Hosts that received a deposit pass (policy enabled). */
+    readonly depositedHosts: SlashEmitterHostId[];
+    /** Hosts skipped by policy opt-out. */
+    readonly skippedHosts: SlashEmitterHostId[];
+}
+/**
+ * Write thin-wrapper command/prompt files for every policy-enabled host.
+ *
+ * Idempotent: skips files whose on-disk bytes already match emission.
+ * Ownership-safe: never overwrites non-thin consumer customizations at product paths.
+ * Opt-out: removes managed thin wrappers only (leaves user customizations alone).
+ */
+export declare function writeSlashCommandDeposit(projectRoot: string, io?: InitDepositIo, policy?: HostSlashCommandsPolicy): SlashCommandDepositResult;
+/**
+ * Exact repo-relative product command paths (all emitter hosts).
+ * Used by installerManagedMatchers for L8 prefer-commit staging without
+ * claiming whole host command directories (consumer custom files stay app-owned).
+ */
+export declare function slashCommandManagedExactPaths(): readonly string[];
+//# sourceMappingURL=slash-deposit.d.ts.map