@halofy/agent-connect 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halofy/agent-connect",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "Halofy lifecycle installer and runtime for supported agents; runtime requests are signed with a per-installation Ed25519 key",
   "bin": {

package/src/claude-hook.mjs

@@ -3,6 +3,25 @@ import { basename } from "node:path";
 import { LifecycleRuntime } from "./runtime.mjs";
 import { normalizeClaudeHookEvent, RECALL_INJECTION_ENABLED, rankedRecallBlocks } from "./session.mjs";
 import { defaultRuntimeDirectory } from "./storage.mjs";
+import { describeSkillSync, syncManagedSkills } from "./skills-sync.mjs";
+
+/**
+ * Badge skills ride the SessionStart heartbeat (D37): check in, repair, and
+ * quarantine, but never let a skills problem degrade memory recall.
+ */
+export async function syncSkillsAtSessionStart(runtime, connection, root, stderr) {
+  try {
+    const summary = await syncManagedSkills({ connection, transport: runtime.transport, root });
+    if (summary.supported && (summary.installed.length || summary.updated.length ||
+        summary.quarantined.length || summary.errors.length)) {
+      stderr.write(`[halofy] ${describeSkillSync(summary)}\n`);
+    }
+    return summary;
+  } catch (error) {
+    stderr.write(`[halofy] skill sync degraded: ${error?.code || "runtime_unavailable"}\n`);
+    return null;
+  }
+}
 
 function id(value) {
   return createHash("sha256").update(String(value)).digest("hex");
@@ -86,6 +105,7 @@ export async function runClaudeLifecycleHook(connection, eventName, {
     if (eventName === "SessionStart") {
       await runtime.replay();
       await runtime.heartbeat(connection.capabilities || {});
+      await syncSkillsAtSessionStart(runtime, connection, root, stderr);
       if (RECALL_INJECTION_ENABLED) {
         const project = hookInput.cwd ? basename(String(hookInput.cwd)) : "";
         const recalled = await runtime.recall(

package/src/host-hook.mjs

@@ -8,7 +8,7 @@ import {
   rankedRecallBlocks,
 } from "./session.mjs";
 import { defaultRuntimeDirectory } from "./storage.mjs";
-import { readHookInput } from "./claude-hook.mjs";
+import { readHookInput, syncSkillsAtSessionStart } from "./claude-hook.mjs";
 import { transcriptDriverFor } from "./transcript-drivers/index.mjs";
 
 const USER_EVENTS = new Set(["UserPromptSubmit", "beforeSubmitPrompt", "BeforeAgent", "pre_llm_call"]);
@@ -158,6 +158,7 @@ export async function runHostLifecycleHook(connection, eventName, {
     if (START_EVENTS.has(eventName)) {
       await runtime.replay();
       await runtime.heartbeat(connection.capabilities || {});
+      await syncSkillsAtSessionStart(runtime, connection, root, stderr);
       if (RECALL_INJECTION_ENABLED) {
         const project = hookInput.cwd ? basename(String(hookInput.cwd)) : "";
         const recalled = await runtime.recall(session,

package/src/install.mjs

@@ -7,6 +7,7 @@ import { ConnectionStore, defaultRuntimeDirectory, ensurePrivateDirectory, readJ
 import { SignedRuntimeTransport } from "./transport.mjs";
 import { INSTALLER_VERSION, RUNTIME_VERSION } from "./version.mjs";
 import { CLIENT_KINDS, CLIENT_REGISTRY, lifecycleClient } from "./client-registry.mjs";
+import { syncManagedSkills } from "./skills-sync.mjs";
 
 export const CLAUDE_CAPABILITIES = CLIENT_REGISTRY["claude-code"].capabilities;
 
@@ -259,6 +260,28 @@ export async function heartbeatInstalledConnection({
   return true;
 }
 
+/**
+ * Install-time skill delivery: the moment the badge is bound, the approved
+ * team + org skills land in the host's skills folder (D37/D38). Returns the
+ * content-free sync summary; never throws for a server or skill problem.
+ */
+export async function syncInstalledSkills({
+  installationId,
+  root = defaultRuntimeDirectory(),
+  fetchImpl = globalThis.fetch,
+  home,
+  env,
+}) {
+  const connection = await new ConnectionStore(root).load(installationId);
+  return syncManagedSkills({
+    connection,
+    transport: new SignedRuntimeTransport(connection, { fetchImpl }),
+    root,
+    ...(home ? { home } : {}),
+    ...(env ? { env } : {}),
+  });
+}
+
 export function localMcpSnippet({ nodePath = process.execPath, proxyPath, installationId }) {
   return {
     mcpServers: {

package/src/installer-cli.mjs

@@ -10,12 +10,14 @@ import {
   installLocalConnection,
   installRuntimeBundle,
   localMcpSnippet,
+  syncInstalledSkills,
 } from "./install.mjs";
 import { configureClaudeProject } from "./claude-config.mjs";
 import { configureCline, configureCodex, configureCursor, configureGemini, configureKimi, configureVscode } from "./host-config.mjs";
 import { CLIENT_KINDS, lifecycleClient } from "./client-registry.mjs";
 import { defaultRuntimeDirectory } from "./storage.mjs";
 import { DISCLOSURE_VERSION, INSTALLER_VERSION } from "./version.mjs";
+import { describeSkillSync, managedSkillsDirectory } from "./skills-sync.mjs";
 
 const CLAIM_PATTERN = /^hsc_[A-Za-z0-9_-]{43}$/;
 
@@ -165,6 +167,7 @@ function captureCategories(client) {
 export function disclosureText({ serverUrl, projectRoot, clientKind, clientVersion, organization = null }) {
   const client = lifecycleClient(clientKind);
   const { supported, unsupported } = captureCategories(client);
+  const skillsRoot = managedSkillsDirectory(clientKind);
   return [
     `Halofy ${client.label} lifecycle connection`,
     `Installer: @halofy/agent-connect@${INSTALLER_VERSION}`,
@@ -179,8 +182,11 @@ export function disclosureText({ serverUrl, projectRoot, clientKind, clientVersi
     "- governed memory tools the agent invokes explicitly (no automatic recall is injected into sessions),",
     `- conversation events exposed by ${client.label}'s reviewed hooks,`,
     "- explicitly supported tool, subagent, compaction, and close evidence,",
-    "- encrypted local retry queue and governed retained conversations, and",
-    "- canonical learning when the selected badge permits writes.",
+    "- encrypted local retry queue and governed retained conversations,",
+    "- canonical learning when the selected badge permits writes, and",
+    skillsRoot
+      ? `- approved company and team skills written to ${skillsRoot}/<skill>/SKILL.md and kept current at each session start; withdrawn skills are moved aside, never deleted.`
+      : "- no managed skills folder for this host (skills stay available through skill_invoke).",
     "",
     `Supported capture categories: ${supported.length > 0 ? supported.join(", ") : "none"}.`,
     `Unsupported capture categories: ${unsupported.length > 0 ? unsupported.join(", ") : "none"}.`,
@@ -188,7 +194,9 @@ export function disclosureText({ serverUrl, projectRoot, clientKind, clientVersi
       ? "This reviewed host surface can report complete coverage when all declared evidence is observed."
       : `This host has partial coverage (${client.reason}); missing categories remain explicit.`,
     "Authorized organization managers may review retained conversations and summaries.",
-    "This does not scan historical files, other applications, clipboard, keystrokes, or other agents.",
+    skillsRoot
+      ? `This reads and writes only the skill folders it created under ${skillsRoot}; it does not scan historical files, other applications, clipboard, keystrokes, or other agents.`
+      : "This does not scan historical files, other applications, clipboard, keystrokes, or other agents.",
     "Disconnecting stops future capture but does not erase retained data.",
     `Disclosure: ${DISCLOSURE_VERSION}`,
   ].join("\n");
@@ -224,6 +232,10 @@ export function allDisclosureText({ serverUrl, projectRoot, organization = null,
       client.coverage === "complete"
         ? "This reviewed host surface can report complete coverage when all declared evidence is observed."
         : `This host has partial coverage (${client.reason}); missing categories remain explicit.`,
+      managedSkillsDirectory(host.clientKind)
+        ? `Approved company and team skills are written to ${managedSkillsDirectory(host.clientKind)}/<skill>/SKILL.md ` +
+          "and kept current at each session start; withdrawn skills are moved aside, never deleted."
+        : "No managed skills folder for this host; skills stay available through skill_invoke.",
     );
   }
   if (unusedKinds.length > 0) {
@@ -236,7 +248,8 @@ export function allDisclosureText({ serverUrl, projectRoot, organization = null,
   lines.push(
     "",
     "Authorized organization managers may review retained conversations and summaries.",
-    "This does not scan historical files, other applications, clipboard, keystrokes, or other agents.",
+    "This reads and writes only the skill folders it created for the hosts listed above; it does not scan " +
+    "historical files, other applications, clipboard, keystrokes, or other agents.",
     "Disconnecting stops future capture but does not erase retained data.",
     `Disclosure: ${DISCLOSURE_VERSION}`,
   );
@@ -277,6 +290,7 @@ async function runAllInstaller(input, {
   fetchImpl,
   sourceRoot,
   claudeConfigPath,
+  skillsHome,
 }) {
   const probes = [];
   for (const selection of input.selections) {
@@ -353,10 +367,27 @@ async function runAllInstaller(input, {
       } catch {
         heartbeat = false;
       }
+      // Skills land during the sweep too; a skills problem is reported per
+      // host, never fatal to the install.
+      let skills = null;
+      try {
+        skills = await syncInstalledSkills({
+          installationId: installed.installationId, root, fetchImpl,
+          ...(skillsHome ? { home: skillsHome } : {}),
+        });
+      } catch {
+        skills = null;
+      }
       results.push({
         clientKind: host.clientKind,
         status: heartbeat ? "configured_heartbeat_verified" : "configured_heartbeat_unavailable",
         installationId: installed.installationId,
+        skills: skills
+          ? { supported: skills.supported, skillsRoot: skills.skillsRoot, checkedIn: skills.checkedIn,
+              installed: skills.installed, updated: skills.updated,
+              quarantined: skills.quarantined.map((q) => q.skillKey),
+              conflicts: skills.conflicts.map((c) => c.skillKey), errors: skills.errors.length }
+          : null,
         proofStorage: installed.proofStorage,
         configuredPaths: configured.configuredPaths || [configured.mcpPath, configured.settingsPath],
         replacedLegacyMcpEntries: configured.replacedLegacyMcpEntries || 0,
@@ -394,11 +425,13 @@ export async function runInstaller(argv, {
   fetchImpl = globalThis.fetch,
   sourceRoot,
   claudeConfigPath,
+  skillsHome,
 } = {}) {
   const input = parseInstallerArgs(argv);
   if (input.mode === "all") {
     return runAllInstaller(input, {
       root, output, detectClaude, detectHost, confirm, fetchImpl, sourceRoot, claudeConfigPath,
+      skillsHome,
     });
   }
   const clientVersion = input.clientKind === "claude-code" ? await detectClaude() : await detectHost(input.clientKind);
@@ -440,6 +473,19 @@ export async function runInstaller(argv, {
   } catch {
     heartbeat = false;
   }
+  // Skills land now, not at the next session: the badge already resolves the
+  // team + org set server-side, so the folder is populated before the user
+  // restarts the host. A skills problem is reported, never fatal.
+  let skills = null;
+  try {
+    skills = await syncInstalledSkills({
+      installationId: installed.installationId, root, fetchImpl, ...(skillsHome ? { home: skillsHome } : {}),
+    });
+    output.write(`${describeSkillSync(skills)}\n`);
+  } catch (error) {
+    skills = null;
+    output.write(`skills: unavailable (${error?.code || "runtime_unavailable"})\n`);
+  }
   return {
     status: heartbeat ? "configured_heartbeat_verified" : "configured_heartbeat_unavailable",
     installationId: installed.installationId,
@@ -453,6 +499,11 @@ export async function runInstaller(argv, {
       proxyPath: bundle.runtimePath,
       installationId: installed.installationId,
     }),
+    skills: skills
+      ? { supported: skills.supported, skillsRoot: skills.skillsRoot, checkedIn: skills.checkedIn,
+          installed: skills.installed, updated: skills.updated, quarantined: skills.quarantined.map((q) => q.skillKey),
+          conflicts: skills.conflicts.map((c) => c.skillKey), errors: skills.errors.length }
+      : null,
     nextStep: `Restart ${lifecycleClient(input.clientKind).label}, then check the connection in Halofy.`,
   };
 }

package/src/skills-sync.mjs

@@ -0,0 +1,266 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { ensurePrivateDirectory, readJson, writePrivateFile } from "./storage.mjs";
+
+/**
+ * Badge-delivered skills (CONTRACTS-S16-SKILL-TRACKING D37–D39 on the signed
+ * badge runtime). The badge resolves, server-side, every approved and vetted
+ * skill on its team + org chain; this module mirrors that set into the host's
+ * own skills folder and keeps it there.
+ *
+ * Every managed copy is written as `<skillsRoot>/<skillKey>/SKILL.md`, the
+ * layout Claude Code and Codex both read. A manifest under the runtime home
+ * records what was written (id, sha, file digest) so the next check-in can
+ * report it, drift can be repaired, and a withdrawn skill can be quarantined
+ * — moved, never deleted (D7 on the client mirror).
+ *
+ * A folder this runtime did not create is never touched: an employee's own
+ * skill with a colliding name is reported as a conflict and left alone.
+ */
+
+export const STALE_AFTER_MS = 7 * 24 * 60 * 60 * 1000;
+const SKILL_KEY = /^[a-z0-9][a-z0-9._-]{0,199}$/i;
+const MANAGED_MARKER = "content_sha256:";
+
+/**
+ * The user-level Agent Skills folder each host scans, `<dir>/<name>/SKILL.md`.
+ * Every host also reads a workspace folder and most read the generic
+ * `~/.agents/skills`; the badge writes the host's own brand folder so one
+ * badge maps to one host and nothing leaks into a host the badge was not
+ * issued for. Verified 2026-09-04: Claude Code + Codex by install; Gemini CLI
+ * 0.58 (`GEMINI_CLI_HOME` replaces the HOME directory, so the folder is
+ * `<home>/.gemini/skills`) and Kimi Code 0.40 (`KIMI_CODE_HOME || ~/.kimi-code`;
+ * `~/.kimi/skills` is its legacy tree) from the installed binaries; Cursor,
+ * VS Code Copilot, and Cline from their published docs.
+ */
+export function managedSkillsDirectory(clientKind, { home = homedir(), env = process.env } = {}) {
+  switch (clientKind) {
+    case "claude-code": return join(env.CLAUDE_CONFIG_DIR || join(home, ".claude"), "skills");
+    case "codex": return join(env.CODEX_HOME || join(home, ".codex"), "skills");
+    case "cursor": return join(home, ".cursor", "skills");
+    case "gemini-cli": return join(env.GEMINI_CLI_HOME || home, ".gemini", "skills");
+    case "kimi-cli": return join(env.KIMI_CODE_HOME || join(home, ".kimi-code"), "skills");
+    case "vscode": return join(home, ".copilot", "skills");
+    case "cline": return join(home, ".cline", "skills");
+    default: return null;
+  }
+}
+
+export function skillsManifestPath(root, installationId) {
+  return join(root, `skills-${installationId}.json`);
+}
+
+function digest(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+function safeKey(skillKey) {
+  return typeof skillKey === "string" && SKILL_KEY.test(skillKey) && !skillKey.includes("..");
+}
+
+async function pathState(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+async function readText(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+/** Move a managed copy aside with its bytes intact; never `rm`. */
+async function quarantine(skillsRoot, quarantineRoot, skillKey, now) {
+  const from = join(skillsRoot, skillKey);
+  if (!(await pathState(from))) return null;
+  await ensurePrivateDirectory(quarantineRoot);
+  const to = join(quarantineRoot, `${skillKey}-${now.toISOString().replace(/[:.]/g, "-")}`);
+  await rename(from, to);
+  return to;
+}
+
+/**
+ * A folder is "ours" when the manifest lists it, or when its SKILL.md carries
+ * the kernel export frontmatter. Anything else is the employee's own skill.
+ */
+async function isManaged(skillsRoot, skillKey, manifestEntry) {
+  if (manifestEntry) return true;
+  const body = await readText(join(skillsRoot, skillKey, "SKILL.md"));
+  return typeof body === "string" && body.startsWith("---\n") && body.includes(`\n${MANAGED_MARKER}`);
+}
+
+export async function loadSkillsManifest(root, installationId) {
+  const manifest = await readJson(skillsManifestPath(root, installationId), null);
+  if (!manifest || manifest.version !== 1 || !Array.isArray(manifest.installs)) {
+    return { version: 1, installationId, installs: [], lastCheckinAt: null };
+  }
+  return manifest;
+}
+
+/**
+ * One sync pass. Never throws for server or filesystem trouble on a single
+ * skill; the summary names what happened so callers (installer, SessionStart
+ * hooks) can report it. A failed check-in leaves installed copies usable
+ * until the 7-day staleness allowance runs out, then quarantines them (D37).
+ */
+export async function syncManagedSkills({
+  connection,
+  transport,
+  root,
+  home = homedir(),
+  env = process.env,
+  now = () => new Date(),
+}) {
+  const clientKind = connection.clientKind;
+  const skillsRoot = managedSkillsDirectory(clientKind, { home, env });
+  const summary = {
+    supported: skillsRoot !== null,
+    skillsRoot,
+    checkedIn: false,
+    installed: [],
+    updated: [],
+    quarantined: [],
+    conflicts: [],
+    unchanged: [],
+    errors: [],
+  };
+  if (!skillsRoot) return summary;
+
+  const manifestPath = skillsManifestPath(root, connection.installationId);
+  const quarantineRoot = join(root, "skills-quarantine", connection.installationId);
+  const manifest = await loadSkillsManifest(root, connection.installationId);
+  const byId = new Map(manifest.installs.map((entry) => [entry.skillId, entry]));
+  const current = now();
+
+  let response;
+  try {
+    response = await transport.skillsCheckin(manifest.installs.map(({ skillId, sha }) => ({ skillId, sha })));
+    summary.checkedIn = true;
+  } catch (error) {
+    summary.errors.push({ stage: "checkin", code: error?.code || "runtime_unavailable" });
+    const last = manifest.lastCheckinAt ? Date.parse(manifest.lastCheckinAt) : NaN;
+    if (Number.isFinite(last) && current.getTime() - last > STALE_AFTER_MS) {
+      for (const entry of manifest.installs) {
+        try {
+          const moved = await quarantine(skillsRoot, quarantineRoot, entry.skillKey, current);
+          if (moved) summary.quarantined.push({ skillKey: entry.skillKey, reason: "stale_checkin", to: moved });
+        } catch (fsError) {
+          summary.errors.push({ stage: "quarantine", skillKey: entry.skillKey, code: fsError?.code || "fs_error" });
+        }
+      }
+      manifest.installs = [];
+      await writePrivateFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    }
+    return summary;
+  }
+
+  const wanted = new Map();
+  for (const skill of Array.isArray(response?.skills) ? response.skills : []) {
+    if (safeKey(skill.skillKey)) wanted.set(skill.skillId, skill);
+  }
+
+  // 1. Withdrawn copies: revoked / unknown verdicts, and anything the manifest
+  //    lists that the badge no longer resolves.
+  const verdicts = new Map((Array.isArray(response?.items) ? response.items : []).map((item) => [item.skillId, item]));
+  const survivors = [];
+  for (const entry of manifest.installs) {
+    const verdict = verdicts.get(entry.skillId);
+    const status = verdict?.status;
+    const withdrawn = status === "revoked" || status === "unknown" || (!wanted.has(entry.skillId) && status !== "stale");
+    if (!withdrawn) { survivors.push(entry); continue; }
+    try {
+      const moved = await quarantine(skillsRoot, quarantineRoot, entry.skillKey, current);
+      summary.quarantined.push({ skillKey: entry.skillKey, reason: status || "not_resolved", to: moved });
+    } catch (error) {
+      summary.errors.push({ stage: "quarantine", skillKey: entry.skillKey, code: error?.code || "fs_error" });
+      survivors.push(entry);
+    }
+  }
+  manifest.installs = survivors;
+
+  // 2. Missing, stale, or drifted copies: fetch through the governed export
+  //    gate and write. A stale entry keyed on a superseded row is re-keyed
+  //    to the row that replaced it.
+  for (const entry of manifest.installs) {
+    const verdict = verdicts.get(entry.skillId);
+    if (verdict?.status === "stale" && verdict.currentSkillId && !wanted.has(entry.skillId)) {
+      entry.skillId = verdict.currentSkillId;
+    }
+  }
+  const next = [];
+  for (const skill of wanted.values()) {
+    const entry = manifest.installs.find((candidate) => candidate.skillId === skill.skillId);
+    const dir = join(skillsRoot, skill.skillKey);
+    const file = join(dir, "SKILL.md");
+    const onDisk = await readText(file);
+    const intact = entry && typeof onDisk === "string" && digest(onDisk) === entry.fileSha256;
+    if (entry && entry.sha === skill.sha && intact) {
+      summary.unchanged.push(skill.skillKey);
+      next.push({ ...entry, lastCheckinAt: current.toISOString() });
+      continue;
+    }
+    if (!(await isManaged(skillsRoot, skill.skillKey, entry)) && (await pathState(dir))) {
+      summary.conflicts.push({ skillKey: skill.skillKey, reason: "unmanaged_folder" });
+      continue;
+    }
+    try {
+      const exported = await transport.skillDownload(skill.skillId);
+      const content = typeof exported?.content === "string" ? exported.content : null;
+      if (!content) throw Object.assign(new Error("skill export was empty"), { code: "empty_export" });
+      await mkdir(dir, { recursive: true });
+      await writePrivateFile(file, content);
+      const record = {
+        skillId: skill.skillId,
+        skillKey: skill.skillKey,
+        sha: skill.sha,
+        fileSha256: digest(content),
+        namespace: skill.namespace,
+        installedAt: entry?.installedAt || current.toISOString(),
+        lastCheckinAt: current.toISOString(),
+      };
+      next.push(record);
+      (entry ? summary.updated : summary.installed).push(skill.skillKey);
+    } catch (error) {
+      summary.errors.push({ stage: "download", skillKey: skill.skillKey, code: error?.code || "runtime_unavailable" });
+      if (entry) next.push(entry);
+    }
+  }
+  manifest.installs = next;
+  manifest.lastCheckinAt = current.toISOString();
+  manifest.clientKind = clientKind;
+  await writePrivateFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+  // 3. Acknowledge: a second beacon carrying what is now on disk so the
+  //    console's "installed on N badges" reflects this pass, not the last.
+  if (summary.installed.length > 0 || summary.updated.length > 0 || summary.quarantined.length > 0) {
+    try {
+      await transport.skillsCheckin(manifest.installs.map(({ skillId, sha }) => ({ skillId, sha })));
+    } catch (error) {
+      summary.errors.push({ stage: "ack", code: error?.code || "runtime_unavailable" });
+    }
+  }
+  return summary;
+}
+
+/** One-line, content-free summary for installer output and hook stderr. */
+export function describeSkillSync(summary) {
+  if (!summary.supported) return "skills: not managed for this host";
+  const parts = [];
+  if (summary.installed.length) parts.push(`installed ${summary.installed.length}`);
+  if (summary.updated.length) parts.push(`updated ${summary.updated.length}`);
+  if (summary.unchanged.length) parts.push(`unchanged ${summary.unchanged.length}`);
+  if (summary.quarantined.length) parts.push(`quarantined ${summary.quarantined.length}`);
+  if (summary.conflicts.length) parts.push(`skipped ${summary.conflicts.length} unmanaged`);
+  if (summary.errors.length) parts.push(`${summary.errors.length} error${summary.errors.length === 1 ? "" : "s"}`);
+  if (!summary.checkedIn) parts.unshift("check-in unavailable");
+  return `skills (${basename(dirname(summary.skillsRoot))}/${basename(summary.skillsRoot)}): ${parts.join(", ") || "nothing to do"}`;
+}

package/src/transport.mjs

@@ -64,6 +64,13 @@ export class SignedRuntimeTransport {
     });
   }
 
+  /** Badge skill check-in beacon: exactly the installed {skillId, sha} pairs (D39). */
+  skillsCheckin(items) { return this.request("/v1/agent-runtime/skills/checkin", { body: { items } }); }
+  /** Governed skill export — the same gate as a console download (D38). */
+  skillDownload(skillId) {
+    return this.request(`/v1/agent-runtime/skills/${encodeURIComponent(skillId)}/download`, { method: "GET" });
+  }
+
   openSession(body) { return this.request("/v1/agent-sessions/open", { body }); }
   appendEvents(sessionId, events) { return this.request(`/v1/agent-sessions/${encodeURIComponent(sessionId)}/events`, { body: { events } }); }
   recall(sessionId, body) { return this.request(`/v1/agent-sessions/${encodeURIComponent(sessionId)}/recall`, { body }); }

package/src/version.mjs

@@ -1,4 +1,4 @@
 export const PACKAGE_NAME = "@halofy/agent-connect";
-export const INSTALLER_VERSION = "0.6.0";
-export const RUNTIME_VERSION = "0.6.0";
-export const DISCLOSURE_VERSION = "halofy-agent-lifecycle-2026-08-31.2";
+export const INSTALLER_VERSION = "0.7.0";
+export const RUNTIME_VERSION = "0.7.0";
+export const DISCLOSURE_VERSION = "halofy-agent-lifecycle-2026-09-03.1";