@rosthq/cli 0.7.124 → 0.7.126

package/dist/index.js

@@ -52231,7 +52231,7 @@ The implementation method is split into stable sections so a CLI, MCP, or in-app
     order: 12,
     title: "Install the {{brand}} implementation Skill",
     summary: "Install the public implementation Skill through its signed, verified GitHub release so a general-purpose agent can run the {{brand}} implementation method.",
-    version: "2026-07-24.1",
+    version: "2026-07-30.1",
     public: true,
     audiences: ["human", "cli", "mcp", "in_app_agent"],
     stages: ["company_setup"],
@@ -52285,10 +52285,14 @@ A fetched release can never introduce its own trust root. Any key material insid
 
 Files are placed under the client's skills directory as \`rost-implementation/\`, plus a \`.rost-skill-release.json\` provenance marker. The marker records source repository, tag, commit, manifest sha256, and signer fingerprint. The agent quotes this marker when reporting which implementation method ran.
 
+For Claude Code the directory is \`$CLAUDE_CONFIG_DIR/skills/\` when that variable is set, otherwise \`~/.claude/skills/\` \u2014 \`CLAUDE_CONFIG_DIR\` is the variable Claude Code itself reads. The legacy \`CLAUDE_HOME\` is still honoured as a fallback and prints a deprecation notice; prefer \`CLAUDE_CONFIG_DIR\`, because a Skill installed under a root the client does not read leaves the agent running without it. For Codex the directory is \`$CODEX_HOME/skills/\`, otherwise \`~/.codex/skills/\`. The installer prints the resolved directory \u2014 check it matches the configuration the client launches with.
+
 ## Update path
 
 Re-run the installer to update. It re-verifies and replaces the pinned release. Use \`--tag <vX>\` to select a specific signed release. The stable install name \`rost-implementation\` is preserved across versions.
 
+Re-running is also how you confirm an existing install is intact: the installer hashes the files ON DISK against the signed manifest, not just the recorded marker, and reinstalls if any file was edited, removed, or added. A matching provenance marker alone is not evidence about the installed bytes. Note the scope of what this proves \u2014 the files matched the manifest at the moment the installer completed, so re-run it immediately before a run that depends on the Skill being unmodified.
+
 ## After install
 
 The agent bootstraps per the Skill's SKILL.md:
@@ -61717,7 +61721,7 @@ ${redactForLog(pending.diff)}
 }
 
 // src/skill-install.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { lstatSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import os2 from "node:os";
 import path5 from "node:path";
 
@@ -61729,8 +61733,8 @@ var RELEASE_REPOSITORY = {
   owner: "agenticoperatingsystem",
   name: "rost-implementation-skill"
 };
-var DEFAULT_RELEASE_TAG = "v0.1.0-preview";
-var EXPECTED_DEFAULT_MANIFEST_SHA256 = "812325e925688bb807c82c52ef3d184daf78127a7af219340292dc906988680a";
+var DEFAULT_RELEASE_TAG = "v0.2.0";
+var EXPECTED_DEFAULT_MANIFEST_SHA256 = "bbd745e1a625c30773fac5505f32c5152925d2474ac22d2cb4a93aa5a034ca66";
 var SKILL_MANIFEST_PROTOCOL_VERSION = 1;
 var SKILL_INSTALL_DIR_NAME = "rost-implementation";
 var SkillTrustError = class extends Error {
@@ -62031,15 +62035,14 @@ function verifyReleaseManifest(manifest, options) {
       };
     }
   }
+  let files;
   try {
-    for (const file2 of parsed.files) {
-      safeRelativePath2(file2.path);
-    }
+    files = parsed.files.map((file2) => ({ ...file2, path: safeRelativePath2(file2.path) }));
   } catch (error51) {
     const message = error51 instanceof Error ? error51.message : "Invalid path";
     return { ok: false, reason: message };
   }
-  return { ok: true, reason: "Manifest verified", manifest: parsed };
+  return { ok: true, reason: "Manifest verified", manifest: { ...parsed, files } };
 }
 function verifyFileChecksums(files, manifest) {
   const manifestMap = /* @__PURE__ */ new Map();
@@ -62138,6 +62141,10 @@ function verifyReleaseTrust(input) {
 // src/skill-install.ts
 var UsageError3 = class extends Error {
 };
+function writeErrorLine(io, message) {
+  io.stderr.write(`${terminalSafe(message)}
+`);
+}
 var CLIENTS2 = /* @__PURE__ */ new Set(["claude-code", "codex", "cursor"]);
 var REPO_PATH = `${RELEASE_REPOSITORY.owner}/${RELEASE_REPOSITORY.name}`;
 var GITHUB_JSON_HEADERS = { "User-Agent": "rost-cli", "Accept": "application/vnd.github+json" };
@@ -62230,8 +62237,7 @@ async function runInstallImplementation(context, args) {
     tag = optionalValue3(parsed, "tag") ?? DEFAULT_RELEASE_TAG;
   } catch (error51) {
     if (error51 instanceof UsageError3) {
-      context.io.stderr.write(`${error51.message}
-`);
+      writeErrorLine(context.io, error51.message);
       return 1;
     }
     throw error51;
@@ -62244,8 +62250,7 @@ async function runInstallImplementation(context, args) {
     return await installRelease(context, resolved.plan);
   } catch (error51) {
     if (error51 instanceof NetworkRequestError) {
-      context.io.stderr.write(`${error51.message}
-`);
+      writeErrorLine(context.io, error51.message);
       return 2;
     }
     throw error51;
@@ -62254,8 +62259,7 @@ async function runInstallImplementation(context, args) {
 async function resolveVerifiedPlan(context, input, testOverrides = {}) {
   const fetchImpl = context.fetch ?? globalThis.fetch;
   const fail2 = (message, exitCode) => {
-    context.io.stderr.write(`${message}
-`);
+    writeErrorLine(context.io, message);
     return { ok: false, exitCode };
   };
   const refUrl = `https://api.github.com/repos/${REPO_PATH}/git/refs/tags/${encodeURIComponent(input.tag)}`;
@@ -62370,37 +62374,55 @@ async function installRelease(context, plan, testOverrides = {}) {
     ...testOverrides.trustedPublicKeyLine === void 0 ? {} : { trustedPublicKeyLine: testOverrides.trustedPublicKeyLine }
   });
   if (!trustResult.ok) {
-    context.io.stderr.write(`Trust verification failed: ${trustResult.reason}
-`);
+    writeErrorLine(context.io, `Trust verification failed: ${trustResult.reason}`);
     return 1;
   }
   const commitSha = trustResult.commitSha;
   if (commitSha === void 0) {
-    context.io.stderr.write("Trust verification succeeded but did not return a commit sha.\n");
+    writeErrorLine(context.io, "Trust verification succeeded but did not return a commit sha.");
     return 1;
   }
   const manifest = trustResult.manifest;
   if (manifest === void 0) {
-    context.io.stderr.write("Trust verification succeeded but did not return a parsed manifest.\n");
+    writeErrorLine(context.io, "Trust verification succeeded but did not return a parsed manifest.");
     return 1;
   }
   const unsupported = unsupportedClientReason(manifest, plan.client);
   if (unsupported !== null) {
-    context.io.stderr.write(`${unsupported}
-`);
+    writeErrorLine(context.io, unsupported);
     return 1;
   }
   const checksumResult = verifyFileChecksums(plan.files, manifest);
   if (!checksumResult.ok) {
-    context.io.stderr.write(`File verification failed: ${checksumResult.reason}
-`);
+    writeErrorLine(context.io, `File verification failed: ${checksumResult.reason}`);
     return 1;
   }
-  const root = installRoot2(plan.client, context.env);
+  let root;
+  let legacyNotice;
+  try {
+    ({ root, legacyNotice } = installRoot2(plan.client, context.env));
+  } catch (error51) {
+    if (error51 instanceof UsageError3) {
+      writeErrorLine(context.io, error51.message);
+      return 1;
+    }
+    throw error51;
+  }
+  if (legacyNotice !== null) {
+    writeErrorLine(context.io, legacyNotice);
+  }
   const dir = path5.join(root, SKILL_INSTALL_DIR_NAME);
   const manifestSha256 = sha256Hex(plan.manifestRaw);
   const existingMarker = readMarker(dir);
-  if (existingMarker?.manifestSha256 === manifestSha256) {
+  const installedState = existingMarker?.manifestSha256 === manifestSha256 ? verifyInstalledTree(dir, manifest) : null;
+  if (installedState !== null && !installedState.ok) {
+    writeErrorLine(
+      context.io,
+      `NOTICE: the installed Skill does not match the signed release (${installedState.reason}); reinstalling.`
+    );
+  }
+  if (installedState?.ok === true) {
+    writeMarker(dir, { tag: plan.tag, commitSha, manifestSha256 });
     if (plan.json) {
       context.io.stdout.write(
         `${JSON.stringify({
@@ -62430,23 +62452,21 @@ async function installRelease(context, plan, testOverrides = {}) {
     const resolvedTarget = path5.resolve(target);
     const resolvedDir = path5.resolve(dir);
     if (!resolvedTarget.startsWith(`${resolvedDir}${path5.sep}`)) {
-      context.io.stderr.write(`Refusing to write file outside target directory: ${file2.path}
-`);
+      writeErrorLine(context.io, `Refusing to write file outside target directory: ${file2.path}`);
       return 1;
     }
     mkdirSync2(path5.dirname(target), { recursive: true });
     writeFileSync2(target, file2.content, "utf8");
   }
-  const marker = {
-    source: `github.com/${REPO_PATH}`,
-    tag: plan.tag,
-    commit: commitSha,
-    manifestSha256,
-    signerFingerprint: TRUSTED_SIGNER_FINGERPRINT,
-    installedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeFileSync2(path5.join(dir, ".rost-skill-release.json"), `${JSON.stringify(marker, null, 2)}
-`, "utf8");
+  const writtenState = verifyInstalledTree(dir, manifest);
+  if (!writtenState.ok) {
+    writeErrorLine(
+      context.io,
+      `Installed tree does not match the signed release after writing: ${writtenState.reason}`
+    );
+    return 1;
+  }
+  writeMarker(dir, { tag: plan.tag, commitSha, manifestSha256 });
   if (plan.json) {
     context.io.stdout.write(
       `${JSON.stringify({
@@ -62469,13 +62489,77 @@ async function installRelease(context, plan, testOverrides = {}) {
   }
   return 0;
 }
+var SKILL_MARKER_FILE = ".rost-skill-release.json";
 function verifiedSignerLine() {
   const fingerprintBase = TRUSTED_SIGNER_FINGERPRINT.replace("SHA256:", "");
   return `verified signed release; signer SHA256:${fingerprintBase.slice(-12)} (last 12 chars)`;
 }
+function writeMarker(dir, input) {
+  const marker = {
+    source: `github.com/${REPO_PATH}`,
+    tag: input.tag,
+    commit: input.commitSha,
+    manifestSha256: input.manifestSha256,
+    signerFingerprint: TRUSTED_SIGNER_FINGERPRINT,
+    // Refreshed on every verification, not only on a rewrite: it is the
+    // operator's evidence that the pre-launch re-run actually happened.
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync2(path5.join(dir, SKILL_MARKER_FILE), `${JSON.stringify(marker, null, 2)}
+`, "utf8");
+}
+function listInstalledFiles(dir) {
+  const files = [];
+  const walk = (current, prefix) => {
+    for (const name of readdirSync(current)) {
+      const relative = prefix === "" ? name : `${prefix}/${name}`;
+      const absolute = path5.join(current, name);
+      const stats = lstatSync(absolute);
+      if (stats.isSymbolicLink() || !stats.isFile() && !stats.isDirectory()) {
+        throw new Error(`refusing to verify a symlink or special file: ${relative}`);
+      }
+      if (stats.isDirectory()) {
+        walk(absolute, relative);
+        continue;
+      }
+      if (relative === SKILL_MARKER_FILE) {
+        continue;
+      }
+      files.push({ path: relative, absolute });
+    }
+  };
+  walk(dir, "");
+  return files;
+}
+function verifyInstalledTree(dir, manifest) {
+  let present;
+  try {
+    present = listInstalledFiles(dir);
+  } catch (error51) {
+    return { ok: false, reason: error51 instanceof Error ? error51.message : "install directory is unreadable" };
+  }
+  const manifestPaths = new Set(manifest.files.map((file2) => file2.path));
+  const unexpected = present.find((file2) => !manifestPaths.has(file2.path));
+  if (unexpected !== void 0) {
+    return { ok: false, reason: "an installed file is not listed in the signed manifest" };
+  }
+  if (present.length !== manifestPaths.size) {
+    return { ok: false, reason: "the installed tree is missing files listed in the signed manifest" };
+  }
+  function* readEach() {
+    for (const file2 of present) {
+      yield { path: file2.path, content: readFileSync4(file2.absolute) };
+    }
+  }
+  try {
+    return verifyFileChecksums(readEach(), manifest);
+  } catch (error51) {
+    return { ok: false, reason: error51 instanceof Error ? error51.message : "an installed file is unreadable" };
+  }
+}
 function readMarker(dir) {
   try {
-    const content = readFileSync4(path5.join(dir, ".rost-skill-release.json"), "utf8");
+    const content = readFileSync4(path5.join(dir, SKILL_MARKER_FILE), "utf8");
     const parsed = JSON.parse(content);
     if (typeof parsed === "object" && parsed !== null) {
       return parsed;
@@ -62484,18 +62568,46 @@ function readMarker(dir) {
   }
   return null;
 }
+function resolveClaudeSkillInstallRoot(env) {
+  const configDir = requireNonBlank("CLAUDE_CONFIG_DIR", env.CLAUDE_CONFIG_DIR);
+  const legacyHome = requireNonBlank("CLAUDE_HOME", env.CLAUDE_HOME);
+  if (configDir !== null) {
+    const disagrees = legacyHome !== null && path5.resolve(legacyHome) !== path5.resolve(configDir);
+    return {
+      root: path5.join(configDir, "skills"),
+      legacyNotice: disagrees ? `NOTICE: CLAUDE_HOME (${legacyHome}) is ignored; Claude Code reads CLAUDE_CONFIG_DIR (${configDir}).` : null
+    };
+  }
+  if (legacyHome !== null) {
+    return {
+      root: path5.join(legacyHome, "skills"),
+      legacyNotice: "NOTICE: CLAUDE_HOME is deprecated and Claude Code does not read it; set CLAUDE_CONFIG_DIR instead."
+    };
+  }
+  const home = requireNonBlank("HOME", env.HOME) ?? os2.homedir();
+  return { root: path5.join(home, ".claude", "skills"), legacyNotice: null };
+}
+function requireNonBlank(name, value) {
+  if (value === void 0 || value === "") {
+    return null;
+  }
+  if (value.trim().length === 0) {
+    throw new UsageError3(`${name} is set to a blank value; unset it or give it a real path.`);
+  }
+  return value;
+}
 function installRoot2(client, env) {
-  const override = env.ROST_SKILL_INSTALL_ROOT;
-  if (override !== void 0 && override.length > 0) {
-    return path5.resolve(override, client);
+  const override = requireNonBlank("ROST_SKILL_INSTALL_ROOT", env.ROST_SKILL_INSTALL_ROOT);
+  if (override !== null) {
+    return { root: path5.resolve(override, client), legacyNotice: null };
   }
   if (client === "codex") {
-    return path5.join(env.CODEX_HOME ?? path5.join(os2.homedir(), ".codex"), "skills");
+    return { root: path5.join(env.CODEX_HOME ?? path5.join(os2.homedir(), ".codex"), "skills"), legacyNotice: null };
   }
   if (client === "claude-code") {
-    return path5.join(env.CLAUDE_HOME ?? path5.join(os2.homedir(), ".claude"), "skills");
+    return resolveClaudeSkillInstallRoot(env);
   }
-  return path5.join(os2.homedir(), ".cursor", "skills");
+  return { root: path5.join(os2.homedir(), ".cursor", "skills"), legacyNotice: null };
 }
 function parseFlags3(args) {
   const values = /* @__PURE__ */ new Map();