skillpacks 0.1.0

package/packs/monorepo/scripts/mono-detect.sh

@@ -0,0 +1,270 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: mono-detect.sh [root] [--check-stale]
+
+Detect a pnpm workspace monorepo and write .agents/monorepo.json.
+
+Arguments:
+  root           Repository root to inspect. Defaults to current directory.
+  --check-stale  Exit 0 without rewriting when .agents/monorepo.json is fresh.
+
+Output:
+  .agents/monorepo.json with workspace manager, build orchestrator, packages,
+  internal dependency graph, Turbo pipeline names, and detection timestamp.
+EOF
+}
+
+ROOT=""
+CHECK_STALE=false
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    --check-stale)
+      CHECK_STALE=true
+      shift
+      ;;
+    *)
+      if [[ -n "$ROOT" ]]; then
+        echo "ERROR: unexpected argument: $1" >&2
+        usage >&2
+        exit 2
+      fi
+      ROOT="$1"
+      shift
+      ;;
+  esac
+done
+
+ROOT="${ROOT:-$(pwd)}"
+ROOT="$(cd "$ROOT" && pwd)"
+
+node - "$ROOT" "$CHECK_STALE" <<'NODE'
+const fs = require("fs");
+const path = require("path");
+
+const root = process.argv[2];
+const checkStaleOnly = process.argv[3] === "true";
+const workspaceFile = path.join(root, "pnpm-workspace.yaml");
+const turboFile = path.join(root, "turbo.json");
+const outputFile = path.join(root, ".agents", "monorepo.json");
+
+function fail(message, code = 1) {
+  console.error(`ERROR: ${message}`);
+  process.exit(code);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch (error) {
+    fail(`failed to parse JSON at ${path.relative(root, file)}: ${error.message}`);
+  }
+}
+
+function statMtime(file) {
+  return fs.existsSync(file) ? fs.statSync(file).mtimeMs : 0;
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join("/");
+}
+
+function normalizeWorkspacePattern(pattern) {
+  let value = pattern.trim();
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1);
+  }
+  return value.trim();
+}
+
+function parsePnpmWorkspaceGlobs(file) {
+  const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
+  const globs = [];
+  let inPackages = false;
+  let packageIndent = -1;
+
+  for (const rawLine of lines) {
+    const withoutComment = rawLine.replace(/\s+#.*$/, "");
+    if (!withoutComment.trim()) continue;
+
+    const indent = withoutComment.match(/^\s*/)[0].length;
+    const trimmed = withoutComment.trim();
+
+    if (/^packages\s*:\s*$/.test(trimmed)) {
+      inPackages = true;
+      packageIndent = indent;
+      continue;
+    }
+
+    if (inPackages && indent <= packageIndent && !trimmed.startsWith("-")) {
+      inPackages = false;
+    }
+
+    if (inPackages && trimmed.startsWith("-")) {
+      const pattern = normalizeWorkspacePattern(trimmed.slice(1));
+      if (pattern && !pattern.startsWith("!")) globs.push(pattern);
+    }
+  }
+
+  return [...new Set(globs)];
+}
+
+function walkDirs(dir, results = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if ([".git", "node_modules", ".turbo", ".agents"].includes(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    results.push(fullPath);
+    walkDirs(fullPath, results);
+  }
+  return results;
+}
+
+function globToRegex(pattern) {
+  let escaped = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      escaped += ".*";
+      index += 1;
+    } else if (char === "*") {
+      escaped += "[^/]*";
+    } else {
+      escaped += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${escaped}$`);
+}
+
+function packageDirsFromGlobs(globs) {
+  const candidates = walkDirs(root)
+    .filter((dir) => fs.existsSync(path.join(dir, "package.json")))
+    .map((dir) => toPosix(path.relative(root, dir)))
+    .filter(Boolean);
+
+  const regexes = globs.map(globToRegex);
+  return candidates
+    .filter((candidate) => regexes.some((regex) => regex.test(candidate)))
+    .sort();
+}
+
+function readTurboPipelines() {
+  if (!fs.existsSync(turboFile)) return [];
+  const turbo = readJson(turboFile);
+  const tasks = turbo.tasks || turbo.pipeline || {};
+  if (!tasks || typeof tasks !== "object" || Array.isArray(tasks)) return [];
+  return Object.keys(tasks).sort();
+}
+
+function collectPackageJsonFiles(packageDirs) {
+  return packageDirs.map((dir) => path.join(root, dir, "package.json"));
+}
+
+function isFresh(packageJsonFiles) {
+  if (!fs.existsSync(outputFile)) return false;
+  const outputMtime = statMtime(outputFile);
+  const inputs = [workspaceFile, turboFile, ...packageJsonFiles].filter((file) => fs.existsSync(file));
+  return inputs.every((file) => statMtime(file) <= outputMtime);
+}
+
+function findCycle(graph) {
+  const visiting = new Set();
+  const visited = new Set();
+  const stack = [];
+
+  function visit(node) {
+    if (visiting.has(node)) {
+      const start = stack.indexOf(node);
+      return stack.slice(start).concat(node);
+    }
+    if (visited.has(node)) return null;
+
+    visiting.add(node);
+    stack.push(node);
+    for (const next of graph[node] || []) {
+      const cycle = visit(next);
+      if (cycle) return cycle;
+    }
+    stack.pop();
+    visiting.delete(node);
+    visited.add(node);
+    return null;
+  }
+
+  for (const node of Object.keys(graph).sort()) {
+    const cycle = visit(node);
+    if (cycle) return cycle;
+  }
+  return null;
+}
+
+if (!fs.existsSync(workspaceFile)) {
+  fail("not a detected pnpm monorepo: pnpm-workspace.yaml not found");
+}
+
+const workspaceGlobs = parsePnpmWorkspaceGlobs(workspaceFile);
+if (workspaceGlobs.length === 0) {
+  fail("pnpm-workspace.yaml does not define any packages globs");
+}
+
+const packageDirs = packageDirsFromGlobs(workspaceGlobs);
+const packageJsonFiles = collectPackageJsonFiles(packageDirs);
+
+if (checkStaleOnly && isFresh(packageJsonFiles)) {
+  console.log(`fresh: ${path.relative(root, outputFile)}`);
+  process.exit(0);
+}
+
+const rawPackages = packageDirs.map((relativePath) => {
+  const file = path.join(root, relativePath, "package.json");
+  const pkg = readJson(file);
+  if (!pkg.name || typeof pkg.name !== "string") {
+    fail(`package.json missing string name: ${relativePath}/package.json`);
+  }
+  return {
+    name: pkg.name,
+    path: relativePath,
+    dependencies: Object.keys(pkg.dependencies || {}).sort(),
+    devDependencies: Object.keys(pkg.devDependencies || {}).sort(),
+    scripts: pkg.scripts && typeof pkg.scripts === "object" && !Array.isArray(pkg.scripts) ? pkg.scripts : {}
+  };
+});
+
+const packageNames = new Set(rawPackages.map((pkg) => pkg.name));
+if (packageNames.size !== rawPackages.length) {
+  fail("duplicate workspace package names detected");
+}
+
+const dependencyGraph = {};
+for (const pkg of rawPackages) {
+  dependencyGraph[pkg.name] = [...new Set([...pkg.dependencies, ...pkg.devDependencies])].sort();
+  dependencyGraph[pkg.name] = dependencyGraph[pkg.name].filter((dependency) => packageNames.has(dependency));
+}
+
+const cycle = findCycle(dependencyGraph);
+if (cycle) {
+  fail(`workspace dependency graph contains a cycle: ${cycle.join(" -> ")}`);
+}
+
+const output = {
+  workspace_manager: "pnpm",
+  build_orchestrator: fs.existsSync(turboFile) ? "turborepo" : null,
+  root,
+  packages: rawPackages,
+  dependency_graph: dependencyGraph,
+  turbo_pipelines: readTurboPipelines(),
+  detected_at: new Date().toISOString()
+};
+
+fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+fs.writeFileSync(outputFile, `${JSON.stringify(output, null, 2)}\n`);
+console.log(`wrote ${path.relative(root, outputFile)} (${rawPackages.length} packages)`);
+NODE

package/packs/monorepo/scripts/monorepo-validate.sh

@@ -0,0 +1,278 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage: monorepo-validate.sh [--skip-fixtures] [--fixtures-dir DIR]
+
+Validate the monorepo pack contracts, mirrored skill structure, Codex
+manifests, and fixture-backed scripts.
+
+Options:
+  --skip-fixtures     Run contract, parity, and manifest checks only.
+  --fixtures-dir DIR  Fixture root. Defaults to tests/fixtures/monorepo.
+EOF
+}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PACK_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+REPO_ROOT="$(cd "$PACK_DIR/../.." && pwd)"
+
+FIXTURES_DIR="$REPO_ROOT/tests/fixtures/monorepo"
+SKIP_FIXTURES=false
+FAILURES=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    --skip-fixtures)
+      SKIP_FIXTURES=true
+      shift
+      ;;
+    --fixtures-dir)
+      if [[ $# -lt 2 ]]; then
+        echo "ERROR: --fixtures-dir requires a value" >&2
+        exit 2
+      fi
+      FIXTURES_DIR="$2"
+      shift 2
+      ;;
+    *)
+      echo "ERROR: unexpected argument: $1" >&2
+      usage >&2
+      exit 2
+      ;;
+  esac
+done
+
+pass() {
+  echo "PASS: $*"
+}
+
+skip() {
+  echo "SKIP: $*"
+}
+
+fail() {
+  echo "FAIL: $*" >&2
+  FAILURES=$((FAILURES + 1))
+}
+
+require_file() {
+  local file="$1"
+  local label="$2"
+  if [[ -f "$file" ]]; then
+    pass "$label exists"
+    return 0
+  fi
+  fail "$label missing: $file"
+  return 1
+}
+
+contains() {
+  local file="$1"
+  local pattern="$2"
+  local label="$3"
+  if grep -Eiq "$pattern" "$file"; then
+    pass "$label"
+  else
+    fail "$label missing in ${file#$REPO_ROOT/}"
+  fi
+}
+
+read_frontmatter_value() {
+  local file="$1"
+  local key="$2"
+  awk -v key="$key" '
+    NR == 1 && $0 == "---" { in_fm = 1; next }
+    in_fm && $0 == "---" { exit }
+    in_fm && $0 ~ "^" key ":" {
+      sub("^[^:]+:[[:space:]]*", "")
+      print
+      exit
+    }
+  ' "$file"
+}
+
+heading_fingerprint() {
+  grep -E '^## ' "$1" | sed 's#\$#/#g'
+}
+
+check_contracts() {
+  local skill
+  local skills=()
+
+  while IFS= read -r skill; do
+    skills+=("$skill")
+  done < <(find "$PACK_DIR/claude" "$PACK_DIR/codex" -path '*/SKILL.md' -type f | sort)
+
+  if [[ "${#skills[@]}" -eq 0 ]]; then
+    fail "no monorepo pack skill contracts found"
+    return
+  fi
+
+  for skill in "${skills[@]}"; do
+    contains "$skill" '^## Augmentation Injection Pattern$' "augmentation injection section in ${skill#$REPO_ROOT/}"
+    contains "$skill" 'augmentation injection pattern' "augmentation injection language in ${skill#$REPO_ROOT/}"
+    contains "$skill" '^## Next-Step Routing$|Default next-step routing|Recommended next command' "next-step routing in ${skill#$REPO_ROOT/}"
+  done
+}
+
+check_parity() {
+  local claude_skill codex_skill skill_name key claude_value codex_value claude_headings codex_headings
+
+  for claude_skill in "$PACK_DIR"/claude/*/SKILL.md; do
+    skill_name="$(basename "$(dirname "$claude_skill")")"
+    codex_skill="$PACK_DIR/codex/$skill_name/SKILL.md"
+    if ! require_file "$codex_skill" "Codex mirror for $skill_name"; then
+      continue
+    fi
+
+    for key in name type version; do
+      claude_value="$(read_frontmatter_value "$claude_skill" "$key")"
+      codex_value="$(read_frontmatter_value "$codex_skill" "$key")"
+      if [[ "$claude_value" == "$codex_value" && -n "$claude_value" ]]; then
+        pass "$skill_name frontmatter $key matches"
+      else
+        fail "$skill_name frontmatter $key mismatch: Claude='$claude_value' Codex='$codex_value'"
+      fi
+    done
+
+    claude_headings="$(heading_fingerprint "$claude_skill")"
+    codex_headings="$(heading_fingerprint "$codex_skill")"
+    if [[ "$claude_headings" == "$codex_headings" ]]; then
+      pass "$skill_name section headings match"
+    else
+      fail "$skill_name section headings differ between Claude and Codex"
+    fi
+  done
+}
+
+check_manifests() {
+  local codex_skill skill_name manifest
+
+  for codex_skill in "$PACK_DIR"/codex/*/SKILL.md; do
+    skill_name="$(basename "$(dirname "$codex_skill")")"
+    manifest="$PACK_DIR/codex/$skill_name/agents/openai.yaml"
+    if ! require_file "$manifest" "OpenAI manifest for $skill_name"; then
+      continue
+    fi
+    contains "$manifest" '^interface:' "interface block in $skill_name manifest"
+    contains "$manifest" 'display_name:' "display_name in $skill_name manifest"
+    contains "$manifest" 'short_description:' "short_description in $skill_name manifest"
+    contains "$manifest" 'default_prompt:' "default_prompt in $skill_name manifest"
+    contains "$manifest" 'allow_implicit_invocation:' "allow_implicit_invocation in $skill_name manifest"
+  done
+}
+
+check_lane_fixtures() {
+  local valid="$FIXTURES_DIR/lane-specs-valid.json"
+  local invalid="$FIXTURES_DIR/lane-specs-invalid.json"
+
+  require_file "$valid" "valid lane-spec fixture" || return
+  require_file "$invalid" "invalid lane-spec fixture" || return
+
+  if "$SCRIPT_DIR/lane-spec-validate.sh" "$valid" >/dev/null; then
+    pass "valid lane-spec fixture passes"
+  else
+    fail "valid lane-spec fixture failed validation"
+  fi
+
+  if "$SCRIPT_DIR/lane-spec-validate.sh" "$invalid" >/dev/null 2>&1; then
+    fail "invalid lane-spec fixture unexpectedly passed"
+  else
+    pass "invalid lane-spec fixture fails as expected"
+  fi
+}
+
+json_field_equals() {
+  local file="$1"
+  local expression="$2"
+  local expected="$3"
+  local label="$4"
+
+  if node -e '
+    const fs = require("fs");
+    const data = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+    const expression = process.argv[2];
+    const expected = process.argv[3];
+    const value = Function("data", `return ${expression}`)(data);
+    const normalized = value === null ? "null" : String(value);
+    process.exit(normalized === expected ? 0 : 1);
+  ' "$file" "$expression" "$expected"; then
+    pass "$label"
+  else
+    fail "$label"
+  fi
+}
+
+check_detection_fixture() {
+  local fixture_name="$1"
+  local expected_orchestrator="$2"
+  local expected_count="$3"
+  local source="$FIXTURES_DIR/$fixture_name"
+  local work_dir="$TMP_DIR/$fixture_name"
+  local output="$work_dir/.agents/monorepo.json"
+
+  require_file "$source/pnpm-workspace.yaml" "$fixture_name workspace file" || return
+  cp -R "$source" "$work_dir"
+
+  if "$SCRIPT_DIR/mono-detect.sh" "$work_dir" >/dev/null; then
+    pass "$fixture_name detection runs"
+  else
+    fail "$fixture_name detection failed"
+    return
+  fi
+
+  require_file "$output" "$fixture_name monorepo artifact" || return
+  json_field_equals "$output" 'data.workspace_manager' "pnpm" "$fixture_name workspace manager is pnpm"
+  json_field_equals "$output" 'data.build_orchestrator' "$expected_orchestrator" "$fixture_name build orchestrator is $expected_orchestrator"
+  json_field_equals "$output" 'data.packages.length' "$expected_count" "$fixture_name package count is $expected_count"
+}
+
+check_detection_fixtures() {
+  local not_monorepo="$FIXTURES_DIR/not-monorepo"
+
+  check_detection_fixture "pnpm-turbo" "turborepo" "3"
+  check_detection_fixture "pnpm-only" "null" "1"
+
+  require_file "$not_monorepo/package.json" "not-monorepo fixture package" || return
+  if "$SCRIPT_DIR/mono-detect.sh" "$not_monorepo" >/dev/null 2>&1; then
+    fail "not-monorepo fixture unexpectedly detected"
+  else
+    pass "not-monorepo fixture fails detection as expected"
+  fi
+}
+
+check_fixtures() {
+  if "$SKIP_FIXTURES"; then
+    skip "fixture checks skipped by --skip-fixtures"
+    return
+  fi
+
+  if [[ ! -d "$FIXTURES_DIR" ]]; then
+    fail "fixtures directory missing: $FIXTURES_DIR"
+    return
+  fi
+
+  TMP_DIR="$(mktemp -d)"
+  trap 'rm -rf "$TMP_DIR"' EXIT
+
+  check_lane_fixtures
+  check_detection_fixtures
+}
+
+check_contracts
+check_parity
+check_manifests
+check_fixtures
+
+if [[ "$FAILURES" -gt 0 ]]; then
+  echo "monorepo pack validation failed with $FAILURES failure(s)" >&2
+  exit 1
+fi
+
+echo "monorepo pack validation passed"

package/packs/ord/PACK.md

@@ -0,0 +1,33 @@
+# ORD Pack
+
+OSS Rapid Distribution — rapid shipping of open-source developer tools, CLI utilities, and npm packages. Part of the ORD deck.
+
+Use this pack when you want to move from developer pain point to published package in days. ORD is the fast lane for testing devtool concepts before committing to full Devtool AFPS depth.
+
+Install in a project with:
+
+```bash
+scripts/pack.sh install ord
+```
+
+Then refresh local skill links if needed:
+
+```bash
+scripts/pack.sh refresh
+```
+
+## Default Flow
+
+```text
+ord-scan -> ord-align -> ord-ship
+```
+
+## Graduation
+
+When an ORD package gains traction (stars, downloads, issues), graduate to the full Devtool AFPS pipeline: `scripts/pack.sh install devtool`.
+
+## Skills
+
+- `ord-scan`: Scan for OSS tool opportunities from npm gaps, GitHub trends, and developer pain points.
+- `ord-align`: Validate whether the tool is worth building — namespace check, existing solutions, effort estimate.
+- `ord-ship`: Publish to npm, create README, set up repo, and log the shipment.

package/packs/ord/claude/ord-align/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: ord-align
+description: Validate whether an OSS tool is worth building — namespace, existing solutions, effort estimate
+type: analysis
+version: v0.0
+interview_depth: light
+---
+
+# ORD Align
+
+Invoke as `/ord-align`.
+
+Rapid alignment check for an ORD candidate. Validates feasibility, checks the npm namespace, surveys existing solutions, and produces a go/no-go decision.
+
+## Process
+
+1. **Identify candidate:** Read the most recent ord-scan output or `$ARGUMENTS` for the tool concept to evaluate.
+2. **Light interview (1-3 questions):** Ask only what's needed:
+   - Target developer persona unclear?
+   - Scope boundary question (what's in v1 vs. later)?
+   - Licensing or dependency concern?
+3. **Check dimensions:**
+   - **npm namespace:** Is the desired package name available? Check `npm view <name>`. If taken, is a scoped package (`@scope/name`) viable?
+   - **Existing solutions:** What already exists? Why is it insufficient? Be honest — if a good solution exists, this is a NO-GO.
+   - **Feasibility:** Can v1 ship in 1-3 days? What's the minimal useful API surface?
+   - **Effort estimate:** Break down into: core logic, CLI/API surface, tests, docs, publish pipeline.
+   - **Adoption signal:** Is there evidence developers want this? (GitHub issues, forum posts, tweet complaints)
+4. **Verdict:** GO or NO-GO with one-line rationale.
+5. **If GO:** Produce a 1-page alignment doc:
+   - Package name (confirmed available or scoped fallback)
+   - One-line description (what goes in package.json)
+   - Target developer persona
+   - Core API surface (3-5 exported functions or CLI commands)
+   - Tech stack (TypeScript, build tool, test framework)
+   - Ship deadline (date)
+   - Success metric (downloads, stars, or adoption signal to watch)
+
+## Output
+
+Write alignment doc to `alignment/ord-<slug>.md` if GO. End with:
+
+```md
+**Verdict:** GO / NO-GO
+**Next work:** <build the package / scan for another candidate>
+**Recommended next command:** /ord-ship / /ord-scan
+```
+
+## Constraints
+
+- Do not begin implementation.
+- Keep the alignment doc to 1 page.
+- If the candidate came from ord-scan, reference it; don't re-research.
+- Run `npm view` to check namespace availability when possible.
+
+## Default Shipping Contract
+
+Follow the shared shipping contract convention.

package/packs/ord/claude/ord-scan/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: ord-scan
+description: Scan for OSS tool opportunities from npm gaps, GitHub trends, and developer pain points
+type: research
+version: v0.0
+interview_depth: none
+---
+
+# ORD Scan
+
+Invoke as `/ord-scan`.
+
+Rapid opportunity scanner for open-source developer tools. Identifies gaps in the npm ecosystem, trending developer pain points, and CLI/library opportunities.
+
+## Process
+
+1. **Gather signals:** Scan for opportunities across:
+   - npm packages with high download counts but poor DX, stale maintenance, or missing features
+   - GitHub trending repos and discussions revealing unmet developer needs
+   - Stack Overflow / Reddit / HN threads where developers complain about tooling gaps
+   - Build tool, testing, CLI, and workflow automation gaps
+   - Wrapper/adapter opportunities (bridging two popular tools that don't talk to each other)
+2. **Filter for ORD fit:** Each candidate must pass:
+   - Buildable and publishable in 1-3 days
+   - Clear value proposition explainable in one sentence
+   - npm namespace likely available (or scoped package viable)
+   - No heavy runtime dependencies or complex native bindings
+   - Solves a real, recurring developer pain point (not a toy)
+3. **Produce brief:** For each viable candidate (aim for 2-5), output:
+   - One-line concept
+   - Problem it solves (the pain point)
+   - Why it doesn't exist yet (or why existing solutions fall short)
+   - Build estimate (hours)
+   - Distribution: npm, GitHub, dev community channels
+   - Monetization potential (none / sponsorware / freemium CLI / premium features)
+4. **Rank and recommend:** Order candidates by (developer pain × feasibility × ecosystem gap size) and highlight the top pick.
+
+## Output
+
+A ranked list of 2-5 OSS tool candidates with lightweight briefs. End with:
+
+```md
+**Top pick:** <concept name>
+**Next work:** validate top pick feasibility and namespace
+**Recommended next command:** /ord-align
+```
+
+## Constraints
+
+- Do not produce full idea-scope-brief depth — keep each candidate to a few lines.
+- Do not begin implementation or scaffolding.
+- Do not run paid API calls or external account actions.
+- If `$ARGUMENTS` specifies a domain or constraint (e.g., "CLI tools" or "testing"), narrow the scan.
+
+## Default Shipping Contract
+
+Follow the shared shipping contract convention.

package/packs/ord/claude/ord-ship/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## v0.1
+
+- Added the `devtool` pack installation prerequisite before recommending `/devtool-adoption` as the graduation route.
+
+## v0.0
+
+- Initial ORD shipping workflow.