@keighleykodric/weeve 0.1.1 → 0.1.2

package/README.md

@@ -1,8 +1,8 @@
 # 🧵 Weeve
 
-Cross-functional alignment system. 14+ lanes that audit strategy, product, design, engineering, QA, security, marketing, sales, and UX — then synthesize into one prioritized roadmap.
+Cross-functional contract framework. Each domain writes findings in the same versioned schema shape — Pilot reads them all and surfaces what conflicts, what blocks the ship, and what to do first. Observability for AI-orchestrated execution.
 
-Markdown-in-git. BYO everything. Each lane writes a `<lane>-recommendations.md` file in the same shape. Pilot reads them all and produces a single roadmap. The alignment property: findings from different domains compose, rather than sit in separate files nobody reads.
+Markdown-in-git. BYO everything. The contract shape is the durable asset: a versioned schema that every lane writes to and Pilot synthesizes from. Findings from different domains compose because they share a common structure — not because a platform forces alignment.
 
 ---
 
@@ -10,9 +10,9 @@ Markdown-in-git. BYO everything. Each lane writes a `<lane>-recommendations.md`
 
 1. Install the lanes you need
 2. Run each lane against your product (`/<lane>-intro` to start)
-3. Each lane writes findings to `docs/<lane>/<lane>-recommendations.md`
-4. Run `/pilot-roadmap` — Pilot reads all lane outputs and synthesizes a prioritized roadmap
-5. Run `/pilot-ship` — autonomous worker picks tasks from the roadmap and ships them
+3. Each lane writes findings to `docs/<lane>/<lane>-signals.md`
+4. Run `/pilot-priorities` — Pilot reads all lane outputs and synthesizes a prioritized backlog
+5. Run `/pilot-ship` — autonomous worker picks tasks from the priorities file and ships them
 
 ---
 
@@ -66,9 +66,13 @@ Markdown-in-git. BYO everything. Each lane writes a `<lane>-recommendations.md`
 
 ---
 
+> **Trust model:** Skills execute with your OS permissions — only install from trusted sources.
+
+---
+
 ## You don't need every lane
 
-Install only the lanes that match your team. If marketing doesn't use Maven, that's fine — Maven won't appear in the Pilot roadmap, and nothing breaks.
+Install only the lanes that match your team. If marketing doesn't use Maven, that's fine — Maven won't appear in the Pilot priorities file, and nothing breaks.
 
 Departments without a lane can still contribute. Any team member can feed context into another lane's intake skill — paste a doc, a ticket link, or a screenshot into `/compass-intake` or `/layers-plus-intake` and it gets scoped and routed. You don't need a lane installed to provide input; you just won't get lane-specific findings back.
 
@@ -96,6 +100,16 @@ npx @keighleykodric/weeve add all            # Everything
 
 Every preset includes Pilot — it's the synthesis layer that makes the lanes compose.
 
+### Version pinning
+
+Pin to a tagged release for reproducible installs:
+
+```
+npx skills add keighleykodric/weeve-compass@v0.1.0
+```
+
+See [Releases](https://github.com/keighleykodric/weeve/releases) for available versions.
+
 ---
 
 ## First-run order
@@ -106,22 +120,64 @@ See [WORKFLOW.md](WORKFLOW.md) for the full cadence, within-lane sequences, and
 
 ---
 
-## The alignment property
+## The contract shape
 
-Each lane writes findings independently. Pilot reads them all and surfaces:
+Each lane writes findings independently, in the same schema. Pilot reads them all and surfaces:
 - Cross-lane conflicts (strategy says X, design says Y)
 - Ship gates (Guard or Verify can block `/pilot-ship`)
 - Priority synthesis (what to do first, across all domains)
 
-The claim: running all lanes against the same product produces coherent, composable output — not just a bigger folder of tools.
+The schema is what makes the lanes composable. A finding from Guard and a finding from Compass use the same severity vocabulary, status field, and ID prefix — so Pilot can synthesize them without translation. The contract is the moat, not the lane count.
 
 ---
 
 ## Schema
 
-All lane recommendations files follow a versioned schema: [recommendations-schema.md](docs/shared/recommendations-schema.md) (v0.3).
+All lane signals files follow a versioned schema: [signals-schema.md](spec/schema.md) (v0.4).
+
+The schema is the contract. Severity uses `🔴 High / 🟡 Medium / 🟢 Low`. Lane files never use Now/Next/Watch — that vocabulary belongs to Pilot's priorities output. The manifest hierarchy (`weeve.yaml` → `road.yaml` → `lane.yaml`) governs multi-lane configuration.
+
+---
+
+## Alternative installation (git clone)
+
+If you prefer not to use the npm installer, you can clone lanes directly and verify integrity:
+
+```bash
+# Clone a specific tagged release
+git clone --branch v0.1.0 --depth 1 https://github.com/keighleykodric/weeve-compass.git
+
+# Verify the commit SHA matches the published release
+cd weeve-compass
+git rev-parse HEAD
+# Compare against the SHA listed on https://github.com/keighleykodric/weeve-compass/releases/tag/v0.1.0
+
+# Verify skills-lock.json integrity (if present)
+# skills-lock.json contains SHA-256 hashes of all SKILL.md files
+cat skills-lock.json
+# Manually verify: shasum -a 256 skills/<skill-dir>/SKILL.md
+```
+
+Then symlink or copy the skills directory into `~/.claude/skills/`:
+
+```bash
+cp -r skills/* ~/.claude/skills/
+```
+
+This bypasses the npm registry entirely. You can audit all code before installation and verify that file contents match the published hashes in `skills-lock.json`.
+
+---
+
+## Terminology
+
+Two terms in Weave overlap with common engineering vocabulary:
+
+| Term | In Weave | In engineering contexts |
+|---|---|---|
+| **Operator** | The practitioner running the lanes — a cross-functional lead, designer, or strategist using Claude Code | Infrastructure operator, DevOps engineer, Kubernetes operator |
+| **Schema** | The governance spec that defines how lanes write findings (`spec/schema.md`) | Database schema, OpenAPI spec, JSON Schema |
 
-The schema is the durable asset. Severity uses `🔴 High / 🟡 Medium / 🟢 Low`. Lane files never use Now/Next/Watch — that vocabulary belongs to Pilot's roadmap output.
+If you come from an infrastructure or data engineering background: Weave's "Operator" is closer to "practitioner" or "user," and Weave's "Schema" is closer to "contract format" or "output spec."
 
 ---
 

package/bin/weeve.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
 
 const ORG = "keighleykodric";
 
@@ -37,6 +40,27 @@ const PRESETS = {
   gtm: ["compass", "maven", "pitch", "pilot"],
 };
 
+// CODEOWNERS lines per lane
+const LANE_OWNERS = {
+  compass: "weeve/compass/      @leadership",
+  "layers-plus": "weeve/layers-plus/  @product",
+  felt: "weeve/felt/         @product",
+  ally: "weeve/ally/         @design",
+  rubric: "weeve/rubric/       @design",
+  forge: "weeve/forge/        @engineering",
+  helm: "weeve/helm/         @engineering",
+  verify: "weeve/verify/       @engineering",
+  guard: "weeve/guard/        @security",
+  maven: "weeve/maven/        @marketing",
+  pitch: "weeve/pitch/        @revenue",
+  pilot: "weeve/pilot/        @leadership",
+};
+
+const FIRST_STEP_ORDER = [
+  "compass", "layers-plus", "felt", "ally", "rubric",
+  "forge", "helm", "verify", "guard", "maven", "pitch", "pilot",
+];
+
 const cmd = process.argv[2];
 const args = process.argv.slice(3);
 
@@ -62,8 +86,9 @@ function installLanes(lanes) {
     console.log(`  + ${lane} — ${LANES[lane]}`);
     run(`npx skills add ${repo}`);
   }
+  // Always install framework skills from the weeve repo itself
+  run(`npx skills add ${ORG}/weeve`);
   // Show the right first step based on what was installed
-  const FIRST_STEP_ORDER = ["compass", "layers-plus", "felt", "ally", "rubric", "forge", "helm", "verify", "guard", "maven", "pitch", "pilot"];
   const firstLane = FIRST_STEP_ORDER.find((l) => lanes.includes(l));
   if (firstLane && firstLane !== "pilot") {
     console.log(`\nDone. Run /${firstLane}-intro to get started.`);
@@ -95,6 +120,421 @@ switch (cmd) {
     break;
   }
 
+  case "init": {
+    const presetArg = args[0];
+
+    // Resolve lanes to scaffold
+    let lanes;
+    if (!presetArg) {
+      lanes = Object.keys(LANES);
+    } else if (PRESETS[presetArg]) {
+      lanes = PRESETS[presetArg];
+    } else if (LANES[presetArg]) {
+      lanes = [presetArg];
+    } else {
+      console.error(`Unknown preset or lane: ${presetArg}`);
+      console.error(`Run 'weeve presets' to see available presets.`);
+      process.exit(1);
+    }
+
+    const cwd = process.cwd();
+    const yamlPath = path.join(cwd, "weeve.yaml");
+
+    // Bail if weeve.yaml already exists
+    if (fs.existsSync(yamlPath)) {
+      console.error(`Warning: weeve.yaml already exists in ${cwd}. Exiting without changes.`);
+      process.exit(1);
+    }
+
+    // 1. Create weeve/<lane>/ output folders
+    for (const lane of lanes) {
+      const laneDir = path.join(cwd, "weeve", lane);
+      fs.mkdirSync(laneDir, { recursive: true });
+      fs.writeFileSync(path.join(laneDir, ".gitkeep"), "");
+    }
+
+    // 1b. Create loom/ content-type folders based on installed lanes, plus shared/ and archive/
+    // Loom is organised by content type, not lane — multiple lanes share the same folder.
+    const loomFolders = new Set(["shared"]);
+    const LOOM_MAP = {
+      strategy:    ["compass"],
+      business:    ["compass", "guard"],
+      design:      ["ally", "layers-plus", "rubric"],
+      engineering: ["forge", "helm", "verify", "guard", "layers-plus"],
+      research:    ["felt"],
+      marketing:   ["maven", "rubric"],
+      sales:       ["pitch"],
+    };
+    for (const [folder, owners] of Object.entries(LOOM_MAP)) {
+      if (owners.some((l) => lanes.includes(l))) loomFolders.add(folder);
+    }
+    for (const folder of loomFolders) {
+      const dir = path.join(cwd, "loom", folder);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, ".gitkeep"), "");
+    }
+    fs.mkdirSync(path.join(cwd, "archive"), { recursive: true });
+
+    // 2. Write weeve.yaml
+    const projName = path.basename(cwd);
+    const projTag = projName.replace(/[^a-zA-Z0-9]/g, "").slice(0, 6).toUpperCase() || "MYP";
+    const yaml = [
+      `# weeve.yaml — generated by weeve init`,
+      `schema_version: "0.4"`,
+      ``,
+      `project:`,
+      `  name: ${projName}`,
+      `  tag: ${projTag}`,
+      `  # docs_root: ./weeve  # Uncomment to write skill outputs here instead of vault`,
+  `  # loom_root: ./loom   # Uncomment to read raw input from here instead of vault`,
+      `  # repos:              # Multi-repo: list other repos that share this tag`,
+      `  #   - name: api`,
+      `  #     path: ../my-api`,
+      `  # depends_on:         # Other weeve projects this project reads context from`,
+      `  #   - tag: API`,
+      `  #     name: Core API`,
+      `  #     relationship: api-contract`,
+      ``,
+      `roads:`,
+      `  - name: startup`,
+      `    path: roads/startup`,
+      ``,
+      `# Installed lanes: ${lanes.join(", ")}`,
+      `# Run 'weeve status' to see installed skills`,
+      ``,
+    ].join("\n");
+    fs.writeFileSync(yamlPath, yaml);
+
+    // 3a. Scaffold weeve/shared/ for skill-managed shared docs
+    const sharedDir = path.join(cwd, "weeve", "shared");
+    fs.mkdirSync(sharedDir, { recursive: true });
+
+    fs.writeFileSync(path.join(sharedDir, "weeve-project.md"), [
+      `# ${projName} — project brief`,
+      ``,
+      `<!-- What are you building, who is it for, what stage are you at? -->`,
+      `<!-- Include: product surface, current state, team size, open questions -->`,
+      ``,
+      `**What it is:**`,
+      ``,
+      `**Stage:**`,
+      ``,
+      `**Core surface:**`,
+      ``,
+      `**Current state:**`,
+      ``,
+      `**Team:**`,
+      ``,
+      `**Open questions:**`,
+      ``,
+    ].join("\n"));
+
+    fs.writeFileSync(path.join(sharedDir, "weeve-decisions.md"), [
+      `# ${projName} — key decisions`,
+      ``,
+      `<!-- Architectural, product, and strategic decisions that are settled.`,
+      `     Lanes use this to avoid re-opening closed questions. -->`,
+      `<!-- Format: - [DATE] Decision. Reason. -->`,
+      ``,
+    ].join("\n"));
+
+    fs.writeFileSync(path.join(sharedDir, "weeve-guardrails.md"), [
+      `# ${projName} — constraints`,
+      ``,
+      `<!-- Hard limits and non-negotiables. Lanes treat these as guardrails. -->`,
+      `<!-- Pilot and all lanes read this before picking or executing tasks. -->`,
+      `<!-- Examples: no external SaaS without security review, must pass WCAG AA, -->`,
+      `<!--           no breaking API changes without deprecation period -->`,
+      ``,
+    ].join("\n"));
+
+    fs.writeFileSync(path.join(sharedDir, "weeve-sources.md"), [
+      `# ${projName} — context sources`,
+      ``,
+      `<!-- Links to external docs lanes should be aware of. -->`,
+      `<!-- Org strategy, brand guidelines, API contracts, compliance docs, etc. -->`,
+      `<!-- Format: - **Label:** [Title](url) — one-line description -->`,
+      ``,
+    ].join("\n"));
+
+    // 3. Write or append CODEOWNERS
+    const codeownersPath = path.join(cwd, "CODEOWNERS");
+    const ownerLines = lanes
+      .filter((l) => LANE_OWNERS[l])
+      .map((l) => LANE_OWNERS[l]);
+    const codeownersBlock = [
+      `# Weeve lane ownership — edit to match your team structure`,
+      ...ownerLines,
+      ``,
+    ].join("\n");
+
+    if (fs.existsSync(codeownersPath)) {
+      fs.appendFileSync(codeownersPath, "\n" + codeownersBlock);
+    } else {
+      fs.writeFileSync(codeownersPath, codeownersBlock);
+    }
+
+    // 4. Summary
+    const firstLane = FIRST_STEP_ORDER.find((l) => lanes.includes(l));
+    const nextCmd = firstLane && firstLane !== "pilot"
+      ? `/${firstLane}-intro`
+      : `/pilot-intro`;
+
+    console.log(`\nWeeve initialized${presetArg ? ` (${presetArg} preset)` : ""}:\n`);
+    console.log(`  Created  weeve.yaml`);
+    console.log(`  Created  CODEOWNERS${fs.existsSync(codeownersPath) ? " (appended)" : ""}`);
+    console.log(`  Created  weeve/shared/weeve-project.md`);
+    console.log(`  Created  weeve/shared/weeve-decisions.md`);
+    console.log(`  Created  weeve/shared/weeve-guardrails.md`);
+    console.log(`  Created  weeve/shared/weeve-sources.md`);
+    console.log(`  Created  archive/`);
+    for (const lane of lanes) {
+      console.log(`  Created  weeve/${lane}/`);
+    }
+    const loomList = [...loomFolders].filter((f) => f !== "shared").sort().join("/  loom/");
+    console.log(`  Created  loom/${loomList}/  loom/shared/`);
+    console.log(`\n  weeve/  — skill outputs (written by skills)`);
+    console.log(`  loom/   — your input: drop notes, research, briefs here (organised by content type)`);
+    console.log(`  archive/ — historical snapshots\n`);
+    console.log(`\nNext: run 'weeve add ${presetArg || "all"}' to install skills, then run ${nextCmd}\n`);
+    break;
+  }
+
+  case "status": {
+    const lockPath = path.join(os.homedir(), ".claude", "skills-lock.json");
+
+    if (!fs.existsSync(lockPath)) {
+      console.log("No weeve lanes installed. Run 'weeve add <lane>' to get started.");
+      break;
+    }
+
+    let lock;
+    try {
+      lock = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+    } catch {
+      console.error(`Could not parse ${lockPath}`);
+      process.exit(1);
+    }
+
+    const skills = lock.skills || {};
+
+    // Group skills by weeve lane (source matches keighleykodric/weeve-<lane>)
+    const laneMap = {};
+    for (const [skillName, skillData] of Object.entries(skills)) {
+      const source = skillData.source || "";
+      const match = source.match(/^keighleykodric\/weeve-(.+)$/);
+      if (match) {
+        const lane = match[1];
+        if (!laneMap[lane]) {
+          laneMap[lane] = { count: 0, source };
+        }
+        laneMap[lane].count++;
+      }
+    }
+
+    if (Object.keys(laneMap).length === 0) {
+      console.log("No weeve lanes installed. Run 'weeve add <lane>' to get started.");
+      break;
+    }
+
+    console.log("\nInstalled lanes:\n");
+    const laneNames = Object.keys(laneMap);
+    const maxLane = Math.max(...laneNames.map((l) => l.length));
+    for (const lane of laneNames) {
+      const { count, source } = laneMap[lane];
+      console.log(
+        `  ${lane.padEnd(maxLane + 2)}${String(count).padStart(2)} skills   ${source}`
+      );
+    }
+
+    const firstInstalled = FIRST_STEP_ORDER.find((l) => laneMap[l]);
+    const nextCmd = firstInstalled && firstInstalled !== "pilot"
+      ? `/${firstInstalled}-intro`
+      : `/pilot-intro`;
+
+    console.log(`\n${laneNames.length} lane${laneNames.length !== 1 ? "s" : ""} installed. Run ${nextCmd} to get started.\n`);
+    break;
+  }
+
+  case "remove":
+  case "uninstall": {
+    if (!args.length) {
+      console.error("Usage: weeve remove <lane|preset> [lane2...]");
+      process.exit(1);
+    }
+
+    // Expand preset or validate individual lanes
+    let lanes;
+    if (args.length === 1 && PRESETS[args[0]]) {
+      const preset = args[0];
+      console.log(`Removing preset: ${preset} (${PRESETS[preset].join(", ")})`);
+      lanes = PRESETS[preset];
+    } else {
+      const invalid = args.filter((l) => !LANES[l]);
+      if (invalid.length) {
+        console.error(`Unknown lane(s): ${invalid.join(", ")}`);
+        console.error(`Run 'weeve list' to see available lanes.`);
+        process.exit(1);
+      }
+      lanes = args;
+    }
+
+    console.log(`\nRemoving ${lanes.length} lane(s)...\n`);
+    for (const lane of lanes) {
+      const repo = `${ORG}/weeve-${lane}`;
+      console.log(`  - ${lane}`);
+      run(`npx skills remove ${repo}`);
+    }
+    console.log(`\nDone. Removed: ${lanes.join(", ")}\n`);
+    break;
+  }
+
+  case "demo": {
+    const presetArg = args[0];
+
+    if (!presetArg) {
+      console.log("\nAvailable demos:\n");
+      const demoPreviews = {
+        core: "Prism — design token management SaaS (compass, layers-plus, ally, rubric, pilot)",
+        engineering: "Volta — internal developer platform (forge, helm, verify, guard, pilot)",
+        product: "Canvas — no-code form builder (compass, layers-plus, ally, rubric, felt, pilot)",
+        strategy: "Beacon — B2B analytics at a strategic inflection point (compass, layers-plus, maven, pilot)",
+        gtm: "Relay — outbound sales automation SaaS (compass, maven, pitch, pilot)",
+      };
+      const maxName = Math.max(...Object.keys(demoPreviews).map((k) => k.length));
+      for (const [name, desc] of Object.entries(demoPreviews)) {
+        console.log(`  ${name.padEnd(maxName + 2)}${desc}`);
+      }
+      console.log("\nUsage: weeve demo <preset>\n");
+      break;
+    }
+
+    if (!PRESETS[presetArg]) {
+      console.error(`Unknown preset: ${presetArg}`);
+      console.error("Run 'weeve demo' to see available demos.");
+      process.exit(1);
+    }
+
+    const demoSrc = path.join(__dirname, "..", "examples", presetArg, "demo");
+
+    if (!fs.existsSync(demoSrc)) {
+      console.error(`No demo found for preset: ${presetArg}`);
+      process.exit(1);
+    }
+
+    const cwd = process.cwd();
+    const weeveYaml = path.join(cwd, "weeve.yaml");
+
+    if (fs.existsSync(weeveYaml)) {
+      console.error(`weeve.yaml already exists in ${cwd}. Remove it first or run in an empty directory.`);
+      process.exit(1);
+    }
+
+    // Recursively copy demo folder to cwd
+    function copyDir(src, dest) {
+      fs.mkdirSync(dest, { recursive: true });
+      for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+          copyDir(srcPath, destPath);
+        } else {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    }
+
+    copyDir(demoSrc, cwd);
+
+    const demoNames = { core: "Prism", engineering: "Volta", product: "Canvas", strategy: "Beacon", gtm: "Relay" };
+    const demoName = demoNames[presetArg];
+    const firstLane = FIRST_STEP_ORDER.find((l) => PRESETS[presetArg].includes(l));
+    const firstCmd = firstLane && firstLane !== "pilot" ? `/${firstLane}-intro` : `/pilot-intro`;
+
+    console.log(`\nDemo ready: ${demoName} (${presetArg} preset)\n`);
+    console.log(`  weeve.yaml      project config (docs_root: ./docs)`);
+    console.log(`  docs/shared/    weeve-project.md, weeve-guardrails.md, weeve-intake.md\n`);
+    console.log(`Next steps:`);
+    console.log(`  1. weeve add ${presetArg}   — install the lanes`);
+    console.log(`  2. ${firstCmd}   — start the first lane\n`);
+    break;
+  }
+
+  case "project": {
+    const subcmd = args[0];
+
+    if (!subcmd || subcmd === "show") {
+      // Walk up from cwd to find weeve.yaml
+      let dir = process.cwd();
+      let found = null;
+      for (let i = 0; i < 4; i++) {
+        const candidate = path.join(dir, "weeve.yaml");
+        if (fs.existsSync(candidate)) {
+          found = candidate;
+          break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+
+      if (!found) {
+        console.log("\nNo weeve.yaml found in this directory or its parents.");
+        console.log("Run 'weeve init [preset]' to create one.\n");
+        break;
+      }
+
+      const raw = fs.readFileSync(found, "utf8");
+      console.log(`\nProject config: ${found}\n`);
+
+      // Parse and display key fields
+      const nameMatch = raw.match(/^\s{2}name:\s*(.+)$/m);
+      const tagMatch = raw.match(/^\s{2}tag:\s*(.+)$/m);
+      const docsMatch = raw.match(/^\s{2}docs_root:\s*(.+)$/m);
+      const schemaMatch = raw.match(/^schema_version:\s*(.+)$/m);
+
+      const name = nameMatch ? nameMatch[1].trim() : "(not set)";
+      const tag = tagMatch ? tagMatch[1].trim() : "(not set)";
+      const docsRoot = docsMatch ? docsMatch[1].trim() : `<vault>/Projects/${tag}/docs (via Claudette)`;
+      const schema = schemaMatch ? schemaMatch[1].trim() : "(not set)";
+
+      const maxLabel = 14;
+      console.log(`  ${"name".padEnd(maxLabel)}${name}`);
+      console.log(`  ${"tag".padEnd(maxLabel)}${tag}`);
+      console.log(`  ${"docs_root".padEnd(maxLabel)}${docsRoot}`);
+      console.log(`  ${"schema_version".padEnd(maxLabel)}${schema}`);
+
+      // Check for repos
+      const reposBlock = raw.match(/^\s{2}repos:\n((?:\s{4}.+\n?)*)/m);
+      if (reposBlock) {
+        console.log(`  ${"repos".padEnd(maxLabel)}${reposBlock[1].trim().split("\n").length} registered`);
+      }
+
+      // Check for depends_on
+      const depsBlock = raw.match(/^\s{2}depends_on:\n((?:\s{4}.+\n?)*)/m);
+      if (depsBlock) {
+        const depTags = [...depsBlock[1].matchAll(/tag:\s*(\S+)/g)].map((m) => m[1]);
+        const depNames = [...depsBlock[1].matchAll(/name:\s*(.+)/g)].map((m) => m[1].trim());
+        const depList = depTags.map((tag, i) => depNames[i] ? `${depNames[i]} (${tag})` : tag).join(", ");
+        console.log(`  ${"depends_on".padEnd(maxLabel)}${depList}`);
+      }
+
+      // Check for shared docs
+      const sharedDir = path.join(path.dirname(found), "docs", "shared");
+      if (fs.existsSync(sharedDir)) {
+        const sharedFiles = fs.readdirSync(sharedDir).filter((f) => f.endsWith(".md"));
+        console.log(`  ${"shared/".padEnd(maxLabel)}${sharedFiles.join(", ")}`);
+      }
+
+      console.log();
+      break;
+    }
+
+    console.error(`Unknown project subcommand: ${subcmd}`);
+    console.error("Usage: weeve project show");
+    process.exit(1);
+  }
+
   case "list":
   case "lanes": {
     console.log("\nAvailable lanes:\n");
@@ -127,11 +567,17 @@ switch (cmd) {
  ╚███╔███╔╝███████╗███████╗ ╚████╔╝ ███████╗
   ╚══╝╚══╝ ╚══════╝╚══════╝  ╚═══╝  ╚══════╝
 
- Cross-functional alignment system
+ Cross-functional contract framework
 
 Commands:
   weeve add <lane> [lane2...]   Install one or more lanes
   weeve add <preset>            Install a preset group of lanes
+  weeve remove <lane> [lane2…]  Remove one or more lanes
+  weeve remove <preset>         Remove a preset group of lanes
+  weeve init [preset]           Scaffold weeve structure in current directory
+  weeve demo [preset]           Copy a pre-built demo project to current directory
+  weeve project show            Show current project config (weeve.yaml)
+  weeve status                  Show installed lanes and skill counts
   weeve list                    Show all available lanes
   weeve presets                 Show preset groups
 
@@ -139,6 +585,10 @@ Examples:
   weeve add compass ally pilot  Install three lanes
   weeve add core                Install core preset (compass, layers-plus, ally, rubric, pilot)
   weeve add all                 Install everything
+  weeve init core               Scaffold folder structure for the core preset
+  weeve demo core               Copy the Prism demo project (ready to run immediately)
+  weeve status                  See which lanes are installed
+  weeve remove ally             Remove a single lane
 
 Presets:
   all          Every lane

package/examples/core/CODEOWNERS.template

@@ -0,0 +1,9 @@
+# Weeve lane ownership
+# Copy to .github/CODEOWNERS and replace team handles with your org's teams
+# Requires GitHub branch protection with "Require review from Code Owners" enabled
+
+weeve/compass/       @leadership
+weeve/layers-plus/   @product
+weeve/ally/          @design
+weeve/rubric/        @design
+weeve/pilot/         @leadership