@xiongxianfei/rigorloop 0.1.5 → 0.3.0

package/dist/lib/adapters.js

@@ -0,0 +1,50 @@
+const ADAPTERS = {
+  codex: {
+    name: "codex",
+    displayName: "Codex",
+    installRoots: {
+      skills: ".agents/skills",
+    },
+    directoryPlan: [".agents", ".agents/skills"],
+  },
+  claude: {
+    name: "claude",
+    displayName: "Claude Code",
+    installRoots: {
+      skills: ".claude/skills",
+    },
+    directoryPlan: [".claude", ".claude/skills"],
+  },
+  opencode: {
+    name: "opencode",
+    displayName: "opencode",
+    installRoots: {
+      skills: ".opencode/skills",
+      commands: ".opencode/commands",
+    },
+    directoryPlan: [".opencode", ".opencode/skills", ".opencode/commands"],
+  },
+};
+
+function cloneDescriptor(descriptor) {
+  return {
+    ...descriptor,
+    installRoots: { ...descriptor.installRoots },
+    directoryPlan: [...descriptor.directoryPlan],
+    archiveName(releaseTag) {
+      return `rigorloop-adapter-${descriptor.name}-${releaseTag}.zip`;
+    },
+    primaryInstallRoot() {
+      return descriptor.installRoots.skills;
+    },
+  };
+}
+
+export function adapterDescriptor(name) {
+  const descriptor = ADAPTERS[name];
+  return descriptor ? cloneDescriptor(descriptor) : undefined;
+}
+
+export function supportedAdapterNames() {
+  return Object.keys(ADAPTERS);
+}

package/dist/lib/lockfile.js

@@ -2,10 +2,11 @@ import { createHash } from "node:crypto";
 
 const SHA256_PATTERN = /^[0-9a-f]{64}$/i;
 const SUPPORTED_SOURCES = new Set(["release-archive", "local-archive"]);
+const SUPPORTED_ADAPTERS = new Set(["codex", "claude", "opencode"]);
 const TOP_LEVEL_FIELDS = ["schema_version", "rigorloop", "manifest", "generated"];
 const RIGORLOOP_FIELDS = ["package", "version"];
 const MANIFEST_FIELDS = ["path", "sha256"];
-const GENERATED_FIELDS = ["adapters"];
+const GENERATED_FIELDS = ["adapters", "targets"];
 const ADAPTER_FIELDS = [
   "adapter",
   "release",
@@ -13,10 +14,20 @@ const ADAPTER_FIELDS = [
   "archive",
   "archive_sha256",
   "installed_root",
+  "installed_roots",
   "tree_hash_algorithm",
   "tree_sha256",
   "file_count",
+  "root_hashes",
 ];
+const SINGLE_ROOTS = {
+  codex: ".agents/skills",
+  claude: ".claude/skills",
+};
+const OPENCODE_ROOTS = {
+  skills: ".opencode/skills",
+  commands: ".opencode/commands",
+};
 
 function failure(kind, code, message, path = "rigorloop.lock") {
   return { ok: false, kind, code, message, path };
@@ -38,6 +49,11 @@ function isSha256(value) {
   return typeof value === "string" && SHA256_PATTERN.test(value);
 }
 
+function isNonNegativeInteger(value) {
+  const text = String(value);
+  return /^\d+$/.test(text) && Number.isInteger(Number.parseInt(text, 10));
+}
+
 function parseTopLevel(lines) {
   const sections = new Map();
   for (const line of lines) {
@@ -63,6 +79,10 @@ function parseSection(lines, sectionName, allowedFields) {
     if (line.trim() === "") {
       continue;
     }
+    const nestedMatch = line.match(/^  ([A-Za-z_][A-Za-z0-9_-]*):\s*$/);
+    if (nestedMatch) {
+      return failure("unsupported", "unsupported-lockfile-shape", `Unsupported nested field ${sectionName}.${nestedMatch[1]}`);
+    }
     const match = line.match(/^  ([A-Za-z_][A-Za-z0-9_-]*):(?:\s*(.*))?$/);
     if (!match) {
       continue;
@@ -112,6 +132,18 @@ function parseAdapters(lines) {
 
   const adapters = [];
   let current;
+  let nested;
+  let rootHashRole;
+
+  function pushCurrent() {
+    if (current) {
+      adapters.push(current);
+    }
+    current = undefined;
+    nested = undefined;
+    rootHashRole = undefined;
+  }
+
   for (let index = adaptersStart + 1; index < lines.length; index += 1) {
     const line = lines[index];
     if (/^[A-Za-z_][A-Za-z0-9_-]*:/.test(line)) {
@@ -124,11 +156,10 @@ function parseAdapters(lines) {
     if (generatedFieldMatch) {
       return failure("unsupported", "unsupported-lockfile-shape", `Unsupported field generated.${generatedFieldMatch[1]}`);
     }
+
     const startMatch = line.match(/^    - ([A-Za-z_][A-Za-z0-9_-]*):(?:\s*(.*))?$/);
     if (startMatch) {
-      if (current) {
-        adapters.push(current);
-      }
+      pushCurrent();
       current = {};
       const [, key, value] = startMatch;
       if (!ADAPTER_FIELDS.includes(key)) {
@@ -147,26 +178,165 @@ function parseAdapters(lines) {
       if (!ADAPTER_FIELDS.includes(key)) {
         return failure("unsupported", "unsupported-lockfile-shape", `Unsupported field generated.adapters[${adapters.length}].${key}`);
       }
+      if (key === "installed_roots" || key === "root_hashes") {
+        if (value !== undefined && value !== "") {
+          return failure("invalid", "invalid-lockfile", `Expected mapping for generated.adapters[${adapters.length}].${key}`);
+        }
+        current[key] = {};
+        nested = key;
+        rootHashRole = undefined;
+        continue;
+      }
       if (value === undefined || value === "") {
         return failure("invalid", "invalid-lockfile", `Missing scalar value for generated.adapters[${adapters.length}].${key}`);
       }
       current[key] = parseScalar(value);
+      nested = undefined;
+      rootHashRole = undefined;
+      continue;
+    }
+
+    const installedRootMatch = line.match(/^        ([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (installedRootMatch && current && nested === "installed_roots") {
+      current.installed_roots[installedRootMatch[1]] = parseScalar(installedRootMatch[2]);
+      continue;
+    }
+
+    const rootHashRoleMatch = line.match(/^        ([A-Za-z_][A-Za-z0-9_-]*):\s*$/);
+    if (rootHashRoleMatch && current && nested === "root_hashes") {
+      rootHashRole = rootHashRoleMatch[1];
+      current.root_hashes[rootHashRole] = {};
+      continue;
+    }
+
+    const rootHashFieldMatch = line.match(/^          ([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/);
+    if (rootHashFieldMatch && current && nested === "root_hashes" && rootHashRole) {
+      const [, key, value] = rootHashFieldMatch;
+      if (!["tree_sha256", "file_count"].includes(key)) {
+        return failure("unsupported", "unsupported-lockfile-shape", `Unsupported field generated.adapters[${adapters.length}].root_hashes.${rootHashRole}.${key}`);
+      }
+      current.root_hashes[rootHashRole][key] = key === "file_count" ? Number.parseInt(parseScalar(value), 10) : parseScalar(value);
+      continue;
+    }
+
+    if (line.startsWith("      ") && current) {
+      return failure("unsupported", "unsupported-lockfile-shape", `Unsupported lockfile adapter mapping near: ${line.trim()}`);
     }
   }
-  if (current) {
-    adapters.push(current);
-  }
+  pushCurrent();
   return { adapters };
 }
 
-function validateAdapter(adapter) {
-  for (const field of ADAPTER_FIELDS) {
+function parseTargets(lines) {
+  const transformed = lines.map((line) => {
+    if (line === "  targets:") {
+      return "  adapters:";
+    }
+    return line.replace(/^    - target:/, "    - adapter:");
+  });
+  const parsed = parseAdapters(transformed);
+  if (parsed.ok === false || parsed.missing) {
+    return parsed;
+  }
+  return {
+    targets: parsed.adapters.map((adapter) => {
+      const { adapter: target, ...rest } = adapter;
+      return { target, ...rest };
+    }),
+  };
+}
+
+function unexpectedFields(adapter, allowed) {
+  return Object.keys(adapter).filter((field) => !allowed.includes(field));
+}
+
+function validateSingleRootAdapter(adapter, schemaVersion) {
+  const allowed = [
+    "adapter",
+    "release",
+    "source",
+    "archive",
+    "archive_sha256",
+    "installed_root",
+    "tree_hash_algorithm",
+    "tree_sha256",
+    "file_count",
+  ];
+  const unexpected = unexpectedFields(adapter, allowed);
+  if (unexpected.length) {
+    return failure("unsupported", "unsupported-lockfile-shape", `Unsupported field generated.adapters[].${unexpected[0]}`);
+  }
+  for (const field of allowed) {
+    if (adapter[field] === undefined) {
+      return failure("invalid", "invalid-lockfile", `Missing adapter field: ${field}`);
+    }
+  }
+  if (adapter.adapter === "opencode") {
+    return failure("unsupported", "unsupported-lockfile-shape", "opencode lockfile entries must use installed_roots.");
+  }
+  if (schemaVersion === 1 && adapter.adapter !== "codex") {
+    return failure("unsupported", "unsupported-lockfile-shape", "schema_version 1 supports only Codex lockfile entries.");
+  }
+  if (adapter.installed_root !== SINGLE_ROOTS[adapter.adapter]) {
+    return failure("unsupported", "unsupported-lockfile-shape", "Unsupported installed root.");
+  }
+  if (!isSha256(adapter.tree_sha256)) {
+    return failure("invalid", "invalid-lockfile", "Adapter tree hash must be a SHA-256 value.");
+  }
+  if (!isNonNegativeInteger(adapter.file_count)) {
+    return failure("invalid", "invalid-lockfile", "Adapter file_count must be a non-negative integer.");
+  }
+  adapter.file_count = Number.parseInt(adapter.file_count, 10);
+  return undefined;
+}
+
+function validateMultiRootAdapter(adapter) {
+  const allowed = [
+    "adapter",
+    "release",
+    "source",
+    "archive",
+    "archive_sha256",
+    "tree_hash_algorithm",
+    "installed_roots",
+    "root_hashes",
+  ];
+  const unexpected = unexpectedFields(adapter, allowed);
+  if (unexpected.length) {
+    return failure("unsupported", "unsupported-lockfile-shape", `Unsupported field generated.adapters[].${unexpected[0]}`);
+  }
+  for (const field of allowed) {
     if (adapter[field] === undefined) {
       return failure("invalid", "invalid-lockfile", `Missing adapter field: ${field}`);
     }
   }
-  if (adapter.adapter !== "codex") {
-    return failure("unsupported", "unsupported-lockfile-shape", "Only codex lockfile entries are supported in this slice.");
+  if (adapter.adapter !== "opencode") {
+    return failure("unsupported", "unsupported-lockfile-shape", "Only opencode supports multi-root lockfile entries.");
+  }
+  const rootRoles = Object.keys(adapter.installed_roots).sort();
+  const hashRoles = Object.keys(adapter.root_hashes).sort();
+  if (!rootRoles.length || rootRoles.join("\n") !== hashRoles.join("\n")) {
+    return failure("invalid", "invalid-lockfile", "installed_roots and root_hashes roles must match.");
+  }
+  for (const role of rootRoles) {
+    if (!Object.hasOwn(OPENCODE_ROOTS, role) || adapter.installed_roots[role] !== OPENCODE_ROOTS[role]) {
+      return failure("unsupported", "unsupported-lockfile-shape", "Unsupported opencode installed root.");
+    }
+    const hash = adapter.root_hashes[role];
+    if (!hash || !isSha256(hash.tree_sha256)) {
+      return failure("invalid", "invalid-lockfile", "Adapter root hash must be a SHA-256 value.");
+    }
+    if (!isNonNegativeInteger(hash.file_count)) {
+      return failure("invalid", "invalid-lockfile", "Adapter root file_count must be a non-negative integer.");
+    }
+    hash.file_count = Number.parseInt(hash.file_count, 10);
+  }
+  return undefined;
+}
+
+function validateAdapter(adapter, schemaVersion) {
+  if (!SUPPORTED_ADAPTERS.has(adapter.adapter)) {
+    return failure("unsupported", "unsupported-lockfile-shape", "Unsupported lockfile adapter.");
   }
   if (!SUPPORTED_SOURCES.has(adapter.source)) {
     return failure("unsupported", "unsupported-lockfile-shape", "Unsupported lockfile adapter source.");
@@ -174,17 +344,27 @@ function validateAdapter(adapter) {
   if (adapter.tree_hash_algorithm !== "rigorloop-tree-hash-v1") {
     return failure("unsupported", "unsupported-lockfile-shape", "Unsupported tree hash algorithm.");
   }
-  if (adapter.installed_root !== ".agents/skills") {
-    return failure("unsupported", "unsupported-lockfile-shape", "Unsupported installed root.");
+  if (!isSha256(adapter.archive_sha256)) {
+    return failure("invalid", "invalid-lockfile", "Adapter archive hash must be a SHA-256 value.");
   }
-  if (!isSha256(adapter.archive_sha256) || !isSha256(adapter.tree_sha256)) {
-    return failure("invalid", "invalid-lockfile", "Adapter hashes must be SHA-256 values.");
-  }
-  const fileCount = Number.parseInt(adapter.file_count, 10);
-  if (!/^\d+$/.test(String(adapter.file_count)) || !Number.isInteger(fileCount) || fileCount < 0) {
-    return failure("invalid", "invalid-lockfile", "Adapter file_count must be a non-negative integer.");
+  if (adapter.installed_roots !== undefined || adapter.root_hashes !== undefined) {
+    if (schemaVersion !== 2) {
+      return failure("unsupported", "unsupported-lockfile-shape", "Multi-root lockfile entries require schema_version 2.");
+    }
+    return validateMultiRootAdapter(adapter);
   }
-  adapter.file_count = fileCount;
+  return validateSingleRootAdapter(adapter, schemaVersion);
+}
+
+function validateTarget(target) {
+  const adapter = { ...target, adapter: target.target };
+  delete adapter.target;
+  const error = validateAdapter(adapter, 2);
+  if (error) {
+    return error;
+  }
+  const { adapter: normalizedTarget, ...rest } = adapter;
+  Object.assign(target, { target: normalizedTarget, ...rest });
   return undefined;
 }
 
@@ -193,7 +373,7 @@ export function parseLockfile(text) {
     return failure("invalid", "invalid-lockfile", "rigorloop.lock is empty or not text.");
   }
   if (/[\[\]{}]/.test(text)) {
-    return failure("invalid", "invalid-lockfile", "rigorloop.lock is not valid strict schema_version 1 YAML.");
+    return failure("invalid", "invalid-lockfile", "rigorloop.lock is not valid strict YAML.");
   }
 
   const lines = text.replace(/\r\n?/g, "\n").split("\n");
@@ -209,7 +389,8 @@ export function parseLockfile(text) {
     }
   }
   const schemaVersion = parseScalar(top.get("schema_version"));
-  if (!/^\d+$/.test(schemaVersion) || Number.parseInt(schemaVersion, 10) !== 1) {
+  const parsedSchemaVersion = Number.parseInt(schemaVersion, 10);
+  if (!/^\d+$/.test(schemaVersion) || ![1, 2, 3].includes(parsedSchemaVersion)) {
     return failure("unsupported", "unsupported-lockfile-shape", "Unsupported lockfile schema_version.");
   }
 
@@ -235,6 +416,33 @@ export function parseLockfile(text) {
     return failure("invalid", "invalid-lockfile", "Invalid manifest lockfile entry.");
   }
 
+  if (parsedSchemaVersion === 3) {
+    const targetResult = parseTargets(lines);
+    if (targetResult.ok === false) {
+      return targetResult;
+    }
+    if (targetResult.missing || !targetResult.targets.length) {
+      return failure("invalid", "invalid-lockfile", "generated.targets must contain at least one target entry.");
+    }
+    for (const target of targetResult.targets) {
+      const targetError = validateTarget(target);
+      if (targetError) {
+        return targetError;
+      }
+    }
+    return {
+      ok: true,
+      lockfile: {
+        schema_version: parsedSchemaVersion,
+        rigorloop: rigorloop.fields,
+        manifest: manifest.fields,
+        generated: {
+          targets: targetResult.targets,
+        },
+      },
+    };
+  }
+
   const adapterResult = parseAdapters(lines);
   if (adapterResult.ok === false) {
     return adapterResult;
@@ -243,7 +451,7 @@ export function parseLockfile(text) {
     return failure("invalid", "invalid-lockfile", "generated.adapters must contain at least one adapter entry.");
   }
   for (const adapter of adapterResult.adapters) {
-    const adapterError = validateAdapter(adapter);
+    const adapterError = validateAdapter(adapter, parsedSchemaVersion);
     if (adapterError) {
       return adapterError;
     }
@@ -252,7 +460,7 @@ export function parseLockfile(text) {
   return {
     ok: true,
     lockfile: {
-      schema_version: 1,
+      schema_version: parsedSchemaVersion,
       rigorloop: rigorloop.fields,
       manifest: manifest.fields,
       generated: {
@@ -263,9 +471,19 @@ export function parseLockfile(text) {
 }
 
 export function serializeLockfile(lockfile) {
-  const adapters = [...lockfile.generated.adapters].sort((left, right) => left.adapter.localeCompare(right.adapter));
+  const isTargetSchema = lockfile.schema_version === 3;
+  const sourceEntries = lockfile.generated.targets ?? lockfile.generated.adapters;
+  const entries = [...sourceEntries].map((entry) => {
+    if (isTargetSchema || entry.adapter) {
+      return entry;
+    }
+    const { target, ...rest } = entry;
+    return { adapter: target, ...rest };
+  }).sort((left, right) =>
+    (left.target ?? left.adapter).localeCompare(right.target ?? right.adapter),
+  );
   const lines = [
-    "schema_version: 1",
+    `schema_version: ${lockfile.schema_version ?? 2}`,
     "",
     "rigorloop:",
     `  package: "${lockfile.rigorloop.package}"`,
@@ -276,20 +494,37 @@ export function serializeLockfile(lockfile) {
     `  sha256: "${lockfile.manifest.sha256}"`,
     "",
     "generated:",
-    "  adapters:",
+    isTargetSchema ? "  targets:" : "  adapters:",
   ];
-  for (const adapter of adapters) {
+  for (const adapter of entries) {
     lines.push(
-      `    - adapter: ${adapter.adapter}`,
+      isTargetSchema ? `    - target: ${adapter.target}` : `    - adapter: ${adapter.adapter}`,
       `      release: "${adapter.release}"`,
       `      source: ${adapter.source}`,
       `      archive: "${adapter.archive}"`,
       `      archive_sha256: "${adapter.archive_sha256}"`,
-      `      installed_root: "${adapter.installed_root}"`,
-      `      tree_hash_algorithm: ${adapter.tree_hash_algorithm}`,
-      `      tree_sha256: "${adapter.tree_sha256}"`,
-      `      file_count: ${adapter.file_count}`,
     );
+    if (adapter.installed_roots) {
+      lines.push(`      tree_hash_algorithm: ${adapter.tree_hash_algorithm}`, "      installed_roots:");
+      for (const [role, root] of Object.entries(adapter.installed_roots)) {
+        lines.push(`        ${role}: "${root}"`);
+      }
+      lines.push("      root_hashes:");
+      for (const [role, hash] of Object.entries(adapter.root_hashes)) {
+        lines.push(
+          `        ${role}:`,
+          `          tree_sha256: "${hash.tree_sha256}"`,
+          `          file_count: ${hash.file_count}`,
+        );
+      }
+    } else {
+      lines.push(
+        `      installed_root: "${adapter.installed_root}"`,
+        `      tree_hash_algorithm: ${adapter.tree_hash_algorithm}`,
+        `      tree_sha256: "${adapter.tree_sha256}"`,
+        `      file_count: ${adapter.file_count}`,
+      );
+    }
   }
   return `${lines.join("\n")}\n`;
 }

package/dist/metadata/adapter-artifacts-v0.2.0.json

@@ -0,0 +1,31 @@
+{
+  "schema_version": 1,
+  "release": {
+    "version": "v0.2.0",
+    "source_repository": "xiongxianfei/rigorloop",
+    "source_commit": "0649434a75561bb8e2922a612e0121a095233687",
+    "release_tag": "v0.2.0",
+    "published_at": "2026-05-23"
+  },
+  "metadata": {
+    "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.2.0/adapter-artifacts-v0.2.0.json",
+    "sha256": "0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "artifacts": [
+    {
+      "adapter": "codex",
+      "archive": "rigorloop-adapter-codex-v0.2.0.zip",
+      "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.2.0/rigorloop-adapter-codex-v0.2.0.zip",
+      "sha256": "b7a8b5fcb4abf25eccb90868eb43d87943ee0bb526451910fb2d59f4844d41b3",
+      "size_bytes": 105317,
+      "install_root": ".agents/skills",
+      "tree_hash_algorithm": "rigorloop-tree-hash-v1",
+      "tree_sha256": "6c01d71d2a0e4cd3b276092728f52de23345095b25ce2135b1a0759afd25c12e",
+      "file_count": 38
+    }
+  ],
+  "validation": {
+    "command": "python scripts/validate-adapters.py --root <release-output-dir> --version v0.2.0",
+    "result": "pass"
+  }
+}

package/dist/metadata/adapter-artifacts-v0.3.0.json

@@ -0,0 +1,65 @@
+{
+  "schema_version": 1,
+  "release": {
+    "version": "v0.3.0",
+    "source_repository": "xiongxianfei/rigorloop",
+    "source_commit": "02a9d7d6d514fc99908abf32898494dbbbae00c9",
+    "release_tag": "v0.3.0",
+    "published_at": "2026-05-24"
+  },
+  "metadata": {
+    "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.3.0/adapter-artifacts-v0.3.0.json",
+    "sha256": "0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "artifacts": [
+    {
+      "adapter": "codex",
+      "archive": "rigorloop-adapter-codex-v0.3.0.zip",
+      "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.3.0/rigorloop-adapter-codex-v0.3.0.zip",
+      "sha256": "ee5c35aa5ffaa9007aea2f2687b82c72135a42489edf56fe6427b37c55159550",
+      "size_bytes": 105318,
+      "install_root": ".agents/skills",
+      "tree_hash_algorithm": "rigorloop-tree-hash-v1",
+      "tree_sha256": "6c01d71d2a0e4cd3b276092728f52de23345095b25ce2135b1a0759afd25c12e",
+      "file_count": 38
+    },
+    {
+      "adapter": "claude",
+      "archive": "rigorloop-adapter-claude-v0.3.0.zip",
+      "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.3.0/rigorloop-adapter-claude-v0.3.0.zip",
+      "sha256": "91e0dd0d1573b7b3cfa5dfefb54a98b85dfe66d042889ecb8ba691f5c7bdc9e3",
+      "size_bytes": 104643,
+      "install_root": ".claude/skills",
+      "tree_hash_algorithm": "rigorloop-tree-hash-v1",
+      "tree_sha256": "8d1378e2b66be8502ef07a0013a60b19276b500c719056824a50335e4d1d3d1b",
+      "file_count": 38
+    },
+    {
+      "adapter": "opencode",
+      "archive": "rigorloop-adapter-opencode-v0.3.0.zip",
+      "url": "https://github.com/xiongxianfei/rigorloop/releases/download/v0.3.0/rigorloop-adapter-opencode-v0.3.0.zip",
+      "sha256": "89f0b8f58681dc4563da6e4918ea039a2ed0dcca1dc84caabaf9836ea32fa0db",
+      "size_bytes": 104887,
+      "install_root": ".opencode/skills",
+      "tree_hash_algorithm": "rigorloop-tree-hash-v1",
+      "tree_sha256": "8d1378e2b66be8502ef07a0013a60b19276b500c719056824a50335e4d1d3d1b",
+      "file_count": 38,
+      "skills_only_compatibility": {
+        "releases": [
+          "v0.3.0"
+        ]
+      }
+    }
+  ],
+  "compatibility": {
+    "opencode_skills_only": {
+      "releases": [
+        "v0.3.0"
+      ]
+    }
+  },
+  "validation": {
+    "command": "python scripts/validate-adapters.py --root <release-output-dir> --version v0.3.0",
+    "result": "pass"
+  }
+}

package/dist/metadata/releases.json

@@ -1,11 +1,11 @@
 {
   "schema_version": 1,
   "releases": {
-    "v0.1.5": {
+    "v0.3.0": {
       "source_repository": "xiongxianfei/rigorloop",
-      "release_tag": "v0.1.5",
-      "bundled_metadata": "adapter-artifacts-v0.1.5.json",
-      "bundled_metadata_sha256": "af43fe972d10f656f229909a9e764e652801fa3c0ae2df40a357ea4d069d7e7e"
+      "release_tag": "v0.3.0",
+      "bundled_metadata": "adapter-artifacts-v0.3.0.json",
+      "bundled_metadata_sha256": "510060d820851b98ec864d7727c3acb730e03afe8212bdfdd9ecead07100563d"
     }
   }
 }

package/package.json

@@ -1,7 +1,27 @@
 {
   "name": "@xiongxianfei/rigorloop",
-  "version": "0.1.5",
-  "description": "RigorLoop CLI.",
+  "version": "0.3.0",
+  "description": "Git-first workflow for AI coding agents: proposals, specs, tests, review gates, and durable validation evidence from idea to PR.",
+  "keywords": [
+    "ai-agents",
+    "ai-coding",
+    "coding-agent",
+    "agentic-workflow",
+    "llm",
+    "developer-tools",
+    "software-engineering",
+    "code-review",
+    "git-workflow",
+    "cli",
+    "npm-package",
+    "claude-code",
+    "codex",
+    "opencode",
+    "workflow",
+    "testing",
+    "validation",
+    "pull-requests"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/xiongxianfei/rigorloop"