@sentropic/h2a 0.98.5 → 0.98.7-rc.1

package/dist/cli.js

@@ -62,6 +62,13 @@ import { runHarnessCli, HARNESS_SKILLS } from "./vendor/harness/index.js";
 import { buildLaunchIndex } from "./runtime/local-files/launch-index.js";
 import { renderCommandMap } from "./cli-command-map.js";
 import { resolveHostConfigRoot } from "./runtime/host-config-root.js";
+import { isNativeHost, NATIVE_HOSTS, REGISTRY_WAITING, stateRoot, vibeHome } from "./hosts/native-paths.js";
+import { convergeNativeHost } from "./hosts/native-convergence.js";
+import { nativeSkillArtifacts } from "./hosts/native-skills.js";
+import { assertNativePath, atomicNativeWrite, snapshot as snapshotNativeFile } from "./hosts/native-files.js";
+import { clearVibeDirectRemoved, editVibeMcpServers, setVibeDirectRemoved, VIBE_MCP_NAME } from "./hosts/vibe-mcp.js";
+import { convergeAfterExplicitUpgrade } from "./hosts/upgrade-equipment.js";
+import { captureHostOperatorNotices } from "./hosts/operator-notices.js";
 import { H2A_ATTESTER_COMPREHENSION_RIGHT, H2A_COMPREHENSION_ATTESTATION_BODY_KIND, H2A_DECLARATION_INTERET_BODY_KIND, H2A_ORG_MANIFEST_FILENAME, H2A_ORG_PROPOSAL_BODY_KIND, H2A_ORG_RATIFIED_BODY_KIND, H2A_ROLES, H2A_WORK_STATUSES, auditNhiPosture, buildComprehensionAttestation, canAttestComprehension, checkEnvelopeFreshness, computeHash, createEnvelope, deriveWorkspaceId, diffOrgManifest, effectiveOrgInstances, isComprehensionAttestation, nhiAttestationEnvelope, nhiInventory, deriveConnectionConfidence, nhiTrustBundle, orgAssignmentEnvelope, parseOrgManifest, signCanonical, signEnvelope, subagentAddress, validateOrgManifest, verifyComprehensionAttestation } from "@sentropic/h2a";
 import { H2A_CLAUDE_HOST } from "./hosts/claude.js";
 import { H2A_CODEX_HOST } from "./hosts/codex.js";
@@ -263,9 +270,9 @@ export function renderCliHelp() {
         "  h2a drumbeat escalations [--root <path>]",
         "  h2a drumbeat relance-inbox [--instance <id>] [--relauncher logging|local-tmux|headless|auto] [--root <path>]",
         "  h2a drumbeat watch [--interval-ms <n>] [--max-relances <n>] [--relauncher logging|local-tmux|remote|headless|auto] [--instance <signer> --private-key <pem>] [--decider logging|<command>] [--decider-after <k>] [--decider-enforce] [--root <path>]",
-        "  h2a host setup --host <codex|claude|gemini|agy|hermes|opencode|muse|vibe> [--endpoint local|remote] [--url <https://…/mcp>] [--root <path>] [--print | --write <file>] [--force] [--no-wake]   (selects exactly one h2a endpoint; local renders mcp-serve --auto-open --auto-upgrade --wake auto by default)",
+        "  h2a host setup --host <codex|claude|gemini|agy|hermes|opencode|muse|vibe> [--endpoint local|remote] [--url <https://…/mcp>] [--root <path>] [--print | --write <file>] [--force] [--no-wake]   (selects one endpoint; Muse/agy render nonrecommended historical direct paths pending registry bootstrap; Vibe --write installs the interim direct entry pending registry bootstrap (--remove clears it for migration))",
         "  h2a host status [--host <name>]",
-        "  h2a host plugin --host <codex|claude|gemini|agy|hermes|opencode|muse|vibe> --instance <id> [--status <work-status>] [--root <path>] [--write <settings.json> [--force]] [--scaffold <dir>]   (--write installs the Stop hook for claude|gemini|codex|hermes|opencode; --scaffold writes codex's full local marketplace + trust step; vibe records via a post_agent hook in ~/.vibe/hooks.toml; agy and muse are poll-only)",
+        "  h2a host plugin --host <codex|claude|gemini|agy|hermes|opencode|muse|vibe> --instance <id> [--status <work-status>] [--root <path>] [--write <settings.json|hooks.toml> [--force]] [--scaffold <dir>]   (--write installs the Stop hook for claude|gemini|codex|hermes|opencode; --scaffold writes codex's full local marketplace + trust step; vibe writes its explicit parent-only wrapper to VIBE_HOME/hooks.toml; agy and muse have no qualified native hooks)",
         "  h2a store migrate [--from <v>] [--to <v>] [--sanitize-paths] [--dry-run] [--root <path>]",
         "  h2a store index-launch --root <absolute-path> (derived indexes; original logs retained)",
         "",
@@ -274,7 +281,7 @@ export function renderCliHelp() {
         "  h2a conductor [--workspace <id|path>] [--root <path>]   (who is the live conductor/owner of a workspace — derived from presence; conductor=role CONDUCTOR if set, else null; candidates=in-workspace live agents)",
         "  h2a conductor-launch-check [--workspace <id|path>] [--root <path>] [--idle-ms <ms>]   (DRY-RUN: polls track workspace-activity; recommends launching a conductor if work is stalled and none is live — h2a does NOT spawn; launch parked pending spawn policy + remote)",
         "  h2a conductor-launch --workspace <id|path> [--root <path>] [--idle-ms <ms>] [--confirm] [--remote <instance>] [--instance <self>]   (D3 EMIT: if stalled+no conductor, emits a launch-REQUEST envelope to a live remote agent — gated by --confirm + 1/30min/workspace cap; h2a NEVER spawns; remote does the actual spawn)",
-        "  h2a doctor [--root <path>] [--scan <dir>] [--prune] [--repair] [--dry-run]   (--repair converges Claude/Codex plugin installs; --repair --dry-run reports host findings/actions without changing them; --prune deletes host-less/phantom/orphan inbox dirs + stray buses; dry-run by default)",
+        "  h2a doctor [--root <path>] [--scan <dir>] [--prune] [--repair] [--dry-run] [--host <name>] [--skip-hosts] [--guard on|off] [--lifecycle on|off]   (--repair converges detected host components; --repair --dry-run reports host findings/actions without changing them; --prune deletes host-less/phantom/orphan inbox dirs + stray buses; dry-run by default)",
         "  h2a keepalive [--root <path>] [--interval <ms>] [--once]   (external keepalive prober — refreshes presence for agents whose tmux pane is still alive)",
         "  h2a rename --instance <id> --name <name> [--root <path>]   (set a live session's display name so peers can find it via discover --name)",
         "  h2a status [--root <path>] [--scope <s>] [--instance <i>]",
@@ -1486,19 +1493,20 @@ export function cmdUpgrade(flags, streams, runtime) {
     // the boot auto-upgrade (bounded — no infinite terminal wait). No cachePath is
     // passed, so it always checks fresh and is never throttled for an explicit run.
     const result = performAutoUpgrade(current, { ...(runtime ? { runtime } : {}) });
+    const hosts = convergeAfterExplicitUpgrade(result, flags);
     if (result.outcome === "upgraded") {
-        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target, upgraded: true, verified: result.verifiedVersion, package: H2A_CLI_PACKAGE, ...(result.logPath ? { log: result.logPath } : {}) }, null, 2)}\n`);
+        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target, upgraded: true, verified: result.verifiedVersion, package: H2A_CLI_PACKAGE, hosts, ...(result.logPath ? { log: result.logPath } : {}) }, null, 2)}\n`);
         return 0;
     }
     if (result.outcome === "already-current") {
-        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target ?? current, upgraded: false, reason: "already current or registry unreachable" }, null, 2)}\n`);
+        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target ?? current, upgraded: false, hosts, reason: "already current or registry unreachable" }, null, 2)}\n`);
         return 0;
     }
     // The target is published but not yet installable (propagation delay). A full
     // `npm i -g` would hit the same registry and fail too, so we do not force it;
     // the staged path retries on a later run. Nothing was mutated.
     if (result.outcome === "deferred-propagation") {
-        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target, upgraded: false, reason: "update published but not yet installable; retry later", ...(result.logPath ? { log: result.logPath } : {}) }, null, 2)}\n`);
+        streams.stdout.write(`${JSON.stringify({ ok: true, current, latest: result.target, upgraded: false, hosts, reason: "update published but not yet installable; retry later", ...(result.logPath ? { log: result.logPath } : {}) }, null, 2)}\n`);
         return 0;
     }
     // skipped-locked / failed.
@@ -3625,6 +3633,105 @@ function driveLineFromHookInput(raw) {
     }
     return driveLineFromText(raw);
 }
+function resolveVibeSetupTarget(flags) {
+    if (flags.write && flags.write !== "true")
+        return flags.write;
+    return join(vibeHome(), "config.toml");
+}
+function vibeWantedEntry(snippet) {
+    const incoming = snippet.config.mcpServers.h2a;
+    if (typeof incoming.url === "string")
+        return { name: VIBE_MCP_NAME, transport: "streamable-http", url: incoming.url };
+    return { name: VIBE_MCP_NAME, transport: "stdio", command: incoming.command ?? "h2a", args: [...(incoming.args ?? ["mcp-serve"])] };
+}
+function vibeStateForTarget(targetPath) {
+    return stateRoot("vibe", dirname(resolvePath(targetPath)));
+}
+function cmdVibeSetupWrite(flags, streams, snippet, endpoint) {
+    const targetPath = resolveVibeSetupTarget(flags);
+    if (!targetPath.toLowerCase().endsWith(".toml")) {
+        streams.stderr.write(`h2a host setup: --write for Vibe MCP supports TOML only and will not rewrite ${targetPath}. Use the default <VIBE_HOME>/config.toml.\n`);
+        return 1;
+    }
+    const wanted = vibeWantedEntry(snippet);
+    let original;
+    try {
+        if (!existsSync(targetPath))
+            original = "";
+        else
+            original = readFileSync(targetPath, "utf8");
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: cannot read ${targetPath} (${error.message})\n`);
+        return 3;
+    }
+    let edited;
+    try {
+        edited = editVibeMcpServers(original, wanted);
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: ${targetPath} refused (${error.message}); invalid or incompatible TOML is never overwritten, even with --force.\n`);
+        return 2;
+    }
+    if (!edited.changed) {
+        clearVibeDirectRemoved(vibeStateForTarget(targetPath));
+        streams.stdout.write(`${JSON.stringify({ ok: true, host: "vibe", endpoint, path: targetPath, merged: false, replacedH2a: false, removedH2aMcpServers: [], migration: "voie directe — non migrée" }, null, 2)}\n`);
+        return 0;
+    }
+    try {
+        atomicNativeWrite(targetPath, edited.text, { state: vibeStateForTarget(targetPath), expected: snapshotNativeFile(targetPath) });
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: cannot write ${targetPath} (${error.message})\n`);
+        return 3;
+    }
+    clearVibeDirectRemoved(vibeStateForTarget(targetPath));
+    streams.stdout.write(`${JSON.stringify({ ok: true, host: "vibe", endpoint, path: targetPath, merged: true, replacedH2a: edited.replacedH2a, removedH2aMcpServers: edited.removed, migration: "voie directe — non migrée" }, null, 2)}\n`);
+    streams.stderr.write(`# wrote the interim direct mcp_servers.h2a endpoint for host=vibe to ${targetPath} (owner 16/10, derogation O7.2; migration R5/R7: h2a host setup --host vibe --remove)\n# disabled duplicate h2a MCP entries: ${edited.removed.join(", ") || "none"}\n# ${snippet.path.hint}\n`);
+    return 0;
+}
+function cmdVibeSetupRemove(flags, streams) {
+    const targetPath = resolveVibeSetupTarget(flags);
+    if (!targetPath.toLowerCase().endsWith(".toml")) {
+        streams.stderr.write(`h2a host setup: --remove for Vibe MCP supports TOML only and will not rewrite ${targetPath}. Use the default <VIBE_HOME>/config.toml.\n`);
+        return 1;
+    }
+    let original;
+    try {
+        if (!existsSync(targetPath))
+            original = "";
+        else
+            original = readFileSync(targetPath, "utf8");
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: cannot read ${targetPath} (${error.message})\n`);
+        return 3;
+    }
+    let edited;
+    try {
+        edited = editVibeMcpServers(original, null);
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: ${targetPath} refused (${error.message}); invalid or incompatible TOML is never overwritten, even with --force.\n`);
+        return 2;
+    }
+    if (!edited.changed) {
+        setVibeDirectRemoved(vibeStateForTarget(targetPath));
+        streams.stdout.write(`${JSON.stringify({ ok: true, host: "vibe", path: targetPath, removed: false, migration: REGISTRY_WAITING }, null, 2)}\n`);
+        return 0;
+    }
+    try {
+        atomicNativeWrite(targetPath, edited.text, { state: vibeStateForTarget(targetPath), expected: snapshotNativeFile(targetPath) });
+    }
+    catch (error) {
+        streams.stderr.write(`h2a host setup: cannot write ${targetPath} (${error.message})\n`);
+        return 3;
+    }
+    setVibeDirectRemoved(vibeStateForTarget(targetPath));
+    streams.stdout.write(`${JSON.stringify({ ok: true, host: "vibe", path: targetPath, removed: true, removedH2aMcpServers: edited.removed, migration: REGISTRY_WAITING }, null, 2)}\n`);
+    streams.stderr.write(`# removed the interim direct mcp_servers.h2a endpoint for host=vibe from ${targetPath}; registry bootstrap expected.\n`);
+    return 0;
+}
 function cmdHostSetup(flags, streams, options) {
     const host = flags.host;
     if (!host) {
@@ -3714,9 +3821,16 @@ function cmdHostSetup(flags, streams, options) {
     }
     const targetPath = flags.write;
     const printMode = flags.print === "true" || !targetPath;
+    if (host === "vibe" && flags.remove === "true") {
+        return cmdVibeSetupRemove(flags, streams);
+    }
+    if (host === "vibe" && targetPath) {
+        return cmdVibeSetupWrite(flags, streams, snippet, endpoint);
+    }
     if (printMode && !targetPath) {
-        streams.stdout.write(`${JSON.stringify(snippet.config, null, 2)}\n`);
-        streams.stderr.write(`# ${host} — selected ${endpoint} h2a endpoint; paste this snippet under \`mcpServers\` in:\n# ${snippet.path.hint}\n# example path: ${snippet.path.example}\n`);
+        streams.stdout.write(`${JSON.stringify(isNativeHost(host) ? { ...snippet.config, migration: REGISTRY_WAITING, hint: snippet.path.hint } : snippet.config, null, 2)}\n`);
+        streams.stderr.write(isNativeHost(host) ? `# ${host}: rendu historique non recommandé; ${REGISTRY_WAITING}.\n# ${snippet.path.hint}\n` :
+            `# ${host} — selected ${endpoint} h2a endpoint; paste this snippet under \`mcpServers\` in:\n# ${snippet.path.hint}\n# example path: ${snippet.path.example}\n`);
         return reportHostSetupCoherence(host, streams, options) ? 0 : 2;
     }
     if (isUnsupportedHostWritePath(host, targetPath)) {
@@ -3803,6 +3917,7 @@ function cmdHostSetup(flags, streams, options) {
         replacedH2a,
         removedH2aMcpServers,
         removedTrackMcpServers,
+        ...(isNativeHost(host) ? { migration: "voie directe — non migrée" } : {}),
         ...(coherent ? {} : { next: "h2a doctor --repair" })
     }, null, 2)}\n`);
     streams.stderr.write(`# wrote the selected ${endpoint} mcpServers.h2a endpoint for host=${host} to ${targetPath}\n# disabled duplicate h2a MCP entries: ${removedH2aMcpServers.join(", ") || "none"}\n# disabled standalone Track MCP entries: ${removedTrackMcpServers.join(", ") || "none"}\n# ${snippet.path.hint}\n`);
@@ -3865,7 +3980,17 @@ function cmdHostStatus(flags, streams) {
             mcpAdapterShipped,
             hostSetupShipped,
             hostScenarioShipped,
-            summary
+            summary: hostScenarioShipped ? summary.replace('scenario shipped', 'rendu testé') : summary,
+            ...(isNativeHost(descriptor.host) ? { native: (() => {
+                    try {
+                        return nativeHostReport(descriptor.host, flags, false, false, undefined, streams.cwd?.());
+                    }
+                    catch (error) {
+                        return { ok: false, installation: 'inspection impossible', error: error.message };
+                    }
+                })() } : {
+                convergence: ['claude', 'codex'].includes(descriptor.host) ? 'historical doctor convergence; native parity unverified; registry non migré' : 'non couvert'
+            })
         };
     });
     streams.stdout.write(`${JSON.stringify({ ok: true, hosts }, null, 2)}\n`);
@@ -3885,6 +4010,24 @@ function cmdHostPlugin(flags, streams) {
         streams.stderr.write("h2a host plugin: --instance <id> is required\n");
         return 1;
     }
+    if (flags.host === 'vibe') {
+        try {
+            if (flags.instance === 'auto')
+                throw new Error('non disponible — interface B non livrée');
+            if (flags.write && resolvePath(flags.write) !== join(vibeHome(), 'hooks.toml')) {
+                streams.stderr.write('h2a host plugin: this target is not available for vibe; post_agent requires the effective <VIBE_HOME>/hooks.toml TOML file.\n');
+                return 1;
+            }
+            const result = nativeHostReport('vibe', flags, !!flags.write, false, undefined, streams.cwd?.());
+            streams.stdout.write(`${JSON.stringify({ ...result, push: true, mechanism: 'vibe-hooks', record: 'rendered' in result ? result.rendered : '',
+                receive: 'N-A', hint: 'post_agent in <VIBE_HOME>/hooks.toml; ' + ('lifecycleScope' in result ? result.lifecycleScope : 'hôte absent') }, null, 2)}\n`);
+            return result.ok ? 0 : 2;
+        }
+        catch (error) {
+            streams.stderr.write(`h2a host plugin: ${error.message}\n`);
+            return 2;
+        }
+    }
     const render = renderStopHook(flags.host, {
         instance: flags.instance,
         ...(flags.root ? { root: flags.root } : {}),
@@ -4715,6 +4858,14 @@ export function cmdConductorLaunch(argv, streams, opts) {
     return 0;
 }
 function cmdDoctor(flags, streams, options = {}) {
+    if (flags.host && !isNativeHost(flags.host) && !['claude', 'codex'].includes(flags.host)) {
+        streams.stderr.write('h2a doctor: --host must be claude|codex|vibe|muse|agy\n');
+        return 1;
+    }
+    if ((flags.guard || flags.lifecycle) && flags.host !== 'vibe') {
+        streams.stderr.write('h2a doctor: --guard/--lifecycle require --host vibe\n');
+        return 1;
+    }
     const cwd = streams.cwd ?? (() => process.cwd());
     const root = resolveRoot(flags, cwd);
     const report = {
@@ -4793,9 +4944,10 @@ function cmdDoctor(flags, streams, options = {}) {
     // is allowed to touch host configuration/caches and invoke native host CLIs.
     // That keeps an ordinary isolated-bus probe independent of the operator's
     // personal Claude/Codex setup while retaining a fail-closed repair surface.
-    if (flags.repair === "true") {
+    if (flags.repair === "true" && (!flags.host || ['claude', 'codex'].includes(flags.host))) {
         const dryRun = flags["dry-run"] === "true";
-        const hostInstallations = (options.doctorHostInstallations ?? doctorHostInstallations)({ repair: true, dryRun });
+        const hostInstallations = (options.doctorHostInstallations ?? doctorHostInstallations)({ repair: true, dryRun,
+            ...(flags.host ? { hosts: [flags.host] } : {}) });
         checks.hostInstallations = hostInstallations;
         if (!hostInstallations.ok) {
             report.ok = false;
@@ -4844,6 +4996,21 @@ function cmdDoctor(flags, streams, options = {}) {
             message: "pass --repair to detect and converge Claude/Codex host installation drift"
         };
     }
+    if (flags['skip-hosts'] !== 'true') {
+        const selection = flags.host ? isNativeHost(flags.host) ? [flags.host] : [] : NATIVE_HOSTS;
+        const hosts = selection.map(host => {
+            try {
+                const { instance, ...nativeFlags } = flags;
+                return nativeHostReport(host, nativeFlags, flags.repair === 'true', false, undefined, cwd());
+            }
+            catch (error) {
+                return { host, ok: false, installation: 'inspection impossible', error: error.message };
+            }
+        });
+        checks.nativeHostInstallations = { ok: hosts.every(host => host.ok), hosts };
+        if (!hosts.every(host => host.ok))
+            report.ok = false;
+    }
     // ── Warning checks (do NOT flip report.ok) ──────────────────────────────
     // (a) rootSource: record where the root came from
     const rootInfo = resolveRootInfo(flags, cwd);
@@ -5453,7 +5620,9 @@ function cmdConnect(flags, streams) {
     const followUp = [
         flags.host === "remote"
             ? "Use the bridge-provided environment in the remote session Pod"
-            : `Merge the snippet above under \`mcpServers\` in ${steps[1].pathExample}`,
+            : flags.host === "vibe" ? `Entrée directe intérimaire (décision owner 16/10, dérogation O7.2) : h2a host setup --host vibe --write ; migration registre R5/R7 : h2a host setup --host vibe --remove puis bootstrap.`
+                : isNativeHost(flags.host) ? `Rendu historique non recommandé — ${REGISTRY_WAITING}; installation et activation par l’intégrateur registre.`
+                    : `Merge the snippet above under \`mcpServers\` in ${steps[1].pathExample}`,
         identity.privateKeyPath
             ? `keypair ready: ${identity.privateKeyPath}`
             : `legacy override: run h2a keys generate --instance ${instance} --root ${root} if needed`,
@@ -5565,7 +5734,7 @@ function targetSpecFor(host, cwd) {
         // installed skills are listed at session open.
         return {
             host: "vibe",
-            userBase: join(homedir(), ".vibe", "skills"),
+            userBase: join(vibeHome(), "skills"),
             projectBase: join(cwd, ".vibe", "skills"),
             extension: "SKILL.md",
             write: (base, skillName, _parsed, raw) => {
@@ -5704,7 +5873,7 @@ function readSkillFrom(srcDir, dirName, source, renameTo) {
         raw = raw.replace(/^(name:[ \t]*).*$/m, `$1${installName}`);
         parsed = { ...parsed, name: installName };
     }
-    return { kind: "skill", skill: { installName, parsed, raw, source } };
+    return { kind: "skill", skill: { installName, parsed, raw, source, resourceDir: join(srcDir, dirName) } };
 }
 /**
  * Resolve the on-disk `skills/` directory of an installed dependency package
@@ -5812,6 +5981,15 @@ function collectInstallableSkills() {
         return { skills, sources, error: harnessRes.error };
     return { skills, sources };
 }
+function nativeHostReport(host, flags, repair, explicitInstall = false, root, cwd) {
+    const collection = collectInstallableSkills();
+    if (collection.error)
+        throw new Error(collection.error.message);
+    return convergeNativeHost({ host, root, cwd, version: currentCliVersion(), skills: collection.skills, renderGemini: renderSkillAsGeminiToml,
+        sourcesComplete: collection.sources.every(s => s.dir !== null && s.count > 0), repair, explicitInstall,
+        dryRun: flags['dry-run'] === 'true', force: flags.force === 'true', guard: flags.guard, lifecycle: flags.lifecycle,
+        instance: flags.instance, busRoot: flags.root, status: flags.status });
+}
 function cmdInstallSkills(flags, streams) {
     const host = flags.host;
     if (!host) {
@@ -5841,8 +6019,23 @@ function cmdInstallSkills(flags, streams) {
         return collection.error.exit;
     }
     const targetBase = scope === "user" ? spec.userBase : spec.projectBase;
+    if (scope === 'user' && (isNativeHost(host) || host === 'gemini')) {
+        try {
+            const result = nativeHostReport(host, flags, true, true, dirname(targetBase), cwd());
+            streams.stdout.write(`${JSON.stringify({ ...result, scope, targetBase, installed: 'changed' in result ? result.changed : [], sources: collection.sources,
+                prunedLegacy: [], skipped: 'conflicts' in result ? result.conflicts.map(path => ({ path, reason: 'customized or unknown provenance; preserved' })) : [],
+                ...(host === 'muse' ? { verifyHint: 'muse skills list   # project scope requires workspace trust' } : {}),
+                ...(host === 'vibe' ? { verifyHint: 'vibe   # skills load at session open; nouvelle session ou reprise propre' } : {}),
+                ...(host === 'agy' ? { importHint: 'agy plugin import gemini   # then: agy plugin enable h2a' } : {}) }, null, 2)}\n`);
+            return result.ok ? 0 : 2;
+        }
+        catch (error) {
+            streams.stderr.write(`h2a install-skills: ${error.message}\n`);
+            return 3;
+        }
+    }
     // DEC-057: prune the pre-consolidation skill names if they linger on disk.
-    const prunedLegacy = pruneLegacy(spec, targetBase);
+    const prunedLegacy = isNativeHost(host) || host === 'gemini' ? [] : pruneLegacy(spec, targetBase);
     const installed = [];
     const skipped = [];
     for (const skill of collection.skills) {
@@ -5860,7 +6053,18 @@ function cmdInstallSkills(flags, streams) {
             continue;
         }
         try {
-            const targetPath = spec.write(targetBase, skillName, skill.parsed, skill.raw);
+            let targetPath;
+            if (scope === 'project' && (isNativeHost(host) || host === 'gemini')) {
+                const artifacts = nativeSkillArtifacts({ host, root: dirname(targetBase), project: true, version: currentCliVersion(), skills: [skill], renderGemini: renderSkillAsGeminiToml, historicalHashes: () => [] });
+                for (const artifact of artifacts) {
+                    assertNativePath(artifact.path);
+                    mkdirSync(dirname(artifact.path), { recursive: true });
+                    writeFileSync(artifact.path, artifact.bytes);
+                }
+                targetPath = probeTarget;
+            }
+            else
+                targetPath = spec.write(targetBase, skillName, skill.parsed, skill.raw);
             installed.push(targetPath);
         }
         catch (error) {
@@ -6268,6 +6472,10 @@ export function runCli(argv = process.argv.slice(2), streams = {
     stderr: process.stderr
 }, options = {}) {
     const { command, flags } = parseFlags(argv);
+    if (streams.stderr === process.stderr && process.stderr.isTTY) {
+        for (const notice of captureHostOperatorNotices())
+            streams.stderr.write(`${notice}\n`);
+    }
     if (command && TRACK_FACADE_VERBS.has(command)) {
         // ④: read-only + sync-write verbs run in-process; `focus` (async) keeps
         // shelling out. Same `.track`, same lock. A native WRITE never falls back to