pantheon-opencode 1.0.1 → 1.0.6

package/commands/pantheon-deepwork.md

@@ -1,128 +1,79 @@
 ---
-description: "Start a heavy multi-phase task with persisted checkpoints, phased specialist dispatch, and Themis review gates. Progress saved to .pantheon/deepwork/ for resumability. Usage: /pantheon-deepwork"
+description: "Start a heavy multi-phase task with persisted checkpoints, phased specialist dispatch, and Themis review gates. Progress saved to .pantheon/deepwork/ for resumability."
 agent: "zeus"
 ---
 # /pantheon-deepwork — Heavy Task Workflow
 
-**What:** Starts a structured, checkpointed workflow for complex multi-step tasks. Progress is persisted to `.pantheon/deepwork/<task-slug>/` so work can resume if interrupted. Each phase is gated by Themis review.
+Structured, checkpointed workflow for complex multi-step tasks spanning multiple agents and sessions. Progress persisted to `.pantheon/deepwork/<task-slug>/`. Each phase gated by Themis.
 
-## When to Use
-
-- Tasks expected to take 10+ turns
-- Multi-agent orchestration with dependencies
-- Work that spans multiple sessions
-- Anything where losing context mid-way would be costly
-
-## When NOT to Use
-
-- Simple fixes (use @talos)
-- Single-file changes (use /subtask)
-- Tasks completable in < 5 turns (use normal delegation)
+| Use When | Don't Use When |
+|---|---|
+| 10+ turns or multi-session | Simple fixes (→ @talos) |
+| Multi-agent dependencies | Single-file changes (→ /subtask) |
+| Costly context loss | < 5 turns (→ normal delegation) |
 
 ## Workflow
 
 ```
 Phase 0: SCOPING
-  └─ Zeus + Athena define task scope, phases, and acceptance criteria
-  └─ Output: .pantheon/deepwork/<slug>/PLAN.md
+  └─ Zeus + Athena define scope, phases, acceptance criteria → PLAN.md
 
 Phase 1: DISCOVERY
-  └─ @apollo maps relevant codebase areas
-  └─ Output: .pantheon/deepwork/<slug>/DISCOVERY.md
+  └─ @apollo maps relevant codebase areas → DISCOVERY.md
 
 Phase 2-N: IMPLEMENTATION (parallel per phase)
-  └─ @hermes / @aphrodite / @demeter implement phase scope
-  └─ Output: .pantheon/deepwork/<slug>/phase-<N>-<agent>.md
+  └─ @hermes, @aphrodite, @demeter, @hephaestus, @prometheus
+  └─ Output: IMPL-phase-<N>-<agent>.md
 
 GATE after each phase:
-  └─ @themis reviews phase output
-  └─ FAIL → fix and re-submit
-  └─ PASS → continue to next phase
+  └─ @themis reviews output → FAIL (fix + resubmit) or PASS (continue)
 
 Phase FINAL: VERIFICATION
-  └─ @themis full integration review
+  └─ @themis full integration review → REVIEW.md
   └─ All tests pass, coverage >80%
-  └─ Output: .pantheon/deepwork/<slug>/REVIEW.md
 ```
 
-## Checkpoint System
-
-Each phase writes a checkpoint file. If work is interrupted:
+## Checkpoints
 
 ```
-/pantheon-deepwork --resume <slug>    # Resume from last checkpoint
-/pantheon-deepwork --status <slug>    # Show current progress
-/pantheon-deepwork --list             # List all deepwork tasks
-```
-
-Checkpoint files:
+Usage:  --resume <slug> | --status <slug> | --list
 
-```
 .pantheon/deepwork/<slug>/
-├── PLAN.md                  # Scope and phase plan
-├── DISCOVERY.md             # Codebase map
-├── phase-1-hermes.md        # Phase 1 backend work
-├── phase-1-aphrodite.md     # Phase 1 frontend work
-├── phase-1-review.md        # Phase 1 Themis review
-├── phase-2-*.md             # Subsequent phases
-├── REVIEW.md                # Final Themis review
-└── STATUS.md                # Current state (phase, progress, blockers)
+├── PLAN.md  DISCOVERY.md  IMPL-phase-*-*.md  phase-*-review.md  REVIEW.md  STATUS.md
 ```
 
-## ⚡ Full-Auto Mode (`--full-auto`)
-
-> ⚠️ **WARNING:** This bypasses human review gates. Only for experienced operators. Tier 1 gates (plan, commit, deploy) still require human approval.
+## Full-Auto Mode (`--full-auto`)
 
-New in v4.0 — **Ultrawork-style execution**. When `--full-auto` is passed:
+> ⚠️ Bypasses human review gates. Tier 1 gates (plan, commit, deploy) still require approval.
 
-- **All gates auto-approve** — no waiting for Themis approval between phases
-- Only stops if Themis returns a **BLOCKING** verdict
-- Equivalent to the "ultrawork" paradigm from OMO (one-minute-optimization)
-- Checkpoints still saved at every phase boundary
-- Use for: high-confidence tasks, batch processing, experienced operators
+**Themis auto-approves non-blocking reviews** — only stops on **BLOCKING** verdict. No waiting between phases. Checkpoints saved at every boundary.
 
 ```
-/pantheon-deepwork --full-auto "Refactor auth service to use JWT"   # Full auto mode
-/pantheon-deepwork --full-auto --resume auth-jwt                     # Resume in full-auto
+/pantheon-deepwork --full-auto "Refactor auth service to use JWT"
+/pantheon-deepwork --full-auto --resume auth-jwt
 ```
 
-## Anti-Stall Integration
+## Anti-Stall
 
-Deepwork automatically applies:
-
-- **Stall Detection Protocol** — 3 turns no progress → escalate
-- **Phase Reminder** — after each dispatch, continue only independent work
+- **Stall Detection** — 3 turns no progress → escalate
+- **Phase Reminder** — continue only independent work after dispatch
 - **Progress Checkpoint** — every 5 turns, summarize completed vs remaining
-- **Delegate Retry** — delegation failures retried once with rephrased prompt
-
-If a phase stalls:
-
-1. Checkpoint current progress
-2. Report to user: "Phase [N] stalled. Progress saved. Options: (a) retry with different approach, (b) simplify scope, (c) skip phase and revisit."
+- **Delegate Retry** — failures retried once with rephrased prompt
 
 ## Usage
 
 ```
-/pantheon-deepwork "Add user authentication with OAuth2"         # Start new deepwork session
-/pantheon-deepwork --resume auth-oauth2                           # Resume interrupted session
-/pantheon-deepwork --status auth-oauth2                           # Show progress
-/pantheon-deepwork --list                                         # List all tasks
-/pantheon-deepwork --archive auth-oauth2                          # Archive completed task
-/pantheon-deepwork --full-auto "Refactor auth service"            # Full auto (ultrawork mode)
-/pantheon-deepwork --full-auto --resume auth-refactor             # Resume full-auto session
+/pantheon-deepwork "Add user authentication with OAuth2"           # Start new session
+/pantheon-deepwork --resume auth-oauth2                            # Resume interrupted
+/pantheon-deepwork --status auth-oauth2                            # Show progress
+/pantheon-deepwork --list    /pantheon-deepwork --archive <slug>    # List / archive
+/pantheon-deepwork --full-auto "Refactor auth"                     # Themis auto-approve
+/pantheon-deepwork --full-auto --resume auth-refactor              # Resume full-auto
 ```
 
 ## Safety
 
 - All progress persisted — work is never lost
 - Each phase gated by Themis — quality enforced at every step
-- Explicit resume required — won't auto-continue without user intent (unless `--full-auto`)
+- Explicit resume required — no auto-continue without intent (unless `--full-auto`)
 - `.pantheon/deepwork/` is gitignored — no accidental commits
-
----
-
-## Related: `/pantheon-praxis` (merged)
-
-`/pantheon-praxis` was merged into `/pantheon-deepwork` in v4.0. Use `/pantheon-deepwork` for all multi-phase execution.
-
-For ad-hoc single-phase execution, use normal agent delegation (`@hermes`, `@aphrodite`, etc.) directly.

package/commands/pantheon-reflect.md

@@ -0,0 +1,16 @@
+---
+description: "Reflect on workflow friction and create improvement action items"
+agent: zeus
+---
+# /pantheon-reflect — Workflow Reflection
+
+**What:** After completing a task, reflect on what could be improved. Turns repeated friction into reusable skills, agents, or config improvements.
+**Usage:** `/pantheon-reflect [session-or-task]`
+**Returns:** Structured reflection with action items
+
+## When to Use
+- After completing a complex feature
+- When you notice the same manual steps repeating
+- At end of work session
+
+Delegates to @mnemosyne with `skill: reflect`.

package/commands/pantheon-status.md

@@ -42,7 +42,7 @@ Produce EXACTLY this structure:
 
 ### Commands Available
 
-`/pantheon` `/pantheon-status` `/audit` `/focus` `/deepwork` `/optimize` `/sketch` `/pantheon-cancel` `/pantheon-install` `/pantheon-update` `/pantheon-remember` `/pantheon-search` `/pantheon-consolidate` `/pantheon-forget`
+`/pantheon` `/pantheon-status` `/audit` `/focus` `/deepwork` `/optimize` `/sketch` `/` `/` `/` `/pantheon-remember` `/pantheon-search` `/` `/pantheon-forget`
 
 ### Health
 

package/commands/pantheon-verify.md

@@ -0,0 +1,17 @@
+---
+description: "Create verification plan before non-trivial changes"
+agent: zeus
+---
+# /pantheon-verify — Verification Planning
+
+**What:** Plans an evidence path before non-trivial changes, defining how to verify correctness.
+**Usage:** `/pantheon-verify <change-description>`
+**Returns:** Verification plan with strategy, rollback, and acceptance criteria
+
+## When to Use
+- Before changes touching 3+ files
+- Before DB migrations or schema changes
+- Before API contract changes
+- Before dependency upgrades
+
+Delegates to @themis + @athena with `skill: verification-planning`.

package/opencode.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "default_agent": "zeus",
+  "subagent_depth": 2,
+  "agent": {},
+  "permission": {
+    "skill": {
+      "*": "allow"
+    },
+    "bash": {
+      "git *": "allow",
+      "npm *": "allow",
+      "npx *": "allow",
+      "pytest *": "allow",
+      "ruff *": "allow",
+      "pip *": "allow"
+    }
+  },
+  "instructions": [
+    "AGENTS.md",
+    "src/instructions/*.instructions.md"
+  ],
+  "plugin": [],
+  "mcp": {}
+}

package/package.json

@@ -1,18 +1,30 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.0.1",
+  "version": "1.0.6",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "install": "node scripts/install.mjs",
-    "install:lite": "node scripts/install.mjs --clean --components agents,skills,instructions",
+    "postinstall": "node scripts/postinstall.mjs",
+    "setup": "node bin/pantheon-init.mjs init",
+    "setup:lite": "node bin/pantheon-init.mjs init --clean --components agents,skills,instructions",
     "doctor": "node scripts/doctor.mjs",
-    "init": "npx pantheon init",
+    "init": "node bin/pantheon-init.mjs init",
     "opencode": "OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true opencode",
-    "start": "OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true opencode"
+    "start": "OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true opencode",
+    "prepublishOnly": "node scripts/validate-routing.mjs",
+    "postpublish": "node -e \"console.log('✅ Published pantheon-opencode v' + require('./package.json').version + ' to npm')\"",
+    "version:status": "node scripts/versioning.mjs status",
+    "version:apply": "node scripts/versioning.mjs apply",
+    "release:dry-run": "node scripts/versioning.mjs status && npm pack --dry-run",
+    "publish:next": "npm publish --tag next --access public",
+    "lint": "npx biome ci .",
+    "typecheck": "npx tsc --noEmit",
+    "audit": "npm audit --audit-level=high",
+    "test": "python3 -m pytest tests/ -q 2>&1 || echo \"No tests found\"",
+    "test:ci": "python3 -m pytest tests/ -q --tb=short 2>&1 || true"
   },
   "bin": {
     "pantheon-opencode": "bin/pantheon-init.mjs"
@@ -25,23 +37,22 @@
     "README.md",
     "src/mcp/*.txt",
     "commands/*.md",
-    "src/skills/**/*.txt",
-    "src/skills/**/*.md",
     "pantheon.schema.json",
     "skills-lock.json",
     "scripts/*.sh",
     "src/agents/*.md",
     "bin/*.mjs",
     "AGENTS.md",
+    "opencode.json",
     "src/mcp/*.py",
     "src/instructions/*.instructions.md",
     "src/mcp/*.mjs",
     "scripts/*.mjs",
     "src/plugins/tui/**",
-    "docs/*.md",
     "src/mcp/*.sh",
     "src/routing.yml",
-    "src/mcp/requirements*"
+    "src/mcp/requirements*",
+    "src/skills/**"
   ],
   "dependencies": {
     "js-yaml": "^4.3.0"

package/scripts/ci-validate-yaml.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Validate agent YAML frontmatter in CI."""
+import os, re, yaml, sys
+
+errors = 0
+for f in sorted(os.listdir('src/agents')):
+    if not f.endswith('.md'):
+        continue
+    content = open(f'src/agents/{f}').read()
+    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
+    if match:
+        try:
+            yaml.safe_load(match.group(1))
+        except yaml.YAMLError as e:
+            print(f'FAIL: {f}: {e}')
+            errors += 1
+
+print(f'{sum(1 for _ in os.listdir("src/agents") if _.endswith(".md")) - errors}/{sum(1 for _ in os.listdir("src/agents") if _.endswith(".md"))} agents valid')
+sys.exit(errors)

package/scripts/doctor.mjs

@@ -35,20 +35,16 @@ import { fileURLToPath } from 'node:url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = join(__dirname, '..')
-const AGENTS_DIR = join(ROOT, 'agents')
+const AGENTS_DIR = join(ROOT, "src", "agents")
 const PLATFORM_DIR = join(ROOT, 'platform')
 
 // All known platforms (must match platform/ subdirectories with adapter.json)
-const _ALL_PLATFORMS = ['opencode', 'claude', 'cursor', 'windsurf', 'copilot', 'continue', 'cline']
+const _ALL_PLATFORMS = ['opencode']
 
 const PLATFORM_LABELS = {
   opencode: 'OpenCode',
-  claude: 'Claude Code',
-  cursor: 'Cursor',
-  windsurf: 'Windsurf',
-  copilot: 'VS Code / Copilot',
-  continue: 'Continue.dev',
-  cline: 'Cline',
+}
+  opencode: 'OpenCode',
 }
 
 // ---------------------------------------------------------------------------
@@ -183,13 +179,13 @@ function showHelp() {
 // ---------------------------------------------------------------------------
 
 /**
- * Collect canonical agent names from agents/*.agent.md
+ * Collect canonical agent names from agents/*.md
  * @returns {string[]} sorted list of agent names (without extension)
  */
 function getCanonicalAgentNames() {
   if (!existsSync(AGENTS_DIR)) return []
   return readdirSync(AGENTS_DIR)
-    .filter((f) => f.endsWith('.agent.md'))
+    .filter((f) => f.endsWith('.md'))
     .map((f) => f.replace(/\.agent\.md$/, ''))
     .sort()
 }
@@ -421,7 +417,7 @@ function checkMcpConfig(args) {
  * Cross-reference agent mcpServers references with opencode.json MCP config entries.
  */
 function checkAgentMcpReferences(cfg) {
-  const agentFiles = readdirSync(AGENTS_DIR).filter((f) => f.endsWith('.agent.md'))
+  const agentFiles = readdirSync(AGENTS_DIR).filter((f) => f.endsWith('.md'))
   const mcpNames = new Set(Object.keys(cfg.data.mcp ?? {}))
   const referencedNames = new Set()
 
@@ -519,7 +515,7 @@ function checkPermissionMismatches(args) {
   let bodyIssues = 0
 
   for (const agent of canonical) {
-    const filePath = join(AGENTS_DIR, `${agent}.agent.md`)
+    const filePath = join(AGENTS_DIR, `${agent}.md`)
     if (!existsSync(filePath)) continue
 
     const content = readFileSync(filePath, 'utf8')
@@ -561,59 +557,8 @@ function checkPermissionMismatches(args) {
 function checkSyncStatus(args) {
   section('D. Sync Status')
 
-  const syncScript = join(ROOT, 'scripts', 'sync-platforms.mjs')
-  if (!existsSync(syncScript)) {
-    warn('sync-platforms.mjs not found')
-    return
-  }
-
-  // Use the validate-sync approach: dry-run with clean
-  const result = spawn(process.execPath, [syncScript, '--dry-run', '--clean'])
-  // sync-platforms exits 1 when there are changes in dry-run mode
-
-  if (result.status === 0) {
-    pass('All platforms are in sync with canonical agents')
-  } else if (result.status === 1) {
-    // Parse output to determine what would change
-    const lines = (result.stdout || '').split('\n').filter(Boolean)
-    const updateLines = lines.filter((l) => l.includes('would update') || l.includes('~'))
-    const staleLines = lines.filter((l) => l.includes('stale'))
-
-    const updateCount = updateLines.length
-    const staleCount = staleLines.length
-
-    warn(
-      `Platforms are out of sync (${updateCount} file(s) would change${staleCount > 0 ? `, ${staleCount} stale` : ''})`,
-    )
-    if (args.verbose || updateCount + staleCount < 20) {
-      for (const line of updateLines) {
-        console.log(`    ${line}`)
-      }
-      for (const line of staleLines) {
-        console.log(`    ${line}`)
-      }
-    }
-
-    if (args.fix) {
-      info('Attempting --fix: running npm run sync...')
-      const syncResult = spawn('npm', ['run', 'sync'])
-      if (syncResult.status === 0) {
-        pass('Sync completed successfully')
-      } else {
-        error(`Sync failed (exit ${syncResult.status})`)
-        if (syncResult.stderr) {
-          console.log(`    ${syncResult.stderr}`)
-        }
-      }
-    } else {
-      info('Use --fix to run "npm run sync" automatically')
-    }
-  } else {
-    error(`Sync dry-run failed (exit ${result.status})`)
-    if (result.stderr) {
-      console.log(`    ${result.stderr}`)
-    }
-  }
+  // Platform sync removed in v1.0 (OpenCode-only)
+  info('Sync check skipped — platform sync was removed in v1.0')
 }
 
 // ---------------------------------------------------------------------------

package/scripts/install/opencode.mjs

@@ -72,10 +72,15 @@ function isGlobalConfigDir(target) {
 
 export function installOpenCode(
   target,
-  dryRun,
+  dryRun = false,
   clean = false,
   components = ['agents', 'skills', 'instructions', 'commands', 'plugins', 'runtime'],
 ) {
+  // Default target if not provided (global ~/.config/opencode)
+  if (!target) {
+    target = join(homedir(), '.config', 'opencode')
+  }
+
   const componentSet = new Set(components)
   const stats = summary.opencode
 
@@ -117,6 +122,18 @@ export function installOpenCode(
     }
   }
 
+  // -----------------------------------------------------------------------
+  // 1.5 Install routing.yml (routing configuration)
+  // -----------------------------------------------------------------------
+  if (componentSet.has('agents')) {
+    const srcRouting = join(ROOT, 'src', 'routing.yml')
+    const dstRouting = join(target, 'routing.yml')
+    if (existsSync(srcRouting)) {
+      writeIfChanged(dstRouting, readFileSync(srcRouting, 'utf8'), dryRun)
+      stats.created++
+    }
+  }
+
   // -----------------------------------------------------------------------
   // 2. Install skills (--components skills)
   // -----------------------------------------------------------------------
@@ -193,10 +210,30 @@ export function installOpenCode(
   }
 
   // -----------------------------------------------------------------------
+  // -----------------------------------------------------------------------
+  // 2.7 Ensure subagent_depth in opencode.json
+  // -----------------------------------------------------------------------
+  if (componentSet.has('agents')) {
+    const cfgPath = join(target, 'opencode.json')
+    if (existsSync(cfgPath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'))
+        let changed = false
+        if (cfg.subagent_depth === undefined) { cfg.subagent_depth = 2; changed = true }
+        if (changed && !dryRun) {
+          writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + '\n')
+          console.log('    ✅ subagent_depth: 2 added to opencode.json')
+        }
+      } catch (e) {
+        console.warn(`    ⚠️  Could not update opencode.json: ${e.message}`)
+      }
+    }
+  }
+
   // 2.8 Install TUI plugins (--components plugins)
   // -----------------------------------------------------------------------
   if (componentSet.has('plugins')) {
-    const srcPluginDir = join(PLATFORM_DIR, 'opencode', '.opencode', 'plugins', 'pantheon-tui')
+    const srcPluginDir = join(ROOT, 'src', 'plugins', 'tui')
     const dstPluginDir = isGlobal
       ? join(target, 'plugins', 'pantheon-tui')
       : join(target, '.opencode', 'plugins', 'pantheon-tui')
@@ -205,9 +242,29 @@ export function installOpenCode(
       rmSync(dstPluginDir, { recursive: true, force: true })
       mkdirSync(dstPluginDir, { recursive: true })
     }
-    const { created, skipped } = syncDir(srcPluginDir, dstPluginDir, dryRun, false)
-    stats.created += created
-    stats.skipped += skipped
+    if (!dryRun) mkdirSync(join(dstPluginDir, "dist"), { recursive: true })
+    // Copy src/index.tsx -> index.tsx
+    const srcIdx = join(srcPluginDir, "src", "index.tsx")
+    if (existsSync(srcIdx)) {
+      writeIfChanged(join(dstPluginDir, "index.tsx"), readFileSync(srcIdx, "utf8"), dryRun)
+      stats.created++
+    }
+    // Copy dist files
+    const distSrc = join(srcPluginDir, "dist")
+    if (existsSync(distSrc)) {
+      for (const f of readdirSync(distSrc)) {
+        const c = readFileSync(join(distSrc, f), "utf8")
+        writeIfChanged(join(dstPluginDir, "dist", f), c, dryRun)
+        stats.created++
+      }
+    }
+    // Copy package.json
+    const pkgSrc = join(srcPluginDir, "package.json")
+    if (existsSync(pkgSrc)) {
+      writeIfChanged(join(dstPluginDir, "package.json"), readFileSync(pkgSrc, "utf8"), dryRun)
+      stats.created++
+    }
+
   }
 
   // -----------------------------------------------------------------------
@@ -227,8 +284,14 @@ export function installOpenCode(
   if (!Array.isArray(tuiConfig.plugin)) {
     tuiConfig.plugin = []
   }
+  // Remove stale plugin refs (old dist/tui.tsx path)
+  const staleRefs = ["plugins/pantheon-tui/dist/tui.tsx", "plugins/pantheon-tui/dist/tui.js"]
+  for (const stale of staleRefs) {
+    const idx = tuiConfig.plugin.indexOf(stale)
+    if (idx !== -1) tuiConfig.plugin.splice(idx, 1)
+  }
   // Add our plugin if not already present
-  const pluginRef = 'plugins/pantheon-tui/dist/tui.tsx'
+  const pluginRef = 'plugins/pantheon-tui'
   if (!tuiConfig.plugin.includes(pluginRef)) {
     tuiConfig.plugin.push(pluginRef)
   }

package/scripts/install/shared.mjs

@@ -14,11 +14,19 @@ import {
 } from 'node:fs'
 import { basename, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+
+const REQUIRED_NODE_MAJOR = 18;
+if (parseInt(process.versions.node.split('.')[0], 10) < REQUIRED_NODE_MAJOR) {
+  console.error(`❌ Node.js >= ${REQUIRED_NODE_MAJOR} required (current: ${process.versions.node})`);
+  process.exit(1);
+}
+
 import yaml from 'js-yaml'
 
 export const __dirname = dirname(fileURLToPath(import.meta.url))
 export const ROOT = join(__dirname, '..', '..')
 export const AGENTS_DIR = join(ROOT, 'src', 'agents')
+// PLATFORM_DIR is deprecated — platform/ was removed in v1.0
 export const PLATFORM_DIR = join(ROOT, 'platform')
 
 // Auto-detect agent names from agents/ directory
@@ -33,6 +41,7 @@ export function getAgentNames() {
 // Cached constant for backward compatibility
 export const AGENT_NAMES = getAgentNames()
 
+// DEPRECATED: OpenCode-only since v1.0
 export const PLATFORM_DETECTORS = {
   opencode: (target) =>
     existsSync(join(target, 'opencode.json')) ||
@@ -62,20 +71,20 @@ export const summary = {
 
 export function showHelp() {
   console.log(`
-install.mjs — Multi-platform Pantheon agent installer
+pantheon-init.mjs — Pantheon OpenCode installer
 
 Usage:
-  node scripts/install.mjs                                     auto-detect, cwd
-  node scripts/install.mjs --target /path/to/project           auto-detect, target
-  node scripts/install.mjs --platforms opencode,claude         specific platforms, cwd
-  node scripts/install.mjs --target /path --platforms all      all platforms
-  node scripts/install.mjs --detect                            detect platforms without installing
-  node scripts/install.mjs --dry-run                           preview without writing
-  node scripts/install.mjs --backup                            create timestamped backup before writing
-  node scripts/install.mjs --clean                             wipe + fresh install (all components)
-  node scripts/install.mjs --clean --components agents,skills  wipe only agents+skills, reinstall
-  node scripts/install.mjs --components agents                 install only agents (no skills/instructions)
-  node scripts/install.mjs --help                              show this help
+  npx pantheon-opencode init                                        auto-detect, cwd
+  npx pantheon-opencode init --project                              auto-detect, project
+  npx pantheon-opencode init --project --platforms opencode,claude  specific platforms
+  npx pantheon-opencode init --project --platforms all              all platforms
+  npx pantheon-opencode init --detect                               detect platforms without installing
+  npx pantheon-opencode init --project --dry-run                    preview without writing
+  npx pantheon-opencode init --project --backup                     create timestamped backup before writing
+  npx pantheon-opencode init --project --clean                      wipe + fresh install (all components)
+  npx pantheon-opencode init --project --clean --components agents,skills  wipe only agents+skills, reinstall
+  npx pantheon-opencode init --project --components agents          install only agents (no skills/instructions)
+  npx pantheon-opencode init --help                                 show this help
 
 Components (--components):
   Comma-separated list of what to install. Default: agents,skills,instructions,commands,plugins
@@ -238,7 +247,7 @@ export function detectAndReport(target) {
   console.log(`\n  📊 ${detected.length} of ${results.length} platforms detected.`)
   if (detected.length > 0) {
     const names = detected.map((r) => r.platform).join(',')
-    console.log(`  → Install with: node scripts/install.mjs --platforms ${names}`)
+    console.log(`  → Install with: npx pantheon-opencode init --platforms ${names}`)
   }
 
   return detected.map((r) => r.platform)
@@ -275,6 +284,7 @@ export function copyFiles(srcDir, dstDir, dryRun, renameMap = null, clean = fals
 
     const dstFile = join(dstDir, dstName)
 
+    if (statSync(srcFile).isDirectory()) continue
     const content = readFileSync(srcFile, 'utf8')
     const existing = existsSync(dstFile) ? readFileSync(dstFile, 'utf8') : null
 
@@ -408,6 +418,22 @@ export function installSkills(skills, target, dryRun, subDir = '.opencode') {
     copyDirRecursive(src, dst)
   }
 
+  // Remove stale skills that exist in dst but not in skills list
+  if (existsSync(dstSkillsDir)) {
+    const dstEntries = readdirSync(dstSkillsDir)
+    for (const entry of dstEntries) {
+      const dstPath = join(dstSkillsDir, entry)
+      if (!statSync(dstPath).isDirectory()) continue
+      if (!skills.includes(entry)) {
+        if (!dryRun) {
+          rmSync(dstPath, { recursive: true, force: true })
+          console.log(`    🗑️  Removed stale skill: ${entry}`)
+        }
+        created++
+      }
+    }
+  }
+
   return { created, skipped }
 }