pantheon-opencode 1.5.0-beta.9 → 1.5.1

package/README.pt-BR.md

@@ -31,7 +31,7 @@ de planejar o trabalho, avançar, conferir resultados e preservar o contexto
 
 ## Comece em 2 minutos
 
-Requisitos: [OpenCode 1.18.4+](https://opencode.ai/docs/) e Node.js 18+.
+Requisitos: [OpenCode 1.18.4+](https://opencode.ai/docs/) e Node.js 22+.
 
 No projeto em que você quer usar o Pantheon:
 
@@ -130,16 +130,15 @@ registrados juntos.
 |---|---|---|
 | Chave de config do OpenCode | `plugin` singular | `plugins` plural |
 | Registro Pantheon | `src/plugin.ts` mais `src/plugins/pantheon-hooks.ts` | `pantheon-opencode/plugin-v2` (`src/plugin-v2.ts`) |
-| Contrato de runtime | Plugin Pantheon legado, incluindo `pantheon_delegate`, ferramentas read/list, hooks de evento/ferramenta e tratamento de compactação V1 | Plugin V2 completo: 9 ferramentas de orquestração, 4 assinaturas de eventos, session hooks (`prompt`, `context`), tool hooks (`execute.before`/`after`), além de transforms de configuração |
+| Contrato de runtime | Plugin Pantheon V1: 6 ferramentas (`hashline_edit`, as 3 ferramentas de goal, `pantheon_cost`, `pantheon_model`), hooks de evento/ferramenta e tratamento de compactação V1 | Plugin V2 completo: 6 ferramentas de orquestração, 4 assinaturas de eventos, session hooks (`prompt`, `context`), tool hooks (`execute.before`/`after`), além de transforms de configuração |
 | APIs V1 | Registradas | Definições próprias de ferramentas via `ctx.tool.transform()` — não pelo caminho do plugin V1 |
 
-O plugin V2 fornece 9 ferramentas de orquestração (`pantheon_delegate`,
-`pantheon_delegation_read`, `pantheon_delegation_list`, `hashline_edit`,
+O plugin V2 fornece 6 ferramentas de orquestração (`hashline_edit`,
 `pantheon_goal_create`, `pantheon_goal_get`, `pantheon_goal_update`,
 `pantheon_cost`, `pantheon_model`), 4 assinaturas de eventos (`session.created`,
 `session.idle`, `session.error`, `session.compacted`), session hooks (`prompt`,
 `context`) e tool hooks (`execute.before`, `execute.after`). O único recurso V2
-sem suporte é `legacy-hooks` (a superfície de API de delegate específica do V1).
+sem suporte é `legacy-hooks` (a superfície de hooks específica do V1).
 
 O pacote expõe os dois contratos como exports importáveis:
 `pantheon-opencode/plugin` (V1), `pantheon-opencode/plugin-v2` (V2) e
@@ -147,7 +146,7 @@ O pacote expõe os dois contratos como exports importáveis:
 explicitamente o contrato desejado.
 
 A ponte V1→V2 (`src/pantheon/v2-bridge.ts`) habilita interop opcional:
-singletons de infraestrutura V1 (BackgroundJobBoard, DelegationClient,
+singletons de infraestrutura V1 (BackgroundJobBoard,
 GoalStore, TodoEnforcer, VisionHandler) são repassados via `ctx.options` do V2.
 A ponte é opcional — o V2 funciona standalone com degradação graciosa.
 

package/commands/pantheon.md

@@ -9,41 +9,7 @@ agent: zeus
 **When:** Architecture trade-offs, technology selection, security assessments, multi-stakeholder concerns
 **Returns:** Structured synthesis with recommendation, confidence level, resolved divergences
 
-## Dispatch Selection
-
-Choose 2-3 agents based on domain:
-
-| Domain | Specialists |
-|--------|-------------|
-| Architecture | hermes, demeter, themis, athena |
-| Security | themis, hermes, prometheus, nyx |
-| Database | demeter, hermes, prometheus |
-| AI/RAG | hephaestus, nyx |
-| Infrastructure | prometheus, hermes, themis |
-| Frontend/UX | aphrodite, themis, hermes |
-| Observability | nyx, hermes |
-| General | athena, themis, hermes |
-
-Send ALL `task()` calls in a single message. Each must return: Recommendation · Reasoning · Trade-offs · Risks · Confidence.
-
-## Synthesis Structure
-
-After ALL responses arrive, produce EXACTLY this structure:
-
-### 📋 Individual Assessments
-For each specialist: Recommendation, Reasoning, Trade-offs, Risks, Confidence
-
-### ✅ Agreements
-Where 2+ specialists converge
-
-### ⚡ Divergences
-Where they disagree — resolve each one with reasoning
-
-### 🔥 Total Divergence
-If ALL specialists disagree on a point, call this out explicitly
-
-### 🏆 Recommendation
-Decisive conclusion with confidence level
+Dispatch, specialist selection, and synthesis follow the canonical `## Zeus Council Synthesis` protocol (Steps 0–9: precedent fast-path, dispatch, confidence cross-validation, rebuttal, tie-break, Themis audit, persist). Send ALL `task()` calls in a single message; each specialist returns the `## specialist_response` structure from `## Agent Return Format`.
 
 ## Question:
 $ARGUMENTS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pantheon-opencode",
-  "version": "1.5.0-beta.9",
+  "version": "1.5.1",
   "description": "Multi-agent orchestration for OpenCode — 14 specialized agents, TDD, Themis review gates.",
   "type": "module",
   "publishConfig": {
@@ -31,7 +31,6 @@
     "release:dry-run": "node scripts/versioning.mjs status && node scripts/release-notes.mjs && node scripts/package-evidence.mjs",
     "package:evidence": "node scripts/package-evidence.mjs",
     "package:validate": "node scripts/validate-package.mjs",
-    "publish:next": "npm publish --tag next --access public",
     "lint": "biome ci .",
     "typecheck": "tsc --noEmit",
     "audit": "npm audit --audit-level=high",
@@ -120,7 +119,7 @@
   "author": "ils15",
   "license": "MIT",
   "engines": {
-    "node": ">=22"
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
   },
   "preferGlobal": true
 }

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pantheon",
   "publisher": "ils15",
-  "version": "1.5.0-beta.9",
+  "version": "1.5.1",
   "displayName": "Pantheon",
   "description": "Conductor-Delegate orchestration platform with 14 specialized agents, 21 skills, and OpenCode support.",
   "agents": "./src/agents",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.backends._legacy:_Backend"
 
 [project]
 name = "pantheon"
-version = "1.5.0-beta.9"
+version = "1.5.1"
 description = "Multi-agent orchestration framework"
 requires-python = ">=3.11"
 dependencies = []
@@ -37,10 +37,9 @@ ignore = ["E501"]
 "scripts/scrub-secrets.py" = ["N999"]
 # These modules defer optional/heavy imports until the corresponding command is used.
 "scripts/vector_memory/*.py" = ["PLC0415"]
-"tests/test_code_mode_args.py" = ["PLC0415"]
 "tests/test_code_mode_sandbox.py" = ["PLC0415", "N806"]
 "tests/test_code_mode_server.py" = ["PLC0415"]
-"tests/test_eval_store.py" = ["PLC0415", "PLR2004"]
+"tests/test_codemap_mcp.py" = ["PLC0415"]
 "tests/test_memory_mcp_server.py" = ["PLC0415", "PLR2004"]
 # Existing public APIs and test fixtures are intentionally broad/simple; refactoring
 # them would be behavior-affecting rather than a mechanical lint correction.
@@ -54,8 +53,7 @@ ignore = ["E501"]
 "scripts/vector_memory/query.py" = ["PLR0913"]
 "src/mcp/eval_store.py" = ["PLR2004"]
 "tests/test_code_mode_frontmatter.py" = ["PLR2004"]
-"tests/test_eval_judge.py" = ["PLR2004"]
-"tests/test_eval_static.py" = ["PLR2004"]
+"tests/test_eval.py" = ["PLR2004"]
 "tests/test_mcp_persistence_server.py" = ["PLR2004"]
 
 [tool.mypy]

package/scripts/doctor.mjs

@@ -9,6 +9,7 @@
  *   - Permission/frontmatter mismatches
  *   - OpenCode artifact freshness
  *   - Git status
+ *   - Node runtime (node:sqlite availability for pantheon_cost)
  *
  * Usage:
  *   node scripts/doctor.mjs                          # auto-detect, cwd
@@ -23,9 +24,9 @@
 
 import { spawn as spawnAsync, spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { basename, dirname, join, resolve } from 'node:path'
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 // ---------------------------------------------------------------------------
@@ -159,6 +160,8 @@ function showHelp() {
    D. OpenCode Status      — OpenCode artifact layout
    E. Git Status           — uncommitted changes
    F. Runtime Layer        — venv python + pinned pip dependencies
+   H3. Plugin Drift        — registered plugin version vs this package
+   K. Node Runtime         — node:sqlite availability for pantheon_cost
 
  Exit codes:
    0  — no blocking errors (warnings are advisory)
@@ -959,6 +962,35 @@ function checkVenvLayer(args) {
 // Check F.2: Code-Mode Scripts Directory
 // ---------------------------------------------------------------------------
 
+/**
+ * Return whether *dir* contains an executable code-mode target.
+ *
+ * Mirrors `_has_usable_scripts` in `scripts/code_mode_server.py`: a directory
+ * is only a valid resolver candidate when it is a real (non-symlink) directory
+ * containing a regular `.py`/`.sh` direct child. This prevents an empty project
+ * overlay from masking a lower-priority installation that actually ships
+ * scripts. Keep both implementations in sync (see tests/test_doctor_layers.mjs).
+ */
+function hasUsableScripts(dir) {
+  try {
+    if (!existsSync(dir)) return false
+    const stat = lstatSync(dir)
+    if (stat.isSymbolicLink() || !stat.isDirectory()) return false
+    return readdirSync(dir).some((name) => {
+      if (name.startsWith('.')) return false
+      const lower = name.toLowerCase()
+      if (!lower.endsWith('.py') && !lower.endsWith('.sh')) return false
+      try {
+        return statSync(join(dir, name)).isFile()
+      } catch {
+        return false
+      }
+    })
+  } catch {
+    return false
+  }
+}
+
 /**
  * Verify the code-mode scripts directory exists for the resolved runtime
  * root (project → <target>/.opencode, otherwise the global config dir).
@@ -977,7 +1009,7 @@ export function checkCodeModeDir(args) {
   // install (.opencode present) gets its runtime dir created when missing.
   // Only targets with no project layout fall back to the global config dir.
   const codeModeDir =
-    projectCandidates.find((candidate) => existsSync(candidate)) ??
+    projectCandidates.find(hasUsableScripts) ??
     (existsSync(join(target, '.opencode'))
       ? projectCandidates[0]
       : join(resolveOpenCodeConfigDir(env), '.pantheon', 'code-mode'))
@@ -1003,7 +1035,7 @@ export function resolveCodeModeDir(args) {
     join(target, '.opencode', '.pantheon', 'code-mode'),
     join(target, '.pantheon', 'code-mode'),
   ]
-  const projectDir = projectCandidates.find((candidate) => existsSync(candidate))
+  const projectDir = projectCandidates.find(hasUsableScripts)
   if (projectDir) return projectDir
   return join(resolveOpenCodeConfigDir(env), '.pantheon', 'code-mode')
 }
@@ -1132,7 +1164,10 @@ function comparePantheonVersions(a, b) {
   for (let i = 0; i < 3; i++) {
     if (pa.core[i] !== pb.core[i]) return pa.core[i] - pb.core[i]
   }
-  return pa.beta - pb.beta
+  // Infinity - Infinity is NaN, which would make equal stable versions compare
+  // as drift for any caller using a strict === 0 check.
+  if (pa.beta === pb.beta) return 0
+  return pa.beta < pb.beta ? -1 : 1
 }
 
 /**
@@ -1185,6 +1220,159 @@ export function checkInstallVersionDrift(args) {
   return 'sync'
 }
 
+// ---------------------------------------------------------------------------
+// Check H3: Plugin version drift (issue #158)
+// ---------------------------------------------------------------------------
+// npm installs are lockfile-authoritative: a package-lock.json pinned to an
+// older pantheon-opencode (e.g. 1.4.1 satisfying ^1.4.1) is never re-resolved,
+// so an installed copy under node_modules/pantheon-opencode can lag several
+// releases behind the running package. The opencode.json keeps registering
+// that stale copy's plugin path and the user silently runs an obsolete tool
+// surface — 1.5.0 removed the pantheon_delegate tool, so a drifted install
+// still exposes it. This layer compares the version of the package a
+// registered plugin points into against this package's own version. Without
+// network access the "latest" version IS the running package's version.
+
+/** Locates an installed copy of this package inside a dependency tree. */
+const INSTALLED_PACKAGE_MARKER = '/node_modules/pantheon-opencode/'
+
+/**
+ * Return the installed-package root containing a plugin path, or null when the
+ * path is not inside a `node_modules/pantheon-opencode` tree.
+ *
+ * Only installed copies are compared: a dev checkout (e.g. <dev>/pantheon)
+ * and unrelated directories named pantheon-opencode are deliberately not
+ * flagged — the drift signal must never fire on a path the installer does not
+ * own (see the third-party guards in scripts/install/opencode.mjs).
+ *
+ * @param {string|null|undefined} pluginPath
+ * @returns {string|null}
+ */
+export function resolveInstalledPackageRoot(pluginPath) {
+  if (typeof pluginPath !== 'string') return null
+  const normalized = pluginPath.replaceAll('\\', '/')
+  const index = normalized.toLowerCase().lastIndexOf(INSTALLED_PACKAGE_MARKER.toLowerCase())
+  if (index === -1) return null
+  return normalized.slice(0, index + INSTALLED_PACKAGE_MARKER.length - 1)
+}
+
+/**
+ * Read the version of the installed pantheon-opencode package a registered
+ * plugin path points into.
+ * @param {string} pluginPath - absolute or config-relative plugin ref
+ * @returns {{root: string, version: string}|null} null when not an installed copy
+ */
+function readInstalledPluginVersion(pluginPath) {
+  const root = resolveInstalledPackageRoot(pluginPath)
+  if (!root) return null
+  const pkg = readJson(join(root, 'package.json'))
+  if (!pkg || typeof pkg.version !== 'string') return null
+  return { root, version: pkg.version }
+}
+
+/**
+ * Classify plugin version drift between the package a registered plugin points
+ * into and the running doctor's own package. Uses the prerelease-aware
+ * comparator so a stable release outranks its own betas (1.5.0 > 1.5.0-beta.9).
+ * Unreadable versions classify as "unknown" rather than drift, so a broken
+ * package.json never produces a false warning.
+ * @param {string|null} registeredVersion
+ * @param {string|null} packageVersion
+ * @returns {'sync'|'drift'|'unknown'}
+ */
+export function classifyPluginVersionDrift(registeredVersion, packageVersion) {
+  if (!registeredVersion || !packageVersion) return 'unknown'
+  return comparePantheonVersions(registeredVersion, packageVersion) === 0 ? 'sync' : 'drift'
+}
+
+/**
+ * Collect the plugin refs registered across opencode.json configs, from both
+ * the V1 `plugin` and V2 `plugins` lists. Each entry keeps the config it came
+ * from so relative refs resolve against the config directory (as the loader
+ * does), never against the doctor's cwd.
+ * @param {{path: string, data: object}[]} configs
+ * @returns {{path: string, configPath: string, configLabel: string}[]}
+ */
+export function collectRegisteredPluginRefs(configs) {
+  const refs = []
+  for (const cfg of configs) {
+    for (const key of ['plugin', 'plugins']) {
+      const list = cfg.data?.[key]
+      if (!Array.isArray(list)) continue
+      for (const ref of list) {
+        if (typeof ref === 'string') {
+          refs.push({ path: ref, configPath: cfg.path, configLabel: cfg.label })
+        } else if (ref && typeof ref === 'object') {
+          // Object-shaped entries carry their path under `path`/`source`.
+          const objectPath = ['path', 'source', 'id', 'name'].find(
+            (k) => typeof ref[k] === 'string',
+          )
+          if (objectPath) {
+            refs.push({ path: ref[objectPath], configPath: cfg.path, configLabel: cfg.label })
+          }
+        }
+      }
+    }
+  }
+  return refs
+}
+
+/**
+ * Compare the version of the package each registered plugin points into (when
+ * it is an installed copy under node_modules/pantheon-opencode) against this
+ * package's own version, and warn on divergence. Advisory only — a drift
+ * warning never changes the exit code, and a healthy install stays silent.
+ * @param {object} args
+ * @returns {'drift'|'sync'|'skip'|'no-plugin'|'no-version'}
+ */
+export function checkPluginVersionDrift(args) {
+  section('H3. Plugin Version Drift')
+
+  const pkg = readJson(join(ROOT, 'package.json'))
+  const packageVersion = pkg?.version
+  if (!packageVersion) {
+    info('Plugin version drift skipped — this package has no readable version')
+    return 'no-version'
+  }
+
+  const refs = collectRegisteredPluginRefs(collectMcpConfigs(args))
+  if (refs.length === 0) {
+    info('No plugin registrations found in opencode.json — version drift skipped')
+    return 'no-plugin'
+  }
+
+  const seen = new Set()
+  let compared = 0
+  let driftReported = false
+  for (const ref of refs) {
+    const absolute = isAbsolute(ref.path) ? ref.path : resolve(dirname(ref.configPath), ref.path)
+    const installed = readInstalledPluginVersion(absolute)
+    if (!installed) continue
+    // The doctor running from the very tree the plugin points at is the
+    // healthy global-install case — trivially in sync, never flagged.
+    if (resolve(installed.root) === resolve(ROOT)) continue
+    if (seen.has(installed.root)) continue
+    seen.add(installed.root)
+    compared++
+
+    if (classifyPluginVersionDrift(installed.version, packageVersion) !== 'drift') continue
+    driftReported = true
+    warn(
+      `${ref.configLabel}: plugin is registered inside pantheon-opencode v${installed.version}, but this package is v${packageVersion} — the registered tool surface is stale (pantheon_delegate was removed in 1.5.0). Run \`npx pantheon-opencode init\`, or update the package, to realign the registered plugin path`,
+    )
+  }
+
+  if (driftReported) return 'drift'
+  if (compared === 0) {
+    info(
+      'No registered plugin points into an installed pantheon-opencode copy — version drift skipped',
+    )
+    return 'skip'
+  }
+  pass(`All registered plugins point at package v${packageVersion}`)
+  return 'sync'
+}
+
 // ---------------------------------------------------------------------------
 // Check G: AGENTS.md freshness
 // ---------------------------------------------------------------------------
@@ -1395,6 +1583,71 @@ export function classifyPermissionTaskCheck(profile, installedCount, missingCoun
   return missingCount === 0 ? 'pass' : 'error'
 }
 
+// ---------------------------------------------------------------------------
+// Check K: Node Runtime — node:sqlite availability (issue #114)
+// ---------------------------------------------------------------------------
+
+// pantheon_cost uses node:sqlite as its read-only backend; below this Node
+// version the tool reports UNSUPPORTED (see the "Cost tool backend" README
+// section). Matches the floor documented for the PANTHEON_NODE fallback.
+const NODE_SQLITE_MIN = '22.5'
+
+/**
+ * Probe whether the running Node.js can load `node:sqlite` — the read-only
+ * backend used by the `pantheon_cost` tool (issue #114). Runs the import in a
+ * `--no-warnings` child so the experimental-feature notice never pollutes the
+ * doctor output, and so a probe crash can never take down the doctor itself.
+ *
+ * @param {{ execPath?: string; module?: string }} [options]
+ * @returns {{ available: boolean; version: string; reason?: string }}
+ */
+export function probeNodeSqlite(options = {}) {
+  const execPath = options.execPath ?? process.execPath
+  const target = options.module ?? 'node:sqlite'
+  const result = spawn(execPath, [
+    '--no-warnings',
+    '--input-type=module',
+    '-e',
+    `import '${target}'`,
+  ])
+  if (result.status === 0) return { available: true, version: process.version }
+  const reason = (result.stderr || result.stdout || 'import failed').split('\n')[0]
+  return { available: false, version: process.version, reason }
+}
+
+/**
+ * Classify a node:sqlite probe result for the doctor. Kept free of I/O so the
+ * contract is exercised deterministically (see tests/test_doctor_layers.mjs).
+ *
+ * @param {{ available: boolean; version: string }} probe
+ * @returns {{ status: 'ok' | 'unsupported'; message: string }}
+ */
+export function classifyNodeSqliteProbe(probe) {
+  if (probe.available) {
+    return {
+      status: 'ok',
+      message: `node:sqlite available on ${probe.version} — pantheon_cost read-only backend supported`,
+    }
+  }
+  return {
+    status: 'unsupported',
+    message: `pantheon_cost will report UNSUPPORTED on Node ${probe.version} — node:sqlite requires Node >= ${NODE_SQLITE_MIN}`,
+  }
+}
+
+function checkNodeRuntime() {
+  section('K. Node Runtime')
+  const outcome = classifyNodeSqliteProbe(probeNodeSqlite())
+  if (outcome.status === 'ok') {
+    pass(outcome.message)
+  } else {
+    warn(outcome.message)
+    info(
+      `Upgrade to Node >= ${NODE_SQLITE_MIN} (or a runtime with node:sqlite) to enable pantheon_cost`,
+    )
+  }
+}
+
 /**
  * Return the final doctor status message without masking blocking errors.
  * @param {{ error: number; warn: number }} summaryCounts
@@ -1477,12 +1730,14 @@ async function main() {
     existsSync(join(args.target, 'scripts', 'doctor.mjs')) === false
 
   // Run checks (layer order: Config → Venv → spawn paths → runtime smoke)
+  checkNodeRuntime(args)
   checkAgentFiles(args)
   checkMcpConfig(args)
   checkVenvLayer(args)
   checkCodeModeDir(args)
   checkCodeModeManifest(args)
   checkInstallVersionDrift(args)
+  checkPluginVersionDrift(args)
   await checkMcpRuntimeSmoke(args)
   checkPermissionMismatches(args)
   checkSyncStatus(args)

package/scripts/install/plugin.mjs

@@ -8,8 +8,10 @@ import { isAbsolute, join, resolve } from 'node:path'
 import { ROOT, writeIfChanged } from './shared.mjs'
 
 /**
- * Copy a plugin's runtime payload (src/index.tsx → index.tsx, dist/*,
- * package.json and package-lock.json) from source to destination.
+ * Copy a plugin's runtime payload (the bundled dist/*, package.json and
+ * package-lock.json) from source to destination. Only the bundle is copied —
+ * the raw TSX source is never shipped to the destination, so the plugin can
+ * be modularized without the loader needing relative imports.
  * @param {string} srcDir - Source plugin directory (e.g. ROOT/src/plugins/tui)
  * @param {string} dstDir - Destination plugin directory
  * @param {object} [options]
@@ -22,16 +24,11 @@ export function copyPluginFiles(srcDir, dstDir, { dryRun = false } = {}) {
   if (!dryRun) mkdirSync(dstDir, { recursive: true })
   if (!dryRun) mkdirSync(join(dstDir, 'dist'), { recursive: true })
 
-  // Copy src/index.tsx -> index.tsx
-  const srcIdx = join(srcDir, 'src', 'index.tsx')
-  if (existsSync(srcIdx)) {
-    const idxStatus = writeIfChanged(
-      join(dstDir, 'index.tsx'),
-      readFileSync(srcIdx, 'utf8'),
-      dryRun,
-    )
-    if (idxStatus === 'created') result.created++
-    else result.skipped++
+  // Drop legacy raw copies from previous installs (root index.tsx + dist/tui.tsx).
+  // The loader consumes only the bundle, so stale raws must not linger.
+  if (!dryRun) {
+    rmSync(join(dstDir, 'index.tsx'), { force: true })
+    rmSync(join(dstDir, 'dist', 'tui.tsx'), { force: true })
   }
 
   // Copy dist/* files

package/scripts/mcp_persistence_server.py

@@ -1323,7 +1323,7 @@ def build_rehydration_blocks(checkpoint: dict) -> list[str] | None:
     """Build deterministic rehydration blocks from a checkpoint dict.
 
     Pure string templating — no LLM, no embeddings. Mirrors the
-    ``<mission_context>`` convention of delegation-compaction.ts: only a
+    ``<mission_context>`` convention of the compaction-context builder: only a
     non-done goal is re-emitted. Returns None when nothing critical remains.
     """
     if not isinstance(checkpoint, dict) or not checkpoint:

package/scripts/sync-tui.mjs

@@ -10,7 +10,7 @@
  * If the user hasn't initialized yet → do nothing (silent exit).
  */
 import { execSync } from 'node:child_process'
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
@@ -58,9 +58,9 @@ function resolveConfigDir() {
 }
 
 /**
- * Copy plugin runtime files (dist/*, package.json, package-lock.json,
- * src/index.tsx) from srcDir
- * to dstDir. Skips files that are byte-identical.
+ * Copy plugin runtime files (the bundled dist/*, package.json,
+ * package-lock.json) from srcDir to dstDir. Skips files that are byte-identical.
+ * The raw TSX source is never copied — the loader consumes only the bundle.
  * @returns {{ created: number, skipped: number }}
  */
 function copyPluginFiles(srcDir, dstDir) {
@@ -69,13 +69,10 @@ function copyPluginFiles(srcDir, dstDir) {
   mkdirSync(dstDir, { recursive: true })
   mkdirSync(join(dstDir, 'dist'), { recursive: true })
 
-  // src/index.tsx → index.tsx
-  const srcIdx = join(srcDir, 'src', 'index.tsx')
-  if (existsSync(srcIdx)) {
-    const content = readFileSync(srcIdx, 'utf8')
-    if (writeIfChanged(join(dstDir, 'index.tsx'), content)) result.created++
-    else result.skipped++
-  }
+  // Drop legacy raw copies from previous installs (root index.tsx + dist/tui.tsx).
+  // The loader consumes only the bundle, so stale raws must not linger.
+  rmSync(join(dstDir, 'index.tsx'), { force: true })
+  rmSync(join(dstDir, 'dist', 'tui.tsx'), { force: true })
 
   // dist/*
   const distSrc = join(srcDir, 'dist')

package/src/agents/apollo.md

@@ -12,6 +12,7 @@ permission:
   glob: allow
   webfetch: allow
   edit: deny
+  hashline_edit: deny
   bash: deny
   task:
     "*": deny

package/src/agents/gaia.md

@@ -11,6 +11,7 @@ permission:
   grep: allow
   webfetch: allow
   edit: deny
+  hashline_edit: deny
   bash: deny
   task:
     "*": deny

package/src/agents/mnemosyne.md

@@ -34,7 +34,17 @@ permission:
   bash: deny
   read: allow
   grep: allow
-  edit: allow
+  # Scoped write/edit: mnemosyne may create and modify files ONLY inside the
+  # memory-bank and deepwork directories. Everything else stays denied, keeping
+  # the SCOPE BOUNDARY below enforceable at the permission layer (issue #111).
+  write:
+    "*": deny
+    ".pantheon/memory-bank/**": allow
+    ".pantheon/deepwork/**": allow
+  edit:
+    "*": deny
+    ".pantheon/memory-bank/**": allow
+    ".pantheon/deepwork/**": allow
   task:
     "*": deny
 ---