@crouton-kit/crouter 0.3.31 → 0.3.33

package/dist/core/hearth/providers/types.d.ts

@@ -0,0 +1,72 @@
+import type { MachineId, MachineRef, MachineState, M0Config, RouteRef } from '../types.js';
+export interface ExecResult {
+    exitCode: number | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    raw?: Record<string, unknown> | null;
+}
+export interface ExecInput {
+    command: string;
+    timeoutMs?: number;
+    background?: boolean;
+    env?: Record<string, string>;
+    cwd?: string;
+}
+export interface VolumeRef {
+    volumeId: string;
+    name: string;
+    raw?: Record<string, unknown> | null;
+}
+export interface CreateMachineInput {
+    tenantId: string;
+    template?: string | null;
+    envs?: Record<string, string>;
+    enableNetwork?: boolean;
+    name?: string | null;
+    ports?: {
+        target: number;
+        protocol: 'HTTP';
+    }[];
+    volumeMount?: {
+        volumeName: string;
+        path: string;
+    } | null;
+    raw?: Record<string, unknown> | null;
+}
+export interface PublishHttpPortInput {
+    machineId: MachineId;
+    targetPort: number;
+    subdomain?: string | null;
+    routeId?: string | null;
+    routeName?: string | null;
+    raw?: Record<string, unknown> | null;
+}
+export interface HealthResult {
+    ok: boolean;
+    providerName: string;
+    status?: string | null;
+    raw?: Record<string, unknown> | null;
+}
+export type DestroyOutcome = {
+    kind: 'destroyed';
+} | {
+    kind: 'not_found';
+};
+export interface MachineProvider {
+    readonly providerName: 'blaxel';
+    createVolume(input: {
+        name: string;
+    }): Promise<VolumeRef>;
+    createMachine(input: CreateMachineInput): Promise<MachineRef>;
+    getMachine(machineId: MachineId): Promise<MachineRef>;
+    exec(machineId: MachineId, input: ExecInput): Promise<ExecResult>;
+    waitForPort(machineId: MachineId, port: number, opts?: {
+        maxWaitMs?: number;
+    }): Promise<void>;
+    publishHttpPort(machineId: MachineId, input: PublishHttpPortInput): Promise<RouteRef>;
+    health(): Promise<HealthResult>;
+    destroy(machineId: MachineId): Promise<DestroyOutcome>;
+    destroyVolume(volumeId: string): Promise<DestroyOutcome>;
+}
+export type { MachineState, M0Config, RouteRef };

package/dist/core/hearth/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/hearth/registry.d.ts

@@ -0,0 +1,15 @@
+import type { HomeRecord, TenantId } from './types.js';
+export type RegistryData = Record<TenantId, HomeRecord>;
+export declare class RegistryLockError extends Error {
+    readonly lockPath: string;
+    readonly holder: string;
+    readonly ageMs: number | null;
+    constructor(lockPath: string, holder: string, ageMs: number | null);
+}
+export declare function acquireRegistryLock(registryPath: string): () => void;
+export declare function readRegistry(registryPath: string): RegistryData;
+export declare function writeRegistry(registryPath: string, data: RegistryData): RegistryData;
+export declare function getHome(registryPath: string, tenantId: TenantId): HomeRecord | null;
+export declare function putHome(registryPath: string, home: HomeRecord): HomeRecord;
+export declare function updateHome(registryPath: string, tenantId: TenantId, mutate: (home: HomeRecord) => HomeRecord | void): HomeRecord;
+export declare function listHomes(registryPath: string): HomeRecord[];

package/dist/core/hearth/registry.js

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, chmodSync } from 'node:fs';
+import { dirname, join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { general } from '../errors.js';
+import { nowIso } from '../fs-utils.js';
+const LOCK_STALE_MS = 2 * 60_000;
+function expandHomePath(path) {
+    if (path.startsWith('~'))
+        return join(homedir(), path.slice(1));
+    return path;
+}
+function registryLockPath(registryPath) {
+    return `${registryPath}.lock`;
+}
+function lockOwnerPath(lockPath) {
+    return join(lockPath, 'owner.json');
+}
+function ensureParentDir(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+function normalizeRegistry(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [tenantId, record] of Object.entries(value)) {
+        if (record === null || typeof record !== 'object' || Array.isArray(record))
+            continue;
+        const obj = record;
+        if (typeof obj.tenantId !== 'string' || obj.tenantId === '')
+            continue;
+        out[tenantId] = obj;
+    }
+    return out;
+}
+function atomicWriteJson(path, value) {
+    ensureParentDir(path);
+    const tmp = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    const content = JSON.stringify(value, null, 2) + '\n';
+    writeFileSync(tmp, content, { encoding: 'utf8', mode: 0o600 });
+    try {
+        renameSync(tmp, path);
+        chmodSync(path, 0o600);
+    }
+    catch (error) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            /* ignore */
+        }
+        throw error;
+    }
+}
+function lockDiagnostics(lockPath) {
+    let holder = lockPath;
+    let ageMs = null;
+    let stale = false;
+    try {
+        const st = statSync(lockPath);
+        ageMs = Date.now() - st.mtimeMs;
+        stale = ageMs >= LOCK_STALE_MS;
+    }
+    catch {
+        /* ignore */
+    }
+    const ownerFile = lockOwnerPath(lockPath);
+    try {
+        const owner = JSON.parse(readFileSync(ownerFile, 'utf8'));
+        if (typeof owner.holder === 'string' && owner.holder !== '')
+            holder = owner.holder;
+        else if (typeof owner.pid === 'number')
+            holder = `pid ${owner.pid}`;
+        else if (typeof owner.startedAt === 'string')
+            holder = owner.startedAt;
+    }
+    catch {
+        /* ignore */
+    }
+    return { holder, ageMs, stale };
+}
+export class RegistryLockError extends Error {
+    lockPath;
+    holder;
+    ageMs;
+    constructor(lockPath, holder, ageMs) {
+        super(ageMs === null
+            ? `registry lock held at ${lockPath} by ${holder}`
+            : `registry lock held at ${lockPath} by ${holder} (${Math.ceil(ageMs / 1000)}s old)`);
+        this.lockPath = lockPath;
+        this.holder = holder;
+        this.ageMs = ageMs;
+        this.name = 'RegistryLockError';
+    }
+}
+export function acquireRegistryLock(registryPath) {
+    const lockPath = registryLockPath(registryPath);
+    ensureParentDir(lockPath);
+    try {
+        mkdirSync(lockPath, { mode: 0o700 });
+    }
+    catch (error) {
+        const diagnostics = lockDiagnostics(lockPath);
+        throw new RegistryLockError(lockPath, diagnostics.holder, diagnostics.ageMs);
+    }
+    const owner = {
+        holder: `${process.pid}@${basename(registryPath)}:${nowIso()}`,
+        pid: process.pid,
+        startedAt: nowIso(),
+        cwd: process.cwd(),
+    };
+    atomicWriteJson(lockOwnerPath(lockPath), owner);
+    return () => {
+        try {
+            rmSync(lockPath, { recursive: true, force: true });
+        }
+        catch {
+            /* ignore */
+        }
+    };
+}
+export function readRegistry(registryPath) {
+    const path = expandHomePath(registryPath);
+    if (!existsSync(path))
+        return {};
+    return normalizeRegistry(readJson(path));
+}
+export function writeRegistry(registryPath, data) {
+    const path = expandHomePath(registryPath);
+    const release = acquireRegistryLock(path);
+    try {
+        atomicWriteJson(path, data);
+        return data;
+    }
+    finally {
+        release();
+    }
+}
+export function getHome(registryPath, tenantId) {
+    const registry = readRegistry(registryPath);
+    return registry[tenantId] ?? null;
+}
+export function putHome(registryPath, home) {
+    const path = expandHomePath(registryPath);
+    const release = acquireRegistryLock(path);
+    try {
+        const registry = readRegistry(path);
+        registry[home.tenantId] = home;
+        atomicWriteJson(path, registry);
+        return home;
+    }
+    finally {
+        release();
+    }
+}
+export function updateHome(registryPath, tenantId, mutate) {
+    const path = expandHomePath(registryPath);
+    const release = acquireRegistryLock(path);
+    try {
+        const registry = readRegistry(path);
+        const current = registry[tenantId];
+        if (current === undefined) {
+            throw general(`no home for tenant ${tenantId}`, { tenantId, registryPath: path });
+        }
+        const draft = { ...current };
+        const next = mutate(draft) ?? draft;
+        registry[tenantId] = next;
+        atomicWriteJson(path, registry);
+        return next;
+    }
+    finally {
+        release();
+    }
+}
+export function listHomes(registryPath) {
+    return Object.values(readRegistry(registryPath)).sort((a, b) => a.tenantId.localeCompare(b.tenantId));
+}

package/dist/core/hearth/types.d.ts

@@ -0,0 +1,121 @@
+export type TenantId = string;
+export type MachineId = string;
+export type SnapshotId = string;
+export type RouteId = string;
+export type RelayToken = string;
+export type GuestNodeId = string;
+export type MachineState = 'provisioning' | 'running' | 'paused' | 'stopped' | 'suspended' | 'restoring' | 'terminating' | 'terminated' | 'unknown' | string;
+export type RouteUrlSource = 'provider' | 'config' | 'derived' | 'unknown';
+export interface HomeStorageRef {
+    kind: 'volume';
+    durability: 'durable-volume';
+    longTermContract: true;
+    ownerMachineId: MachineId;
+    guestHome: string;
+    volumeId: string;
+    mountPath: string;
+}
+export interface MachineRef {
+    providerName: string;
+    machineId: MachineId;
+    state: MachineState;
+    guestIp?: string | null;
+    sshPort?: number | null;
+    updatedAt?: string | null;
+    raw?: Record<string, unknown> | null;
+}
+export interface SnapshotRef {
+    snapshotId: SnapshotId;
+    machineId: MachineId;
+    stateKey?: string | null;
+    memoryKey?: string | null;
+    diskKey?: string | null;
+    sizeBytes?: number | null;
+    createdAt?: string | null;
+    raw?: Record<string, unknown> | null;
+}
+export interface RouteRef {
+    routeId: RouteId;
+    machineId: MachineId;
+    targetPort: number;
+    url?: string | null;
+    subdomain?: string | null;
+    createdAt?: string | null;
+    concreteUrl?: string | null;
+    concreteUrlSource?: RouteUrlSource | null;
+    raw?: Record<string, unknown> | null;
+}
+export interface BootstrapMarker {
+    tenantId: TenantId;
+    nodeId: GuestNodeId;
+    daemonPid: number;
+    brokerPid: number;
+    crtrHome: string;
+    piAgentDir: string;
+    sessionFile?: string | null;
+    webPort: number;
+    createdAt: string;
+}
+export interface VerifyBaseline {
+    machineId: MachineId;
+    nodeId: GuestNodeId;
+    sessionFile: string;
+    sessionLineCount: number;
+    webPort: number;
+    capturedAt: string;
+    daemonPid?: number | null;
+    brokerPid?: number | null;
+    socketPath?: string | null;
+}
+export type VerifyPhase = 'pre-suspend' | 'post-restore' | 'post-recreate';
+export interface VerifyCheck {
+    name: string;
+    status: 'PASS' | 'FAIL';
+    detail?: string;
+    value?: string | number | boolean | null;
+}
+export interface VerifyResult {
+    phase: VerifyPhase;
+    checks: VerifyCheck[];
+    passed: boolean;
+    machineState: MachineState;
+    nodeId?: GuestNodeId | null;
+    routeUrl?: string | null;
+    hearth_m0_verified?: boolean;
+    hearth_m0_recreate_verified?: boolean;
+    warmResume?: boolean | null;
+    restoreLatencyMs?: number | null;
+    recreateLatencyMs?: number | null;
+    baseline?: VerifyBaseline | null;
+}
+export interface HomeRecord {
+    tenantId: TenantId;
+    providerName: string;
+    machineId: MachineId;
+    homeStorage: HomeStorageRef;
+    state: MachineState;
+    nodeId?: GuestNodeId | null;
+    webRoute?: RouteRef | null;
+    latestSnapshot?: SnapshotRef | null;
+    verifyBaseline?: VerifyBaseline | null;
+    bootstrapMarker?: BootstrapMarker | null;
+    relayToken?: RelayToken | null;
+    warmResume?: boolean | null;
+    restoreLatencyMs?: number | null;
+    recreateLatencyMs?: number | null;
+    createdAt: string;
+    updatedAt: string;
+    raw?: Record<string, unknown> | null;
+}
+export interface M0Config {
+    providerName: string;
+    registryPath: string;
+    guestUser: string;
+    guestHome: string;
+    guestCodePath: string;
+    piPackages: string[];
+    webPort: number;
+    nodeKind: string;
+    piAuthJson?: string | null;
+    relayToken?: RelayToken | null;
+}

package/dist/core/hearth/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/host-exports/__tests__/export-prunes-boot-skill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/host-exports/__tests__/export-prunes-boot-skill.test.js

@@ -0,0 +1,79 @@
+// Regression: crouter must not leave its old generated `crtr-skills` Agent Skill
+// installed in pi/Claude host skill dirs after memory became the first-class
+// guidance surface. The legacy bundle caused pi to inject an <available_skills>
+// block that described SKILL.md as current crouter behavior.
+//
+// Run: node --import tsx/esm --test src/core/host-exports/__tests__/export-prunes-boot-skill.test.ts
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { defineBranch, defineLeaf, defineRoot } from '../../command.js';
+import { provisionExports } from '../export.js';
+let home;
+let prevHome;
+let prevNoExports;
+beforeEach(() => {
+    prevHome = process.env.HOME;
+    prevNoExports = process.env.CRTR_NO_EXPORTS;
+    home = mkdtempSync(join(tmpdir(), 'crtr-export-prune-'));
+    process.env.HOME = home;
+    delete process.env.CRTR_NO_EXPORTS;
+    mkdirSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills'), { recursive: true });
+    mkdirSync(join(home, '.claude', 'skills', 'crtr-skills'), { recursive: true });
+    writeFileSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md'), '---\nname: crtr-skills\n---\n\n<!-- crtr-boot-skill v2 -->\n', 'utf8');
+    writeFileSync(join(home, '.claude', 'skills', 'crtr-skills', 'SKILL.md'), '---\nname: crtr-skills\n---\n\nuser-customized, no crtr marker\n', 'utf8');
+});
+afterEach(() => {
+    if (prevHome === undefined)
+        delete process.env.HOME;
+    else
+        process.env.HOME = prevHome;
+    if (prevNoExports === undefined)
+        delete process.env.CRTR_NO_EXPORTS;
+    else
+        process.env.CRTR_NO_EXPORTS = prevNoExports;
+    rmSync(home, { recursive: true, force: true });
+});
+const root = defineRoot({
+    tagline: 'fixture',
+    globals: [],
+    subtrees: [
+        defineBranch({
+            name: 'fixture',
+            help: { name: 'fixture', summary: 'fixture' },
+            rootEntry: { concept: 'fixture', desc: 'fixture', useWhen: 'fixture' },
+            children: [
+                defineLeaf({
+                    name: 'demo',
+                    help: {
+                        name: 'fixture demo',
+                        summary: 'demo',
+                        output: [],
+                        outputKind: 'object',
+                        effects: ['None. Read-only.'],
+                    },
+                    slash: {
+                        name: 'demo',
+                        description: 'demo command',
+                        body: 'run demo',
+                    },
+                    run: async () => ({}),
+                }),
+            ],
+        }),
+    ],
+});
+test('provisionExports prunes marker-bearing legacy boot skills and still writes slash commands', () => {
+    provisionExports(root, ['node', 'crtr', 'fixture']);
+    assert.equal(existsSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md')), false, 'marker-bearing pi crtr-skills bundle should be removed');
+    assert.equal(existsSync(join(home, '.claude', 'skills', 'crtr-skills', 'SKILL.md')), true, 'markerless user-owned Claude skill should not be removed');
+    assert.match(readFileSync(join(home, '.pi', 'agent', 'prompts', 'demo.md'), 'utf8'), /<!-- crtr-mode-cmd v1 -->/, 'pi slash-command export should still be provisioned');
+    assert.match(readFileSync(join(home, '.claude', 'commands', 'demo.md'), 'utf8'), /<!-- crtr-mode-cmd v1 -->/, 'Claude slash-command export should still be provisioned');
+});
+test('bare front-door argv prunes legacy boot skills before pi can start', () => {
+    provisionExports(root, ['node', 'crtr']);
+    assert.equal(existsSync(join(home, '.pi', 'agent', 'skills', 'crtr-skills', 'SKILL.md')), false, 'bare crtr must remove stale pi crtr-skills before booting pi');
+    assert.equal(existsSync(join(home, '.pi', 'agent', 'prompts', 'demo.md')), false, 'bare front-door pruning must not provision slash-command prompts');
+});

package/dist/core/{skill-sync → host-exports}/builtins.d.ts

@@ -1,13 +1,10 @@
 /**
- * Built-in export registry for the skill-sync subsystem.
+ * Built-in export registry for crtr-generated host artifacts.
  *
- * These are the crtr-*generated* host artifacts — the `crtr-skills` boot skill
- * and any CLI slash-commands. Unlike the user-authored bidirectional manifest
- * pairs (engine.ts), an export pair has a single source of truth (code), so it
- * is one-way: render → marker-guarded write (see export.ts). The generators
- * (`bootSkillBody`, `renderSlashTemplate`) and their version markers were moved
- * here verbatim from bootstrap.ts when skill-sync became the sole host writer —
- * marker strings are byte-identical so already-deployed artifacts roll forward.
+ * Slash-command templates are one-way exports: code is the single source of
+ * truth, so crtr renders them into host prompt/command dirs with marker-guarded
+ * writes (see export.ts). Legacy generated Agent Skills are listed only as
+ * cleanup targets; crouter's first-class guidance surface is memory docs.
  */
 import type { RootDef } from '../command.js';
 /** A host runtime crtr exports generated artifacts into. */
@@ -23,7 +20,7 @@ export interface HostTarget {
 }
 /** One crtr-generated export artifact and every host it reaches. */
 export interface ExportPair {
-    /** Stable id for logging, e.g. `@boot/crtr-skills` or `@cmd/<name>`. */
+    /** Stable id for logging, e.g. `@cmd/<name>`. */
     id: string;
     /** On-disk artifact name (bundle dir name or file stem). */
     name: string;
@@ -34,9 +31,20 @@ export interface ExportPair {
     /** Every host destination. Targets with an absent host root are skipped. */
     targets: HostTarget[];
 }
-export declare const BOOT_SKILL_MARKER_PREFIX = "<!-- crtr-boot-skill v";
+/** A legacy crtr-generated artifact that should be removed if still present. */
+export interface LegacyExportArtifact {
+    /** Stable id for logging/debugging. */
+    id: string;
+    /** On-disk artifact name (bundle dir name or file stem). */
+    name: string;
+    /** Marker prefix identifying a crtr-owned file. Markerless files are user-owned. */
+    markerPrefix: string;
+    /** Every host destination. Targets with an absent host root are skipped. */
+    targets: HostTarget[];
+}
 export declare const SLASH_CMD_MARKER_PREFIX = "<!-- crtr-mode-cmd v";
-/** The crtr-generated export artifacts for this command tree: the boot skill
- *  (both hosts, bundle layout) plus one pair per opted-in slash command (both
- *  hosts, file layout). */
+/** Legacy crtr-generated exports that should not survive after the memory cutover. */
+export declare function legacyExportArtifacts(): LegacyExportArtifact[];
+/** The crtr-generated export artifacts for this command tree: one pair per
+ *  opted-in slash command (both hosts, file layout). */
 export declare function builtinExportPairs(root: RootDef): ExportPair[];

package/dist/core/host-exports/builtins.js

@@ -0,0 +1,68 @@
+/**
+ * Built-in export registry for crtr-generated host artifacts.
+ *
+ * Slash-command templates are one-way exports: code is the single source of
+ * truth, so crtr renders them into host prompt/command dirs with marker-guarded
+ * writes (see export.ts). Legacy generated Agent Skills are listed only as
+ * cleanup targets; crouter's first-class guidance surface is memory docs.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { collectSlashSpecs } from '../command.js';
+// ── Slash commands ───────────────────────────────────────────────────────────
+const SLASH_CMD_MARKER = '<!-- crtr-mode-cmd v1 -->';
+export const SLASH_CMD_MARKER_PREFIX = '<!-- crtr-mode-cmd v';
+/** Render a SlashSpec to a full template file (frontmatter + marker + body). */
+function renderSlashTemplate(spec) {
+    const hint = spec.argumentHint !== undefined
+        ? `argument-hint: ${JSON.stringify(spec.argumentHint)}\n`
+        : '';
+    return `---\ndescription: ${spec.description}\n${hint}---\n\n${SLASH_CMD_MARKER}\n\n${spec.body}\n`;
+}
+// ── Host roots ───────────────────────────────────────────────────────────────
+function claudeSkillsRoot() {
+    return join(homedir(), '.claude', 'skills');
+}
+function piSkillsRoot() {
+    return join(homedir(), '.pi', 'agent', 'skills');
+}
+function claudeCommandsRoot() {
+    return join(homedir(), '.claude', 'commands');
+}
+function piPromptsRoot() {
+    return join(homedir(), '.pi', 'agent', 'prompts');
+}
+// ── Registry ─────────────────────────────────────────────────────────────────
+const LEGACY_BOOT_SKILL_MARKER_PREFIX = '<!-- crtr-boot-skill v';
+/** Legacy crtr-generated exports that should not survive after the memory cutover. */
+export function legacyExportArtifacts() {
+    return [
+        {
+            id: '@legacy/crtr-skills',
+            name: 'crtr-skills',
+            markerPrefix: LEGACY_BOOT_SKILL_MARKER_PREFIX,
+            targets: [
+                { host: 'claude', dir: claudeSkillsRoot, layout: 'bundle' },
+                { host: 'pi', dir: piSkillsRoot, layout: 'bundle' },
+            ],
+        },
+    ];
+}
+/** The crtr-generated export artifacts for this command tree: one pair per
+ *  opted-in slash command (both hosts, file layout). */
+export function builtinExportPairs(root) {
+    const pairs = [];
+    for (const spec of collectSlashSpecs(root)) {
+        pairs.push({
+            id: `@cmd/${spec.name}`,
+            name: spec.name,
+            markerPrefix: SLASH_CMD_MARKER_PREFIX,
+            render: () => renderSlashTemplate(spec),
+            targets: [
+                { host: 'claude', dir: claudeCommandsRoot, layout: 'file' },
+                { host: 'pi', dir: piPromptsRoot, layout: 'file' },
+            ],
+        });
+    }
+    return pairs;
+}

package/dist/core/{skill-sync → host-exports}/export.d.ts

@@ -1,10 +1,12 @@
 /**
  * One-way export of crtr-generated host artifacts — the sole writer of
- * generated content to `~/.claude/skills`, `~/.claude/commands`, and
- * `~/.pi/agent/prompts`. Replaces the two host-dir writers that lived in
- * bootstrap.ts (`ensureBootSkill` + `ensureSlashCommands`), collapsing their
- * two clobber-guards into one `writeIfOurs` and their two kill-switches
- * (`CRTR_NO_BOOT_SKILL` / `CRTR_NO_MODE_CMDS`) into one `CRTR_NO_EXPORTS`.
+ * generated slash-command templates to `~/.claude/commands` and
+ * `~/.pi/agent/prompts`.
+ *
+ * crouter no longer exports Agent Skills / SKILL.md bundles. The export pass
+ * still prunes old marker-bearing `crtr-skills` bundles so hosts stop surfacing
+ * pi/Claude native skills after the memory cutover. Markerless files are
+ * user-owned and never removed.
  *
  * Triggered per-run by cli.ts (argv-gated, exactly as the old writers were) so
  * first-run provisioning is preserved. Best-effort: a provisioning fault must
@@ -17,7 +19,8 @@ import type { RootDef } from '../command.js';
  *  only the leaf dir, never the host root. The single generalization of
  *  bootstrap.ts's two clobber-guards. */
 export declare function writeIfOurs(path: string, content: string, markerPrefix: string): void;
-/** Render and write every built-in export artifact to every present host.
+/** Render and write every built-in export artifact to every present host, while
+ *  pruning legacy generated artifacts that should no longer be surfaced.
  *  Best-effort: swallows errors (debug-logged) so a provisioning fault never
  *  breaks an unrelated `crtr` command. Kill switch: `CRTR_NO_EXPORTS=1`. */
 export declare function provisionExports(root: RootDef, argv?: string[]): void;