pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.10

package/scripts/probe-pantheon-cost.mjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+/**
+ * Offline/ambiental probe for pantheon_cost.
+ *
+ * The probe never reads or writes a user's real database. Without --fixture it
+ * reports AMBIENTAL because a real dependency/database is intentionally not
+ * exercised. With --fixture it imports the installed command and creates a
+ * temporary synthetic opencode database. A missing fixture runtime is also
+ * AMBIENTAL rather than a false PASS.
+ */
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+const requestedVersion = valueFor('--version')
+const jsonOutput = process.argv.includes('--json')
+const fixtureMode = process.argv.includes('--fixture')
+
+function valueFor(name) {
+  const index = process.argv.indexOf(name)
+  return index >= 0 ? process.argv[index + 1] : undefined
+}
+
+function emit(status, detail, checks = []) {
+  const result = { status, version: requestedVersion, detail, checks }
+  if (jsonOutput) process.stdout.write(JSON.stringify(result))
+  else process.stdout.write(`${status}: ${detail}\n`)
+  if (status === 'FAIL') process.exitCode = 1
+}
+
+function diagnostic(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  const stderr =
+    error && typeof error === 'object' && typeof error.stderr === 'string'
+      ? error.stderr.trim()
+      : ''
+  return stderr === '' ? message : `${message}; stderr: ${stderr}`
+}
+
+function ambiental(detail) {
+  emit('AMBIENTAL', detail)
+}
+
+function setEnvironment(values) {
+  const previous = new Map()
+  for (const [key, value] of Object.entries(values)) {
+    previous.set(key, process.env[key])
+    if (value === undefined) delete process.env[key]
+    else process.env[key] = value
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  }
+}
+
+function createSyntheticDb(DatabaseSync, path, rows) {
+  const db = new DatabaseSync(path)
+  db.exec('CREATE TABLE message (data TEXT NOT NULL, time_created INTEGER NOT NULL)')
+  const insert = db.prepare('INSERT INTO message (data, time_created) VALUES (?, ?)')
+  for (const data of rows) insert.run(JSON.stringify(data), Date.now())
+  db.close()
+}
+
+function createIncompatibleDb(DatabaseSync, path) {
+  const db = new DatabaseSync(path)
+  db.exec('CREATE TABLE not_message (value TEXT NOT NULL)')
+  db.close()
+}
+
+function requireOutput(output, fragment, label) {
+  if (!output.includes(fragment)) throw new Error(`${label}: missing ${fragment}`)
+}
+
+function assertTokensOnly(output, expectedRows, total) {
+  requireOutput(output, 'Tokens In | Tokens Out | Tokens Total', 'tokens-only header')
+  for (const row of expectedRows) {
+    requireOutput(
+      output,
+      `| ${row.agent} | ${row.phase} | ${row.input} | ${row.output} | ${row.total} |`,
+      'token row',
+    )
+  }
+  requireOutput(
+    output,
+    `| **Total** | — | **${total.input}** | **${total.output}** | **${total.total}** |`,
+    'token total',
+  )
+  if (/Cost \(USD\)|costUsd|\$\d|\bUSD\b/i.test(output)) {
+    throw new Error('tokens-only output contains a monetary value')
+  }
+}
+
+async function main() {
+  if (requestedVersion !== 'v1' && requestedVersion !== 'v2') {
+    emit('FAIL', 'usage: --version v1|v2 [--fixture] [--json]')
+    return
+  }
+
+  if (!fixtureMode) {
+    ambiental(
+      'real pantheon_cost dependency/database not exercised; use --fixture for synthetic checks',
+    )
+    return
+  }
+
+  const source = new URL('../src/pantheon/cost-command.ts', import.meta.url)
+  if (!existsSync(source)) {
+    ambiental(
+      'pantheon_cost dependency is unavailable: installed package lacks src/pantheon/cost-command.ts',
+    )
+    return
+  }
+
+  let DatabaseSync
+  let createCostCommand
+  try {
+    ;({ DatabaseSync } = await import('node:sqlite'))
+    ;({ createCostCommand } = await import(source.href))
+  } catch (error) {
+    ambiental(
+      `pantheon_cost fixture runtime unavailable: ${error instanceof Error ? error.message : String(error)}`,
+    )
+    return
+  }
+
+  const root = mkdtempSync(join(tmpdir(), 'pantheon-cost-probe-'))
+  const dataHome = join(root, 'data')
+  const opencodeDir = join(dataHome, 'opencode')
+  const selectedDb = join(opencodeDir, requestedVersion === 'v2' ? 'opencode-v2.db' : 'opencode.db')
+  const otherDb = join(root, 'other.db')
+  const envDb = join(root, 'env.db')
+  const explicitDb = join(root, 'explicit.db')
+  const incompatibleDb = join(root, 'incompatible.db')
+  const checks = []
+
+  try {
+    mkdirSync(opencodeDir, { recursive: true })
+    // These rows intentionally include a monetary-looking field to prove it is
+    // ignored; only input/output/total tokens may appear in the report.
+    const selectedRows =
+      requestedVersion === 'v2'
+        ? [
+            {
+              role: 'assistant',
+              agent: 'aphrodite',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 7, output: 8 },
+            },
+            {
+              role: 'assistant',
+              agent: 'aphrodite',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 1, output: 2 },
+            },
+            {
+              role: 'assistant',
+              agent: 'zeus',
+              phase: 'audit',
+              cost: 999.99,
+              tokens: { input: 4, output: 6 },
+            },
+          ]
+        : [
+            {
+              role: 'assistant',
+              agent: 'hermes',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 10, output: 20 },
+            },
+            {
+              role: 'assistant',
+              agent: 'hermes',
+              phase: 'plan',
+              cost: 999.99,
+              tokens: { input: 3, output: 4 },
+            },
+            {
+              role: 'assistant',
+              agent: 'athena',
+              phase: 'review',
+              cost: 999.99,
+              tokens: { input: 2, output: 5 },
+            },
+          ]
+    createSyntheticDb(DatabaseSync, selectedDb, selectedRows)
+    createSyntheticDb(DatabaseSync, otherDb, [
+      {
+        role: 'assistant',
+        agent: 'wrong-version',
+        phase: 'other',
+        tokens: { input: 90, output: 90 },
+      },
+    ])
+    createSyntheticDb(DatabaseSync, envDb, [
+      { role: 'assistant', agent: 'env-agent', phase: 'override', tokens: { input: 1, output: 2 } },
+    ])
+    createSyntheticDb(DatabaseSync, explicitDb, [
+      {
+        role: 'assistant',
+        agent: 'explicit-agent',
+        phase: 'explicit',
+        tokens: { input: 9, output: 1 },
+      },
+    ])
+    createIncompatibleDb(DatabaseSync, incompatibleDb)
+
+    const restore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: undefined,
+    })
+    try {
+      const selectedOutput = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      assertTokensOnly(
+        selectedOutput,
+        requestedVersion === 'v2'
+          ? [
+              { agent: 'aphrodite', phase: 'plan', input: 8, output: 10, total: 18 },
+              { agent: 'zeus', phase: 'audit', input: 4, output: 6, total: 10 },
+            ]
+          : [
+              { agent: 'hermes', phase: 'plan', input: 13, output: 24, total: 37 },
+              { agent: 'athena', phase: 'review', input: 2, output: 5, total: 7 },
+            ],
+        requestedVersion === 'v2'
+          ? { input: 12, output: 16, total: 28 }
+          : { input: 15, output: 29, total: 44 },
+      )
+      checks.push('version-selected DB: PASS')
+    } finally {
+      restore()
+    }
+
+    const envRestore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: envDb,
+    })
+    try {
+      const output = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, '| env-agent | override | 1 | 2 | 3 |', 'PANTHEON_COST_DB')
+      if (output.includes('wrong-version') || output.includes('env-agent') === false) {
+        throw new Error('PANTHEON_COST_DB did not override the version-selected database')
+      }
+      checks.push('PANTHEON_COST_DB override: PASS')
+    } finally {
+      envRestore()
+    }
+
+    const explicitRestore = setEnvironment({
+      XDG_DATA_HOME: dataHome,
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: envDb,
+    })
+    try {
+      const output = await createCostCommand({ dbPath: explicitDb }).pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, '| explicit-agent | explicit | 9 | 1 | 10 |', 'explicit dbPath')
+      if (output.includes('env-agent')) throw new Error('explicit dbPath did not take precedence')
+      checks.push('explicit dbPath precedence: PASS')
+    } finally {
+      explicitRestore()
+    }
+
+    const missingRestore = setEnvironment({
+      XDG_DATA_HOME: join(root, 'missing-data'),
+      PANTHEON_OPENCODE_VERSION: requestedVersion,
+      PANTHEON_COST_DB: undefined,
+    })
+    try {
+      const output = await createCostCommand().pantheon_cost.execute(
+        {},
+        { sessionID: 'cost-probe' },
+      )
+      requireOutput(output, 'not found', 'missing DB')
+      requireOutput(
+        output,
+        requestedVersion === 'v2' ? 'opencode-v2.db' : 'opencode.db',
+        'selected missing DB path',
+      )
+      checks.push('missing DB: PASS')
+    } finally {
+      missingRestore()
+    }
+
+    const incompatibleOutput = await createCostCommand({
+      dbPath: incompatibleDb,
+    }).pantheon_cost.execute({}, { sessionID: 'cost-probe' })
+    requireOutput(incompatibleOutput, 'incompatible opencode.db schema', 'incompatible schema')
+    checks.push('incompatible schema: PASS')
+    emit('PASS', 'offline synthetic DB checks passed; no real DB was read', checks)
+  } catch (error) {
+    emit('FAIL', diagnostic(error), checks)
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+}
+
+await main()

package/scripts/release-beta-version.mjs

@@ -1,80 +1,76 @@
 #!/usr/bin/env node
-/** Compute and optionally apply the beta version for a release PR. */
+/**
+ * release-beta-version.mjs — beta version helpers.
+ *
+ * The beta version is committed in the manifests (package.json) and never
+ * computed at release time. `nextBetaVersion` advances the committed version:
+ *
+ *   X.Y.Z-beta.N  ->  X.Y.Z-beta.(N+1)     (stay on the current beta line)
+ *   X.Y.Z         ->  X.Y.(Z+1)-beta.1     (start a fresh beta line)
+ *
+ * `applyBetaVersion` writes an already-decided beta version into every
+ * manifest and is retained for recovery tooling. The legacy PR+SHA scheme
+ * (`X.Y.Z-beta.<pr>.<sha7>`) is accepted by validation for backward
+ * compatibility only; it is no longer generated.
+ */
 
-import { readFileSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { SEMVER_PATTERN, validateInventory, writeInventoryVersion } from './manifest-inventory.mjs'
 
-export const MANIFESTS = [
-  { file: 'package.json', kind: 'json' },
-  { file: 'pyproject.toml', kind: 'toml' },
-  { file: 'plugin.json', kind: 'json' },
-  { file: 'src/plugins/tui/package.json', kind: 'json' },
-]
-
-const STABLE = /^(\d+)\.(\d+)\.(\d+)$/
+const STABLE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+// Current committed sequential beta line.
+const BETA_LINE = /^(\d+\.\d+\.\d+)-beta\.(\d+)$/
+// Legacy PR+SHA beta scheme, accepted for recovery only.
+const LEGACY_BETA = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*\.[0-9a-f]{7}$/
+const BETA_RELEASE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)-beta\.[1-9]\d*$/
 
 export function nextStableVersion(latest, intent = 'patch') {
-  const match = STABLE.exec(String(latest))
-  if (!match) throw new Error(`npm latest is not a stable semver: "${latest}"`)
-  const [major, minor, patch] = match.slice(1).map(Number)
+  const match = STABLE.exec(String(latest).trim())
+  if (!match) throw new Error(`latest is not a stable semver: "${latest}"`)
   if (!['patch', 'minor', 'major'].includes(intent)) {
     throw new Error(`release intent must be patch, minor, or major: "${intent}"`)
   }
+  const [major, minor, patch] = match.slice(1).map(Number)
   if (intent === 'major') return `${major + 1}.0.0`
   if (intent === 'minor') return `${major}.${minor + 1}.0`
   return `${major}.${minor}.${patch + 1}`
 }
 
-export function betaVersion(latest, intent, pr, sha) {
-  if (!/^\d+$/.test(String(pr)) || Number(pr) < 1) throw new Error(`invalid PR number: "${pr}"`)
-  const shortSha = String(sha).slice(0, 7)
-  if (!/^[0-9a-f]{7,}$/i.test(shortSha)) throw new Error(`invalid commit SHA: "${sha}"`)
-  return `${nextStableVersion(latest, intent)}-beta.${pr}.${shortSha}`
-}
+/**
+ * Next beta version derived from the committed manifest version.
+ *
+ * @param {string} current committed version (e.g. "1.5.0-beta.2")
+ * @returns {string} the next sequential beta (e.g. "1.5.0-beta.3")
+ */
+export function nextBetaVersion(current) {
+  const value = String(current).trim()
+  const line = BETA_LINE.exec(value)
+  if (line) return `${line[1]}-beta.${Number(line[2]) + 1}`
 
-function writeVersion(root, { file, kind }, version) {
-  const path = join(root, file)
-  const raw = readFileSync(path, 'utf8')
-  if (kind === 'toml') {
-    const updated = raw.replace(/^(version\s*=\s*")[^"]+("\s*)$/m, `$1${version}$2`)
-    if (updated === raw) throw new Error(`no version field in ${file}`)
-    writeFileSync(path, updated)
-    return
-  }
-  const content = JSON.parse(raw)
-  content.version = version
-  writeFileSync(path, `${JSON.stringify(content, null, 2)}\n`)
-}
+  const stable = STABLE.exec(value)
+  if (stable) return `${nextStableVersion(value, 'patch')}-beta.1`
 
-export function applyBetaVersion(root, version) {
-  for (const manifest of MANIFESTS) writeVersion(root, manifest, version)
-  // Keep npm's lockfile metadata consistent without changing dependency data.
-  const lockPath = join(root, 'package-lock.json')
-  const lock = JSON.parse(readFileSync(lockPath, 'utf8'))
-  lock.version = version
-  if (lock.packages?.['']) lock.packages[''].version = version
-  writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`)
+  // Any other prerelease (e.g. 1.5.0-rc.1): beta the next patch of its base.
+  const base = /^(\d+\.\d+\.\d+)-[0-9A-Za-z.-]+$/.exec(value)
+  if (!base) throw new Error(`cannot derive a beta version from: "${current}"`)
+  return `${nextStableVersion(base[1], 'patch')}-beta.1`
 }
 
-const args = new Map(
-  process.argv.slice(2).map((arg) => {
-    const [key, ...value] = arg.split('=')
-    return [key.replace(/^--/, ''), value.join('=')]
-  }),
-)
-
-if (args.has('latest')) {
-  try {
-    const version = betaVersion(
-      args.get('latest'),
-      args.get('intent') || 'patch',
-      args.get('pr'),
-      args.get('sha'),
+function validateReleaseVersion(version) {
+  if (typeof version !== 'string' || !SEMVER_PATTERN.test(version)) {
+    throw new Error(`invalid release semver: "${version}"`)
+  }
+  if (!BETA_RELEASE.test(version) && !LEGACY_BETA.test(version)) {
+    throw new Error(
+      `release version must be <base>-beta.<N> or legacy <base>-beta.<pr>.<7-char-sha>: "${version}"`,
     )
-    if (args.has('apply')) applyBetaVersion(process.cwd(), version)
-    console.log(version)
-  } catch (error) {
-    console.error(`release-beta-version: ${error.message}`)
-    process.exit(1)
   }
 }
+
+/** Preflight all six entries, then update metadata only. */
+export function applyBetaVersion(root, version) {
+  validateReleaseVersion(version)
+  const inventory = validateInventory(root, { allowVersionDivergence: true })
+  writeInventoryVersion(inventory, version)
+  const after = validateInventory(root)
+  if (after.sourceVersion !== version) throw new Error('beta version post-write validation failed')
+}

package/scripts/sync-artifacts.mjs

@@ -0,0 +1,169 @@
+/**
+ * sync-artifacts.mjs — postinstall freshness sync for copy-only artifacts.
+ *
+ * Guarantees that an `npm install -g pantheon-opencode` (or npx cache
+ * refresh) brings an EXISTING installation up to date for everything that is
+ * a pure byte-compare copy: agents + routing.yml, skills, AGENTS.md,
+ * commands, the runtime MCP scripts, the code-mode payload and tiers.json.
+ *
+ * Deliberately NOT done here (they belong to `pantheon-opencode init` /
+ * `update`, which the doctor points at when versions drift):
+ *   - opencode.json merge (config keys, plugin registration, MCP entries)
+ *   - venv/pip setup
+ *   - tui.json registration changes
+ *
+ * The user's opencode.json already references the installed package root for
+ * plugins, so after a package update those references hit the NEW code
+ * automatically; this sync refreshes the COPIES that would otherwise stay
+ * stale until the next manual init.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  collectSkillNames,
+  copyFiles,
+  installSkills,
+  ROOT,
+  syncDir,
+  writeIfChanged,
+} from './install/shared.mjs'
+
+/** Canonical MCP script sources — mirrors installOpenCode phase 2.10. */
+const MCP_SCRIPTS = {
+  'mcp_resources_server.py': () => join(ROOT, 'src', 'mcp', 'mcp_resources_server.py'),
+  'code_mode_server.py': () => join(ROOT, 'src', 'mcp', 'code_mode_server.py'),
+  'memory_mcp_server.py': () => join(ROOT, 'src', 'mcp', 'memory_mcp_server.py'),
+  'mcp_persistence_server.py': () => join(ROOT, 'src', 'mcp', 'mcp_persistence_server.py'),
+  '_pantheon_paths.py': () => join(ROOT, 'src', 'mcp', '_pantheon_paths.py'),
+  'mcp_codemap_module.py': () => join(ROOT, 'src', 'mcp', 'mcp_codemap_module.py'),
+  'pantheon_vision_server.py': () => join(ROOT, 'src', 'mcp', 'pantheon_vision_server.py'),
+  'eval_store.py': () => join(ROOT, 'src', 'mcp', 'eval_store.py'),
+  'scrub-secrets.py': () => join(ROOT, 'scripts', 'scrub-secrets.py'),
+}
+
+/**
+ * Sync all copy-only artifacts from the installed package into configDir
+ * (the GLOBAL OpenCode config dir). Byte-compare idempotent; never throws.
+ * @returns {{ created: number, skipped: number, errors: string[] }}
+ */
+export function syncCopyArtifacts(configDir) {
+  const result = { created: 0, skipped: 0, errors: [] }
+  const bump = (r) => {
+    result.created += r.created
+    result.skipped += r.skipped
+  }
+
+  // ── agents + routing.yml ──
+  try {
+    const dstAgents = join(configDir, 'agents')
+    if (existsSync(join(ROOT, 'src', 'agents'))) {
+      mkdirSync(dstAgents, { recursive: true })
+      bump(copyFiles(join(ROOT, 'src', 'agents'), dstAgents, false))
+      const routing = join(ROOT, 'src', 'routing.yml')
+      if (existsSync(routing)) {
+        if (
+          writeIfChanged(join(configDir, 'routing.yml'), readFileSync(routing, 'utf8'), false) ===
+          'created'
+        ) {
+          result.created++
+        } else result.skipped++
+      }
+    }
+  } catch (err) {
+    result.errors.push(`agents: ${err.message}`)
+  }
+
+  // ── skills ──
+  try {
+    const names = collectSkillNames()
+    if (names.length > 0) bump(installSkills(names, configDir, false, ''))
+  } catch (err) {
+    result.errors.push(`skills: ${err.message}`)
+  }
+
+  // ── instructions (AGENTS.md) ──
+  try {
+    const src = join(ROOT, 'AGENTS.md')
+    if (existsSync(src)) {
+      if (
+        writeIfChanged(join(configDir, 'AGENTS.md'), readFileSync(src, 'utf8'), false) === 'created'
+      ) {
+        result.created++
+      } else result.skipped++
+    }
+  } catch (err) {
+    result.errors.push(`instructions: ${err.message}`)
+  }
+
+  // ── commands (*.md) ──
+  try {
+    const srcCmds = join(ROOT, 'commands')
+    if (existsSync(srcCmds)) {
+      bump(syncDir(srcCmds, join(configDir, 'commands'), false, false, (f) => f.endsWith('.md')))
+    }
+  } catch (err) {
+    result.errors.push(`commands: ${err.message}`)
+  }
+
+  // ── runtime payload (MCP scripts, code-mode, tiers) ──
+  try {
+    const dstScripts = join(configDir, 'scripts')
+    mkdirSync(dstScripts, { recursive: true })
+    for (const [name, srcFn] of Object.entries(MCP_SCRIPTS)) {
+      const src = srcFn()
+      if (!existsSync(src)) continue
+      const content = readFileSync(src, 'utf8')
+      const dst = join(dstScripts, name)
+      if (writeIfChanged(dst, content, false) === 'created') {
+        statSync(dst)
+        result.created++
+      } else result.skipped++
+    }
+
+    const req = join(ROOT, 'src', 'mcp', 'requirements-vision.txt')
+    if (existsSync(req)) {
+      if (
+        writeIfChanged(
+          join(configDir, 'requirements-vision.txt'),
+          readFileSync(req, 'utf8'),
+          false,
+        ) === 'created'
+      ) {
+        result.created++
+      } else result.skipped++
+    }
+
+    const srcCodeMode = join(ROOT, '.pantheon', 'code-mode')
+    const dstCodeMode = join(configDir, '.pantheon', 'code-mode')
+    if (existsSync(srcCodeMode)) {
+      bump(syncDir(srcCodeMode, dstCodeMode, false, false))
+    }
+
+    const srcTiers = join(ROOT, '.pantheon', 'tiers.json')
+    const dstTiers = join(configDir, '.pantheon', 'tiers.json')
+    if (existsSync(srcTiers)) {
+      if (writeIfChanged(dstTiers, readFileSync(srcTiers, 'utf8'), false) === 'created')
+        result.created++
+      else result.skipped++
+    }
+  } catch (err) {
+    result.errors.push(`runtime: ${err.message}`)
+  }
+
+  return result
+}
+
+/** Drop stale entries in dst that no longer exist in src (agents/skills dirs). */
+export function pruneMissing(srcDir, dstDir) {
+  if (!existsSync(srcDir) || !existsSync(dstDir)) return 0
+  const src = new Set(readdirSync(srcDir))
+  let removed = 0
+  for (const entry of readdirSync(dstDir)) {
+    if (!src.has(entry)) {
+      rmSync(join(dstDir, entry), { recursive: true, force: true })
+      removed++
+    }
+  }
+  return removed
+}