@shawaze/agentspace 0.3.0

package/dist/cli.js

@@ -0,0 +1,1083 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { pathToFileURL } from "url";
+
+// src/shape.ts
+var CONTRACT_SHAPES = /* @__PURE__ */ new Set([
+  "one-product",
+  "peer-services",
+  "library-consumers"
+]);
+var ORDERED_SHAPES = /* @__PURE__ */ new Set([
+  "one-product",
+  "library-consumers"
+]);
+function shapeHasContracts(shape) {
+  return CONTRACT_SHAPES.has(shape);
+}
+function shapeHasDependencyOrder(shape) {
+  return ORDERED_SHAPES.has(shape);
+}
+function isContractLinked(config) {
+  return shapeHasContracts(config.shape) && config.repos.length >= 2;
+}
+
+// src/templates/memoryBank.ts
+var WIKI_FOLDERS = [
+  "00-core",
+  "01-active",
+  "02-architecture",
+  "03-patterns",
+  "04-business",
+  "05-sessions",
+  "06-learnings",
+  "07-reference",
+  "08-history",
+  "09-research",
+  "10-archive"
+];
+var WIKI_README = `# Memory Bank \u2014 {{workspaceName}} Wiki
+
+An LLM-curated knowledge base (Karpathy LLM Wiki pattern): entity/concept pages,
+an \`index.md\` catalog, an append-only \`log.md\`, and operations (ingest / query / lint).
+
+## Scope
+{{#isOneProduct}}**Cross-app / product-level only.** Per-repo architecture stays in each
+sub-repo's own CLAUDE.md \u2014 do not duplicate it here (duplication drifts).
+{{/isOneProduct}}{{^isOneProduct}}Cross-repo knowledge that spans more than one repository.
+Per-repo detail stays in each sub-repo's own CLAUDE.md.
+{{/isOneProduct}}
+
+## Folders (lower number = higher reading priority)
+| Dir | Holds |
+|---|---|
+| 00-core/ | Foundational, slow-changing |
+| 01-active/ | Current focus, status, next steps |
+| 04-business/ | Domain/feature pages |
+| 06-learnings/ | Lessons, postmortems |
+| 10-archive/ | Superseded material (archive, don't delete) |
+
+## Page conventions
+- Scannable, not exhaustive. Bullets/tables. Reference \`file:line\`, don't duplicate code.
+- Every entity page ends with \`_Last verified: YYYY-MM-DD_\`.
+- Every factual claim about code cites \`file:line\`. Without citations, drift is invisible.
+
+## Size budgets
+\`agentspace doctor\` enforces these mechanically (single source of truth):
+| File / pattern | Hard cap (lines) |
+|---|---|
+| log.md | 500 |
+| 00-core/*.md | 800 |
+| 01-active/currentWork.md | 150 |
+| 04-business/*.md | 800 |
+`;
+var WIKI_INDEX = `# Index
+
+Catalog of wiki pages by category. Updated on every \`/ingest\`.
+
+_(empty \u2014 add pages as you ingest)_
+`;
+var WIKI_LOG = `# Log
+
+Append-only activity journal. One line per action: \`## [YYYY-MM-DD] <action> | <slug>\`.
+`;
+var PROJECT_OVERVIEW = `# Project Overview \u2014 {{workspaceName}}
+
+{{#isOneProduct}}One product across {{repoCount}} repositories.{{/isOneProduct}}{{^isOneProduct}}{{repoCount}} repositories coordinated in one workspace.{{/isOneProduct}}
+
+## Repos
+{{#repos}}- \`{{name}}/\` \u2014 {{role}} ({{stack}})
+{{/repos}}
+
+---
+_Last verified: {{today}}_
+`;
+var CROSS_APP_CONTRACTS = `# Cross-App Contracts \u2014 {{workspaceName}}
+
+> No contracts recorded yet. Populate this after your first cross-repo change.
+> Every entry must cite \`file:line\` and end the page with a verified date footer.
+{{#hasContracts}}> Cite the matching \`openspec/specs/<capability>/spec.md\` for each contract recorded here.
+{{/hasContracts}}
+
+{{#dependencyOrder.length}}**Dependency order:** {{#dependencyOrder}}{{.}} \u2192 {{/dependencyOrder}}(done)
+{{/dependencyOrder.length}}
+`;
+
+// src/context/build.ts
+function buildContext(config, today) {
+  const pillars = config.pillars;
+  const contractLinked = isContractLinked(config);
+  const hasContracts = pillars.includes("contracts") && contractLinked;
+  return {
+    config,
+    manifest: {
+      workspaceName: config.workspaceName,
+      shape: config.shape,
+      repos: config.repos,
+      contractLinked,
+      enforcement: config.enforcement,
+      hasContracts
+    },
+    wiki: {
+      workspaceName: config.workspaceName,
+      shape: config.shape,
+      isOneProduct: config.shape === "one-product",
+      contractLinked,
+      repos: config.repos,
+      dependencyOrder: config.dependencyOrder,
+      today,
+      hasContracts
+    },
+    enforcement: config.enforcement ? {
+      workspaceName: config.workspaceName,
+      shape: config.shape,
+      contractLinked,
+      repos: config.repos,
+      config: { ...config.enforcement },
+      folders: WIKI_FOLDERS
+    } : null,
+    contracts: pillars.includes("contracts") ? {
+      workspaceName: config.workspaceName,
+      shape: config.shape,
+      contractLinked,
+      repos: config.repos,
+      dependencyOrder: config.dependencyOrder,
+      hasWiki: pillars.includes("wiki")
+    } : null
+  };
+}
+
+// src/renderer/render.ts
+import Mustache from "mustache";
+Mustache.escape = (text2) => text2;
+function render(template, view) {
+  return Mustache.render(template, view);
+}
+
+// src/templates/manifest.ts
+var MANIFEST_YAML = `# {{workspaceName}} \u2014 workspace manifest (source of truth for sub-repos)
+workspace: {{workspaceName}}
+shape: {{shape}}
+repos:
+{{#repos}}  - name: {{name}}
+    remote: {{remote}}
+    stack: {{stack}}
+    role: {{role}}
+{{/repos}}{{#enforcement}}enforcement:
+  mode: {{enforcement.mode}}
+  warmPages: {{enforcement.warmPages}}
+  warmSessions: {{enforcement.warmSessions}}
+{{/enforcement}}`;
+var CLONE_REPOS_SH = `#!/usr/bin/env bash
+set -euo pipefail
+# Reconstructs the workspace from the inlined repo list below.
+# Skips repos that already exist (idempotent) and local-only repos (no remote).
+
+# Format per line: "<name>\\t<remote>"  (empty remote = local-only)
+REPOS=(
+{{#repos}}  "{{name}}	{{remoteOrEmpty}}"
+{{/repos}})
+
+for entry in "\${REPOS[@]}"; do
+  name="\${entry%%	*}"
+  remote="\${entry#*	}"
+  if [[ -d "$name" ]]; then
+    echo "skip   $name (already present)"
+  elif [[ -z "$remote" ]]; then
+    echo "skip   $name (local-only, no remote)"
+  else
+    echo "clone  $name"
+    if ! git clone "$remote" "$name"; then
+      echo "FAILED $name (continuing)"
+    fi
+  fi
+done
+`;
+var GITIGNORE = `# Sub-repos are independent git repositories, not tracked here.
+{{#repos}}{{name}}/
+{{/repos}}{{#enforcement}}.agentspace/state.json
+{{/enforcement}}# Machine-local Claude Code settings.
+**/.claude/settings.local.json
+.DS_Store
+`;
+var ROOT_CLAUDE = `# CLAUDE.md \u2014 {{workspaceName}}
+
+This is an agentspace workspace: a coordination layer above {{repoCount}} sibling repos.
+Work inside the relevant sub-repo; read that repo's own CLAUDE.md for stack details.
+
+## Repos
+{{#repos}}- \`{{name}}/\` \u2014 {{role}} ({{stack}})
+{{/repos}}
+
+## Source of truth
+- \`manifest.yaml\` \u2014 canonical repo list. Run \`./clone-repos.sh\` to reconstruct.
+- \`memory-bank/\` \u2014 cross-repo knowledge wiki (read \`memory-bank/README.md\`).
+{{#parallelAgents}}
+## Parallel agents
+
+For features spanning repos, work in dependency order. One git worktree per
+repo; dispatch that repo's \`<repo>-engineer\` agent in each; finish with the
+\`cross-app-reviewer\` on the combined diff. Two parallel agents is comfortable;
+cap around 3\u20135 before human review becomes the bottleneck.
+{{/parallelAgents}}{{#hasContracts}}
+
+## Cross-repo contracts
+
+Before changing any API or shared shape across repos, read \`openspec/project.md\`
+and propose the change there (\`/opsx:propose\`).
+{{/hasContracts}}`;
+var ROOT_README = `# {{workspaceName}}
+
+Coordination workspace for {{repoCount}} sibling repositories, scaffolded by agentspace.
+
+## Repositories
+| Dir | Role | Stack |
+|---|---|---|
+{{#repos}}| \`{{name}}/\` | {{role}} | {{stack}} |
+{{/repos}}
+
+## Getting started
+\`\`\`bash
+./clone-repos.sh   # clone any missing sub-repos (idempotent)
+\`\`\`
+
+Sub-repos are independent git repositories and are git-ignored by this workspace.
+`;
+
+// src/generators/manifest.ts
+function generateManifest(ctx) {
+  const repos = ctx.repos.map((r) => ({
+    ...r,
+    remote: r.remote ?? "",
+    remoteOrEmpty: r.remote ?? ""
+  }));
+  const view = {
+    workspaceName: ctx.workspaceName,
+    shape: ctx.shape,
+    repoCount: ctx.repos.length,
+    repos,
+    enforcement: ctx.enforcement,
+    // mustache section: truthy object renders the block
+    parallelAgents: ctx.contractLinked && ctx.repos.length > 1,
+    hasContracts: ctx.hasContracts
+  };
+  return [
+    { path: "manifest.yaml", contents: render(MANIFEST_YAML, view) },
+    { path: "clone-repos.sh", contents: render(CLONE_REPOS_SH, view) },
+    { path: ".gitignore", contents: render(GITIGNORE, view) },
+    { path: "CLAUDE.md", contents: render(ROOT_CLAUDE, view) },
+    { path: "README.md", contents: render(ROOT_README, view) }
+  ];
+}
+
+// src/generators/memoryBank.ts
+function generateMemoryBank(ctx) {
+  const view = {
+    workspaceName: ctx.workspaceName,
+    isOneProduct: ctx.isOneProduct,
+    repoCount: ctx.repos.length,
+    repos: ctx.repos,
+    dependencyOrder: ctx.dependencyOrder ?? [],
+    today: ctx.today,
+    hasContracts: ctx.hasContracts
+  };
+  const files = [];
+  for (const folder of WIKI_FOLDERS) {
+    files.push({ path: `memory-bank/${folder}/.gitkeep`, contents: "" });
+  }
+  files.push(
+    { path: "memory-bank/README.md", contents: render(WIKI_README, view) },
+    { path: "memory-bank/index.md", contents: render(WIKI_INDEX, view) },
+    { path: "memory-bank/log.md", contents: render(WIKI_LOG, view) },
+    {
+      path: "memory-bank/00-core/projectOverview.md",
+      contents: render(PROJECT_OVERVIEW, view)
+    }
+  );
+  if (ctx.contractLinked) {
+    files.push({
+      path: "memory-bank/00-core/crossAppContracts.md",
+      contents: render(CROSS_APP_CONTRACTS, view)
+    });
+  }
+  return files;
+}
+
+// src/templates/commands.ts
+var INGEST = `---
+description: Ingest a source into the {{workspaceName}} memory-bank (LLM Wiki pattern)
+---
+
+You are operating in **INGEST mode** for the {{workspaceName}} memory-bank.
+
+Source to ingest: $ARGUMENTS
+
+## No-ingest gate (apply first)
+Skip the ingest and tell the user if any are true:
+- The content is derivable from \`git log\` / \`grep\` / reading code directly.
+- You can't name **two future questions** the page would answer.
+- It's one-off setup chatter, not durable cross-repo knowledge.
+
+## Steps
+1. **Read the source** (file, URL, or pasted content).
+2. **Discuss takeaways** briefly (3\u20135 bullets) so the user can correct course.
+3. **Classify and pick a folder** under \`memory-bank/\`:
+{{#folders}}   - \`{{.}}/\`
+{{/folders}}
+4. **Write a concise page** \u2014 bullets, tables, citations. \u2264 150 lines.
+5. **Cite \`file:line\`** for every factual claim about the codebase.
+6. **Last-verified footer:** end with \`_Last verified: YYYY-MM-DD_\`.
+7. **Cross-link** related pages with \`[[slug]]\`.
+8. **Update \`memory-bank/index.md\`** \u2014 add an entry under the right category.
+9. **Append to \`memory-bank/log.md\`:** \`## [YYYY-MM-DD] ingest | <slug>\`
+10. **Report what changed.**
+
+## Rules
+Reference, don't duplicate \u2014 point at \`file:line\` rather than copying code.
+Scannable beats comprehensive.
+`;
+var QUERY = `---
+description: Query the {{workspaceName}} memory-bank; file useful answers back
+---
+
+You are operating in **QUERY mode** for the {{workspaceName}} memory-bank.
+
+Question: $ARGUMENTS
+
+## Steps
+1. **Read \`memory-bank/index.md\`** first \u2014 see what pages exist.
+2. **Read relevant pages** \u2014 \`00-core/\` first for constraints, then concept
+   pages. Walk \`[[cross-links]]\` as needed.
+3. **Classify the question:**
+   - **Behavioral** (what the code does / returns) \u2192 wiki is a hint; **verify the
+     cited \`file:line\` against the code** before answering.
+   - **Decision / history** (why we chose Y) \u2192 wiki answer stands.
+4. **Synthesize with citations** \u2014 link pages with \`[[slug]]\`, cite repo
+   evidence as \`file:line\`.
+5. **If a page's \`Last verified\` is > 30 days old** and you used it for a
+   behavioral answer, call it out.
+6. **If the wiki lacks the answer**, search the repos, then ask:
+   _"Found in \`<source>\`. Worth filing in \`memory-bank/<folder>/<slug>.md\`? (y/n)"_
+7. **Append to \`memory-bank/log.md\`:** \`## [YYYY-MM-DD] query | <topic>\`
+
+## Rules
+Wiki is a hint, code is truth for behavioral claims. Always cite. Never fabricate.
+`;
+var LINT = `---
+description: Lint the {{workspaceName}} memory-bank for staleness, drift, and scope violations
+---
+
+You are operating in **LINT mode** for the {{workspaceName}} memory-bank.
+
+## Step 1 \u2014 mechanical checks (run the tool)
+Run \`agentspace doctor --lint\` and read its JSON findings. These cover size
+budgets, \`_Last verified:_\` staleness, and orphan/citation-path checks \u2014 the
+single source of truth for mechanical rules. Do not re-derive them by hand.
+
+## Step 2 \u2014 judgment checks (only the LLM can do these)
+Sweep the wiki for:
+1. **Broken citations** \u2014 a \`file:line\` whose line no longer matches the claim
+   (spot-check \u22653 per page).
+2. **Contradictions** \u2014 two pages making incompatible claims.
+3. **Stale state** \u2014 "in progress" work that's shipped; SHAs that don't exist.
+4. **Out-of-scope content** \u2014 per-repo detail that belongs in a repo's CLAUDE.md.
+5. **Broken cross-links** \u2014 \`[[slug]]\` pointing at non-existent pages.
+
+## Report
+Output a table: \`Severity | File | Issue | Suggested fix\`. Merge the tool's
+mechanical findings with your judgment findings. **Do NOT fix automatically** \u2014
+ask the user which to act on. Then append to \`memory-bank/log.md\`:
+\`## [YYYY-MM-DD] lint | <H high \xB7 M med \xB7 L low \u2014 short summary>\`
+`;
+
+// src/stackAgents/loader.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join2 } from "path";
+import { parse } from "yaml";
+
+// src/paths.ts
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("agentspace: could not locate package root from " + import.meta.url);
+}
+function packageDir(name) {
+  return join(packageRoot(), name);
+}
+
+// src/stackAgents/loader.ts
+function stacksDir() {
+  return packageDir("stack-agents");
+}
+var cached = null;
+function registry() {
+  if (!cached) {
+    cached = parse(readFileSync(join2(stacksDir(), "stacks.yaml"), "utf8"));
+  }
+  return cached;
+}
+function engineerToolList() {
+  return registry().engineerTools;
+}
+function resolveStackId(input) {
+  const norm = input.trim().toLowerCase();
+  if (norm === "" || norm === "generic" || norm === "_generic") return "_generic";
+  for (const s of registry().stacks) {
+    if (s.id === norm || s.aliases.includes(norm)) return s.id;
+  }
+  return "_generic";
+}
+function loadStackBody(input) {
+  const id = resolveStackId(input);
+  const file = join2(stacksDir(), `${id}.md`);
+  if (existsSync2(file)) return readFileSync(file, "utf8");
+  console.warn(`agentspace: stack file ${id}.md missing; using _generic`);
+  return readFileSync(join2(stacksDir(), "_generic.md"), "utf8");
+}
+
+// src/generators/enforcement.ts
+var REVIEWER_TOOLS = ["Read", "Grep", "Glob", "Bash"];
+function generateEnforcementIntents(ctx) {
+  const agents = ctx.repos.map((repo) => ({
+    name: `${repo.name}-engineer`,
+    repoDir: repo.name,
+    role: repo.role,
+    stack: resolveStackId(repo.stack),
+    boundaryRule: `You only edit files inside \`${repo.name}/\`. Never touch another repo or \`memory-bank/\` (except read-only).`,
+    toolList: engineerToolList(),
+    isReviewer: false
+  }));
+  if (ctx.contractLinked) {
+    agents.push({
+      name: "cross-app-reviewer",
+      repoDir: "",
+      role: "read-only cross-repo reviewer",
+      stack: "generic",
+      boundaryRule: "Read-only. You never edit any file.",
+      toolList: REVIEWER_TOOLS,
+      isReviewer: true
+    });
+  }
+  const view = { workspaceName: ctx.workspaceName, folders: ctx.folders };
+  const commands = [
+    { name: "ingest", body: render(INGEST, view) },
+    { name: "query", body: render(QUERY, view) },
+    { name: "lint", body: render(LINT, view) }
+  ];
+  const hook = ctx.contractLinked ? {
+    enabled: true,
+    mode: ctx.config.mode,
+    warmPages: ctx.config.warmPages,
+    warmSessions: ctx.config.warmSessions,
+    subRepos: ctx.repos.map((r) => r.name)
+  } : null;
+  return { agents, commands, hook };
+}
+
+// src/templates/contracts.ts
+var PROJECT_MD = `# Project Context \u2014 {{workspaceName}} (cross-repo contracts)
+
+> **Scope:** this OpenSpec instance covers **cross-repo contracts only** \u2014 things
+> consumed by more than one repo in this workspace. Per-repo internals do not
+> belong here; they stay in that repo.
+
+## Repos
+| Repo | Role |
+|---|---|
+{{#repos}}| \`{{name}}/\` | {{role}} |
+{{/repos}}
+## What belongs in \`specs/\`
+A capability lives here only if it's a contract **between** repos:
+- HTTP endpoints consumed by another repo
+- Shared data shapes / payloads
+- Auth flows
+- Webhook payloads that cross repos
+- Cross-repo events
+
+It does **not** belong here if it only describes the inside of one repo.
+
+## What belongs in \`changes/\`
+Any proposal that mutates a cross-repo contract, before implementation (adding a
+field consumers read, changing an auth response, deprecating an endpoint).
+{{#hasOrder}}Each change names the affected repos and orders tasks in
+**dependency order: {{#order}}{{.}} \u2192 {{/order}}done**. The producer defines the
+contract; consumers follow.{{/hasOrder}}{{^hasOrder}}These repos are **peers** with
+no global dependency order \u2014 each change names the affected repos and the contract
+between them.{{/hasOrder}}
+
+## Working with this instance
+The \`/opsx:*\` slash commands are installed by the external **\`openspec\` CLI** \u2014
+run \`openspec update\` in this workspace to install them. CLI: \`openspec list\`,
+\`openspec validate\`, \`openspec show <name>\`, \`openspec view\`.
+
+| Command | Purpose |
+|---|---|
+| \`/opsx:propose <idea>\` | Scaffold \`changes/<name>/{proposal,design,tasks}.md\` |
+| \`/opsx:apply <name>\` | Implement a change task-by-task |
+| \`/opsx:archive <name>\` | Fold a shipped change into \`specs/\` (archive on deploy) |
+
+## Relationship to the memory bank
+OpenSpec holds *what the contract is* (specs) and *what's changing* (proposals).
+\`memory-bank/\` holds *why* (decisions, history).{{#hasWiki}} The wiki's
+\`00-core/crossAppContracts.md\` should cite the matching
+\`openspec/specs/<capability>/spec.md\`.{{/hasWiki}}
+`;
+var OPENSPEC_README = `# openspec/ \u2014 {{workspaceName}} cross-repo contracts
+
+Prescriptive contract layer for this workspace. Read \`project.md\` for scope and
+lifecycle.
+
+- \`specs/\` \u2014 current cross-repo capabilities (the truth).
+- \`changes/\` \u2014 proposals in flight; \`changes/archive/\` \u2014 shipped.
+
+The \`/opsx:*\` commands and validation come from the external **\`openspec\` CLI**.
+Run \`openspec update\` to install the slash commands; \`openspec validate\` to check.
+`;
+
+// src/generators/contracts.ts
+function generateContracts(ctx) {
+  if (!ctx.contractLinked) return [];
+  const view = {
+    workspaceName: ctx.workspaceName,
+    repos: ctx.repos,
+    hasOrder: ctx.dependencyOrder !== null && ctx.dependencyOrder.length > 0,
+    order: ctx.dependencyOrder ?? [],
+    hasWiki: ctx.hasWiki
+  };
+  return [
+    { path: "openspec/project.md", contents: render(PROJECT_MD, view) },
+    { path: "openspec/README.md", contents: render(OPENSPEC_README, view) },
+    { path: "openspec/specs/.gitkeep", contents: "" },
+    { path: "openspec/changes/.gitkeep", contents: "" },
+    { path: "openspec/changes/archive/.gitkeep", contents: "" }
+  ];
+}
+
+// src/adapters/claudeCode.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/templates/agents.ts
+var REVIEWER_AGENT = `---
+name: cross-app-reviewer
+description: Read-only reviewer that catches cross-repo breakage in {{workspaceName}}. Use when a change touches an API, shared data shape, or auth flow across repos.
+tools: Read, Grep, Glob, Bash
+---
+
+You are the **Cross-app reviewer** for the {{workspaceName}} workspace.
+
+## Scope (hard boundary)
+**Read-only.** You never edit any file. If the user asks for a fix, report
+findings and stop \u2014 the relevant repo's engineer applies the change.
+
+## What you do
+For a given change (diff, PR, or spec), check whether it breaks any contract
+between the repos:
+1. **Read \`memory-bank/00-core/crossAppContracts.md\` first** \u2014 that's your map.
+2. **Identify what the change touches** \u2014 API routes, shared payload shapes,
+   auth flow, client API code.
+3. **For each touched contract:** is the wiki entry still accurate (cite wiki
+   \`file:line\` and code \`file:line\`)? Does any consumer break (grep across
+   client repos)? Is the change additive (safe) or breaking?
+4. **Report** a table: \`severity \xB7 what changed \xB7 who breaks \xB7 suggested fix\`.
+
+## Severity
+- **CRITICAL** \u2014 breaks a current consumer or the auth contract.
+- **HIGH** \u2014 a likely break or an undocumented contract change.
+- **MEDIUM/LOW** \u2014 additive change; doc drift.
+`;
+
+// src/adapters/claudeCode.ts
+var HOOK_ASSET = "memory-bank-stop.cjs";
+function renderAgent(agent, workspaceName) {
+  if (agent.isReviewer) {
+    return render(REVIEWER_AGENT, { workspaceName });
+  }
+  const body = loadStackBody(agent.stack);
+  return render(body, {
+    repoName: agent.repoDir,
+    repoDir: agent.repoDir,
+    role: agent.role,
+    boundaryRule: agent.boundaryRule
+  });
+}
+function claudeCodeAdapter(intents, ctx) {
+  const files = [];
+  for (const agent of intents.agents) {
+    files.push({
+      path: `.claude/agents/${agent.name}.md`,
+      contents: renderAgent(agent, ctx.workspaceName)
+    });
+  }
+  for (const cmd of intents.commands) {
+    files.push({ path: `.claude/commands/${cmd.name}.md`, contents: cmd.body });
+  }
+  if (intents.hook) {
+    const hookSource = readFileSync2(join3(packageDir("assets"), HOOK_ASSET), "utf8");
+    files.push({ path: `.claude/hooks/${HOOK_ASSET}`, contents: hookSource });
+    files.push({
+      path: ".claude/agentspace-hook.json",
+      contents: JSON.stringify(
+        {
+          mode: intents.hook.mode,
+          warmPages: intents.hook.warmPages,
+          warmSessions: intents.hook.warmSessions,
+          subRepos: intents.hook.subRepos
+        },
+        null,
+        2
+      ) + "\n"
+    });
+    files.push({
+      path: ".claude/settings.json",
+      contents: JSON.stringify(
+        {
+          hooks: {
+            Stop: [
+              {
+                matcher: "*",
+                hooks: [
+                  {
+                    type: "command",
+                    command: `node "$CLAUDE_PROJECT_DIR/.claude/hooks/${HOOK_ASSET}"`,
+                    timeout: 10,
+                    statusMessage: "Checking memory bank..."
+                  }
+                ]
+              }
+            ]
+          }
+        },
+        null,
+        2
+      ) + "\n"
+    });
+  }
+  return files;
+}
+
+// src/fs/writeTree.ts
+import {
+  cp,
+  mkdir,
+  mkdtemp,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+async function isNonEmptyDir(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function writeTree(files, targetDir, opts) {
+  if (!opts.force && await isNonEmptyDir(targetDir)) {
+    throw new Error(
+      `Target directory is not empty: ${targetDir}. Re-run with --force to write anyway.`
+    );
+  }
+  const parent = dirname2(targetDir);
+  await mkdir(parent, { recursive: true });
+  const temp = await mkdtemp(join4(parent, ".agentspace-tmp-"));
+  try {
+    for (const file of files) {
+      const dest = join4(temp, file.path);
+      await mkdir(dirname2(dest), { recursive: true });
+      await writeFile(dest, file.contents);
+    }
+    if (opts.force) {
+      await cp(temp, targetDir, { recursive: true, force: true });
+      await rm(temp, { recursive: true, force: true });
+    } else if (await isNonEmptyDir(targetDir)) {
+      await cp(temp, targetDir, { recursive: true, force: true });
+      await rm(temp, { recursive: true, force: true });
+    } else {
+      await rm(targetDir, { recursive: true, force: true }).catch(() => {
+      });
+      await rename(temp, targetDir);
+    }
+  } catch (err) {
+    await rm(temp, { recursive: true, force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+
+// src/wizard/run.ts
+import * as p from "@clack/prompts";
+
+// src/types.ts
+var DEFAULT_ENFORCEMENT = {
+  mode: "auto",
+  warmPages: 5,
+  warmSessions: 10
+};
+
+// src/wizard/assemble.ts
+function assembleConfig(answers) {
+  const pillars = ["manifest"];
+  if (answers.enableWiki) pillars.push("wiki");
+  if (answers.enableEnforcement) pillars.push("enforcement");
+  if (answers.enableContracts) pillars.push("contracts");
+  return {
+    workspaceName: answers.workspaceName.trim(),
+    shape: answers.shape,
+    repos: answers.repos.map((r) => ({
+      name: r.name.trim(),
+      remote: r.remote.trim() === "" ? null : r.remote.trim(),
+      stack: r.stack,
+      role: r.role.trim()
+    })),
+    dependencyOrder: shapeHasDependencyOrder(answers.shape) ? answers.dependencyOrder : null,
+    pillars,
+    enforcement: answers.enableEnforcement ? { ...DEFAULT_ENFORCEMENT } : null
+  };
+}
+
+// src/wizard/validate.ts
+var FS_SAFE = /^[A-Za-z0-9._-]+$/;
+function validateWorkspaceName(name) {
+  if (!name.trim()) return "Workspace name is required.";
+  return null;
+}
+function validateRepoName(name) {
+  if (!name.trim()) return "Repo name is required.";
+  if (!FS_SAFE.test(name)) {
+    return "Use only letters, numbers, dots, dashes, underscores.";
+  }
+  return null;
+}
+function validateRemote(remote) {
+  if (remote.trim() === "") return null;
+  const ok = /^git@[^:]+:.+\.git$/.test(remote) || /^https?:\/\/.+/.test(remote) || /^ssh:\/\/.+/.test(remote);
+  return ok ? null : "Enter a valid git remote URL, or leave blank for local-only.";
+}
+function validateUniqueNames(names) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const n of names) {
+    if (seen.has(n)) return `Duplicate repo name: ${n}`;
+    seen.add(n);
+  }
+  return null;
+}
+
+// src/wizard/run.ts
+function cancel2(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(1);
+  }
+}
+async function runWizard() {
+  p.intro("agentspace init");
+  const workspaceName = await p.text({
+    message: "Workspace name",
+    validate: (v) => validateWorkspaceName(v) ?? void 0
+  });
+  cancel2(workspaceName);
+  const shape = await p.select({
+    message: "Workspace shape",
+    options: [
+      { value: "single-repo", label: "Single repo" },
+      { value: "one-product", label: "Multi-repo, one product (backend + clients)" },
+      { value: "peer-services", label: "Multi-repo, peer services (no global order)" },
+      { value: "library-consumers", label: "Multi-repo, library + consumers" },
+      { value: "unrelated", label: "Multi-repo, unrelated" }
+    ]
+  });
+  cancel2(shape);
+  const repos = [];
+  let addMore = true;
+  while (addMore) {
+    let name;
+    while (true) {
+      const nameInput = await p.text({
+        message: `Repo #${repos.length + 1} directory name`,
+        validate: (v) => validateRepoName(v) ?? void 0
+      });
+      cancel2(nameInput);
+      const dupError = validateUniqueNames([...repos.map((r) => r.name), nameInput.trim()]);
+      if (dupError) {
+        p.log.error(dupError);
+        continue;
+      }
+      name = nameInput;
+      break;
+    }
+    const remote = await p.text({
+      message: "Git remote URL (blank = local-only)",
+      validate: (v) => validateRemote(v) ?? void 0
+    });
+    cancel2(remote);
+    const stack = await p.text({ message: "Stack id (or 'generic')", placeholder: "generic" });
+    cancel2(stack);
+    const role = await p.text({ message: "Role (one line)" });
+    cancel2(role);
+    repos.push({ name, remote, stack: stack || "generic", role });
+    if (shape === "single-repo") break;
+    const more = await p.confirm({ message: "Add another repo?" });
+    cancel2(more);
+    addMore = more === true;
+  }
+  let dependencyOrder = [];
+  if (shapeHasDependencyOrder(shape) && repos.length > 1) {
+    p.note(
+      "Dependency order: which repo defines contracts the others consume (producer first)."
+    );
+    const remaining = repos.map((r) => r.name);
+    while (dependencyOrder.length < remaining.length) {
+      const pick = await p.select({
+        message: `Position ${dependencyOrder.length + 1}`,
+        options: remaining.filter((n) => !dependencyOrder.includes(n)).map((n) => ({ value: n, label: n }))
+      });
+      cancel2(pick);
+      dependencyOrder.push(pick);
+    }
+  }
+  const enableWiki = await p.confirm({ message: "Include the memory-bank wiki?", initialValue: true });
+  cancel2(enableWiki);
+  const enableEnforcement = await p.confirm({
+    message: "Include the Claude Code enforcement pack (agents, Stop hook, commands)?",
+    initialValue: false
+  });
+  cancel2(enableEnforcement);
+  const enableContracts = await p.confirm({
+    message: "Include the cross-repo contract layer (OpenSpec)?",
+    initialValue: false
+  });
+  cancel2(enableContracts);
+  p.outro("Generating workspace\u2026");
+  return assembleConfig({
+    workspaceName,
+    shape,
+    repos,
+    dependencyOrder,
+    enableWiki: enableWiki === true,
+    enableEnforcement: enableEnforcement === true,
+    enableContracts: enableContracts === true
+  });
+}
+
+// src/commands/init.ts
+function generateWorkspace(config, today) {
+  const ctx = buildContext(config, today);
+  const files = [];
+  files.push(...generateManifest(ctx.manifest));
+  if (config.pillars.includes("wiki")) {
+    files.push(...generateMemoryBank(ctx.wiki));
+  }
+  if (config.pillars.includes("enforcement") && ctx.enforcement) {
+    const intents = generateEnforcementIntents(ctx.enforcement);
+    files.push(...claudeCodeAdapter(intents, ctx.enforcement));
+  }
+  if (config.pillars.includes("contracts") && ctx.contracts) {
+    files.push(...generateContracts(ctx.contracts));
+  }
+  return files;
+}
+async function runInit(config, targetDir, opts) {
+  const files = generateWorkspace(config, opts.today);
+  await writeTree(files, targetDir, { force: opts.force });
+}
+async function initCommand(opts) {
+  const config = await runWizard();
+  await runInit(config, process.cwd(), opts);
+  console.log(`
+\u2713 Created ${config.workspaceName} (${config.pillars.join(", ")}).`);
+  console.log("  Next: ./clone-repos.sh");
+  if (config.pillars.includes("contracts") && isContractLinked(config)) {
+    console.log(
+      "  Contracts: run `openspec update` to install the /opsx:* commands (install the openspec CLI first if needed)."
+    );
+  }
+}
+
+// src/commands/doctor.ts
+import { readFile, readdir as readdir2, stat } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join5, relative } from "path";
+import { parse as parse2 } from "yaml";
+
+// src/budgets.ts
+var SIZE_BUDGETS = [
+  { label: "log.md", cap: 500, match: (p2) => p2 === "memory-bank/log.md" },
+  {
+    label: "01-active/currentWork.md",
+    cap: 150,
+    match: (p2) => p2 === "memory-bank/01-active/currentWork.md"
+  },
+  {
+    label: "00-core/*.md",
+    cap: 800,
+    match: (p2) => /^memory-bank\/00-core\/.+\.md$/.test(p2)
+  },
+  {
+    label: "04-business/*.md",
+    cap: 800,
+    match: (p2) => /^memory-bank\/04-business\/.+\.md$/.test(p2)
+  }
+];
+var STALE_DAYS = 30;
+
+// src/openspec.ts
+import { execSync } from "child_process";
+function openspecAvailable() {
+  try {
+    execSync("command -v openspec", { stdio: "ignore", shell: "/bin/sh" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/doctor.ts
+async function walk(dir) {
+  const out = [];
+  let entries = [];
+  try {
+    entries = await readdir2(dir);
+  } catch {
+    return out;
+  }
+  for (const name of entries) {
+    const full = join5(dir, name);
+    const s = await stat(full);
+    if (s.isDirectory()) out.push(...await walk(full));
+    else out.push(full);
+  }
+  return out;
+}
+function daysBetween(fromIso, toIso) {
+  const from = new Date(fromIso).getTime();
+  const to = new Date(toIso).getTime();
+  return Math.floor((to - from) / 864e5);
+}
+async function runChecks(workspaceDir, today, deps = {}) {
+  const findings = [];
+  const isOpenspecAvailable = deps.openspecAvailable ?? openspecAvailable;
+  try {
+    const raw = await readFile(join5(workspaceDir, "manifest.yaml"), "utf8");
+    const doc = parse2(raw);
+    if (!doc || !Array.isArray(doc.repos) || doc.repos.length === 0) {
+      findings.push({ level: "error", message: "manifest.yaml has no repos." });
+    }
+  } catch {
+    findings.push({ level: "error", message: "manifest.yaml is missing or unparseable." });
+  }
+  const mbDir = join5(workspaceDir, "memory-bank");
+  const files = await walk(mbDir);
+  for (const full of files) {
+    const rel = relative(workspaceDir, full).split("\\").join("/");
+    if (!rel.endsWith(".md")) continue;
+    const contents = await readFile(full, "utf8");
+    const lineCount = contents.split("\n").length;
+    const budget = SIZE_BUDGETS.find((b) => b.match(rel));
+    if (budget && lineCount > budget.cap) {
+      findings.push({
+        level: "warn",
+        message: `${rel}: ${lineCount} lines exceeds cap of ${budget.cap} (${budget.label}). Split or archive.`
+      });
+    }
+    const match = contents.match(/_Last verified:\s*(\d{4}-\d{2}-\d{2})/);
+    if (match) {
+      const age = daysBetween(match[1], today);
+      if (age > STALE_DAYS) {
+        findings.push({
+          level: "warn",
+          message: `${rel}: stale \u2014 last verified ${age} days ago (> ${STALE_DAYS}). Re-verify.`
+        });
+      }
+    }
+  }
+  if (existsSync3(join5(workspaceDir, "openspec")) && !isOpenspecAvailable()) {
+    findings.push({
+      level: "warn",
+      message: "openspec/ is present but the `openspec` CLI was not found on PATH. Install it (https://github.com/Fission-AI/OpenSpec) and run `openspec update`."
+    });
+  }
+  return findings;
+}
+function formatLintJson(findings) {
+  return JSON.stringify({ findings });
+}
+async function doctorCommand(workspaceDir, today, opts = {}) {
+  const findings = await runChecks(workspaceDir, today);
+  if (opts.lint) {
+    console.log(formatLintJson(findings));
+  } else if (findings.length === 0) {
+    console.log("\xB7 No issues found.");
+  } else {
+    for (const f of findings) {
+      const tag = f.level === "error" ? "\u2717" : f.level === "warn" ? "!" : "\xB7";
+      console.log(`${tag} ${f.message}`);
+    }
+  }
+  return findings.some((f) => f.level === "error") ? 1 : 0;
+}
+
+// src/version.ts
+var VERSION = "0.3.0";
+
+// src/cli.ts
+function parseArgs(argv) {
+  const force = argv.includes("--force");
+  const lint = argv.includes("--lint");
+  const first = argv[0];
+  if (first === "init") return { command: "init", force, lint };
+  if (first === "doctor") return { command: "doctor", force, lint };
+  if (first === "--version" || first === "-v") return { command: "version", force, lint };
+  return { command: "help", force, lint };
+}
+var HELP = `agentspace \u2014 scaffold an agent-native multi-repo workspace
+
+Usage:
+  agentspace init [--force]   Interactively scaffold a workspace in the current dir
+  agentspace doctor           Run mechanical health checks on a workspace
+  agentspace --version        Print version
+  agentspace --help           Show this help
+`;
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+async function main(argv) {
+  const args = parseArgs(argv);
+  switch (args.command) {
+    case "init":
+      await initCommand({ force: args.force, today: todayIso() });
+      return 0;
+    case "doctor":
+      return doctorCommand(process.cwd(), todayIso(), { lint: args.lint });
+    case "version":
+      console.log(VERSION);
+      return 0;
+    case "help":
+    default:
+      console.log(HELP);
+      return 0;
+  }
+}
+var invokedDirectly = process.argv[1] !== void 0 && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedDirectly) {
+  main(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
+export {
+  main,
+  parseArgs
+};