@plainconceptsplatform/agent-harness 2.0.0

package/src/steps/copy/agents.js

@@ -0,0 +1,118 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { info, success, warn } from '../../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const agentsContent = await fse.readJson(path.resolve(__dirname, '../../presets/agents-content.json'))
+
+// Steps are matched by their title text, not by exact heading string:
+// heading level (###/####) and step numbers have drifted before and silently
+// broke removal. Matching `^#{3,4} Step N, <title>` survives both.
+const HISTORY_STEP_TITLE = 'Archive project history'
+const CHAIN_STEP_TITLE = 'Chain make commands'
+
+const CHAIN_CONFIRM_LINE = '- ARCHITECTURE.md generated'
+
+function stepHeadingPattern(title) {
+  const escaped = title.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  return new RegExp(`^#{2,4} Step \\d+, ${escaped}`)
+}
+
+// The step heading is kept and its body replaced with an explicit skip note.
+// Removing the block and renumbering the remaining steps (the old approach)
+// went stale against prose cross-references like "Skip steps 2, 3, and 4";
+// stable numbering plus a visible reason is unambiguous for the agent.
+export function skipStepBlock(content, title, note) {
+  const lines = content.split('\n')
+  const pattern = stepHeadingPattern(title)
+  const start = lines.findIndex(l => pattern.test(l.trim()))
+  if (start === -1) return { content, matched: false }
+
+  let end = lines.length
+  for (let i = start + 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { end = i; break }
+  }
+
+  lines.splice(start + 1, end - start - 1, '', `> ${note}`, '')
+  return { content: lines.join('\n'), matched: true }
+}
+
+function removeConfirmLine(content, line) {
+  return content.split('\n').filter(l => l.trim() !== line.trim()).join('\n')
+}
+
+const PLATFORM_WORKFLOW_START = '<!-- PC-PLATFORM-WORKFLOW-START -->'
+const PLATFORM_WORKFLOW_END = '<!-- PC-PLATFORM-WORKFLOW-END -->'
+const PLATFORM_SKILLS_GUIDE_START = '<!-- PC-PLATFORM-SKILLS-GUIDE-START -->'
+const PLATFORM_SKILLS_GUIDE_END = '<!-- PC-PLATFORM-SKILLS-GUIDE-END -->'
+
+function platformContent(platform, key) {
+  const p = agentsContent.platform[platform] ?? agentsContent.platform.github
+  return p[key] ?? ''
+}
+
+function mixedPlatformContent(backlogPlatform, repoPlatform, key) {
+  if (backlogPlatform === repoPlatform) {
+    return platformContent(backlogPlatform, key)
+  }
+  const backlog = agentsContent.platform[backlogPlatform] ?? agentsContent.platform.github
+  const repo = agentsContent.platform[repoPlatform] ?? agentsContent.platform.github
+  const mixed = agentsContent.platform.mixed ?? {}
+  const mixedKey = `${backlogPlatform}-${repoPlatform}`
+  return mixed[mixedKey]?.[key] ?? mixed.default?.[key]?.replace('{backlog}', backlog[key] ?? '').replace('{repo}', repo[key] ?? '') ?? platformContent(repoPlatform, key)
+}
+
+function replaceBetween(content, start, end, replacement) {
+  if (!content.includes(start) || !content.includes(end)) return content
+  const pattern = new RegExp(`${start}[\\s\\S]*?${end}`)
+  return content.replace(pattern, `${start}\n${replacement.trim()}\n${end}`)
+}
+
+export async function patchAgentsMd(ctx) {
+  const obInitSkillPath = path.join(process.cwd(), '.agents', 'skills', 'pc-repo-initialize', 'SKILL.md')
+  if (!await fse.pathExists(obInitSkillPath)) return
+
+  let content = await fse.readFile(obInitSkillPath, 'utf-8')
+  const patches = []
+
+  const skips = [
+    [ctx.hasOpenspec, HISTORY_STEP_TITLE, null,
+      'Skipped during onboarding: this project already had an openspec/ history. Do not archive again; continue with the next step.'],
+    [ctx.hasDesign || ctx.hasArchitecture, CHAIN_STEP_TITLE, CHAIN_CONFIRM_LINE,
+      'Skipped during onboarding: project files already exist. Run /make-architecture or /make-design individually to regenerate.'],
+  ]
+
+  for (const [enabled, title, confirmLine, note] of skips) {
+    if (!enabled) continue
+    const result = skipStepBlock(content, title, note)
+    if (!result.matched) {
+      warn(`pc-repo-initialize SKILL.md step "${title}" not found: template drift? Skipping this patch.`)
+      continue
+    }
+    content = result.content
+    if (confirmLine) content = removeConfirmLine(content, confirmLine)
+    patches.push(`Step "${title}" marked as skipped, file already exists`)
+  }
+
+  if (patches.length > 0) {
+    await fse.writeFile(obInitSkillPath, content, 'utf-8')
+    for (const msg of patches) info(msg)
+    success('pc-repo-initialize SKILL.md patched for existing project state')
+  }
+}
+
+export async function patchAgentGuidance(backlogPlatform, repoPlatform, cwd = process.cwd()) {
+  const agentsMdPath = path.join(cwd, 'AGENTS.md')
+  if (await fse.pathExists(agentsMdPath)) {
+    const repo = repoPlatform ?? backlogPlatform ?? 'github'
+    let content = await fse.readFile(agentsMdPath, 'utf-8')
+    content = replaceBetween(content, PLATFORM_WORKFLOW_START, PLATFORM_WORKFLOW_END, mixedPlatformContent(backlogPlatform, repo, 'workflow'))
+    content = replaceBetween(content, PLATFORM_SKILLS_GUIDE_START, PLATFORM_SKILLS_GUIDE_END, mixedPlatformContent(backlogPlatform, repo, 'skillsGuide'))
+    await fse.writeFile(agentsMdPath, `${content.replace(/\s*$/, '')}\n`, 'utf-8')
+    const label = backlogPlatform === repo ? repo : `${backlogPlatform}→${repo}`
+    success(`AGENTS.md patched for platform workflow: ${label}`)
+  }
+}
+
+

package/src/steps/copy/commands.js

@@ -0,0 +1,91 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { success } from '../../utils/exec.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const _archive = {
+  azure: await fse.readFile(path.resolve(__dirname, '../../fragments/archive/az.md'), 'utf-8'),
+  github: await fse.readFile(path.resolve(__dirname, '../../fragments/archive/gh.md'), 'utf-8'),
+  gitlab: await fse.readFile(path.resolve(__dirname, '../../fragments/archive/gl.md'), 'utf-8'),
+  none: await fse.readFile(path.resolve(__dirname, '../../fragments/archive/none.md'), 'utf-8'),
+}
+
+const _ship = {
+  github: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-ship/gh.md'), 'utf-8'),
+  azure: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-ship/az.md'), 'utf-8'),
+  gitlab: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-ship/gl.md'), 'utf-8'),
+}
+
+const _review = {
+  github: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-review/gh.md'), 'utf-8'),
+  azure: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-review/az.md'), 'utf-8'),
+  gitlab: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-review/gl.md'), 'utf-8'),
+}
+
+const _backlog = {
+  github: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-backlog/gh.md'), 'utf-8'),
+  azure: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-backlog/az.md'), 'utf-8'),
+  jira: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-backlog/jira.md'), 'utf-8'),
+}
+
+// Evidence comments target the backlog platform (where the issue/work-item lives).
+const _evidence = {
+  github: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-evidence/gh.md'), 'utf-8'),
+  azure: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-evidence/az.md'), 'utf-8'),
+  jira: await fse.readFile(path.resolve(__dirname, '../../fragments/ops-evidence/jira.md'), 'utf-8'),
+}
+
+// relativePath is POSIX-style relative to the project root; commands live in
+// .opencode/commands/, skill-backed procedures (plan-archive, ops-ship) in
+// .agents/skills/<name>/SKILL.md.
+function patchFile(relativePath, startMarker, endMarker, content, platform, cwd = process.cwd()) {
+  const targetPath = path.join(cwd, ...relativePath.split('/'))
+  if (!fse.pathExistsSync(targetPath)) return
+
+  let fileContent = fse.readFileSync(targetPath, 'utf-8')
+  if (!fileContent.includes(startMarker) || !fileContent.includes(endMarker)) return
+
+  const pattern = new RegExp(`${startMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?${endMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`)
+  fileContent = fileContent.replace(pattern, `${startMarker}\n${content.trim()}\n${endMarker}`)
+  fse.writeFileSync(targetPath, `${fileContent.replace(/\s*$/, '')}\n`, 'utf-8')
+  success(`${relativePath} content injected for platform: ${platform}`)
+}
+
+export async function patchArchiveCommand(platform, cwd = process.cwd()) {
+  const repoPlatform = typeof platform === 'object' ? (platform.repoPlatform ?? platform.backlogPlatform ?? 'github') : platform
+  const replacement = _archive[repoPlatform]
+  if (!replacement) return
+  patchFile('.agents/skills/pc-plan-archive/SKILL.md', '<!-- PC-PLATFORM-ARCHIVE-START -->', '<!-- PC-PLATFORM-ARCHIVE-END -->', replacement, repoPlatform, cwd)
+}
+
+export async function patchOpsShip(platform, cwd = process.cwd()) {
+  const repoPlatform = typeof platform === 'object' ? (platform.repoPlatform ?? 'github') : platform
+  const replacement = _ship[repoPlatform]
+  if (!replacement) return
+  patchFile('.agents/skills/pc-ops-ship/SKILL.md', '<!-- PC-PLATFORM-SHIP-START -->', '<!-- PC-PLATFORM-SHIP-END -->', replacement, repoPlatform, cwd)
+}
+
+export async function patchOpsReview(platform, cwd = process.cwd()) {
+  const repoPlatform = typeof platform === 'object' ? (platform.repoPlatform ?? 'github') : platform
+  const replacement = _review[repoPlatform]
+  if (!replacement) return
+  patchFile('.opencode/commands/ops-review.md', '<!-- PC-PLATFORM-REVIEW-START -->', '<!-- PC-PLATFORM-REVIEW-END -->', replacement, repoPlatform, cwd)
+}
+
+export async function patchOpsBacklog(platform, cwd = process.cwd()) {
+  const backlogPlatform = typeof platform === 'object' ? (platform.backlogPlatform ?? 'github') : platform
+  const replacement = _backlog[backlogPlatform]
+  if (!replacement) return
+  patchFile('.opencode/commands/ops-backlog.md', '<!-- PC-PLATFORM-BACKLOG-START -->', '<!-- PC-PLATFORM-BACKLOG-END -->', replacement, backlogPlatform, cwd)
+}
+
+export async function patchOpsEvidence(platform, cwd = process.cwd()) {
+  const backlogPlatform = typeof platform === 'object' ? (platform.backlogPlatform ?? 'github') : platform
+  const replacement = _evidence[backlogPlatform]
+  // browser/none have no CLI to post with: leave the markers empty (the skill skips commenting).
+  if (!replacement) return
+  patchFile('.agents/skills/pc-ops-evidence/SKILL.md', '<!-- PC-PLATFORM-EVIDENCE-START -->', '<!-- PC-PLATFORM-EVIDENCE-END -->', replacement, backlogPlatform, cwd)
+}
+

package/src/steps/copy/fullstack-engineer.js

@@ -0,0 +1,83 @@
+import fse from 'fs-extra'
+import path from 'path'
+import { success } from '../../utils/exec.js'
+
+const FULLSTACK_FILE = 'fullstack-engineer.md'
+const FULLSTACK_DESCRIPTION = 'Default engineer that accumulates skills from all created persona engineers. Use as fallback when no specialist matches: but prefer spawning a specific engineer for deterministic results.'
+const FULLSTACK_IDENTITY = 'You are the default engineer, mostly used by the user for architecture and planning. You are more complete but less accurate than specialized engineers, prefer spawning a specialist when one matches the task domain.'
+
+// The reminder plugin owns ability bootstrap. Remove the old prompt-level
+// directive when regenerating so it cannot duplicate the plugin reminder.
+function stripStartupDirective(text) {
+  if (!text) return text
+  return text
+    .split(/\r?\n\r?\n+/)
+    .filter(paragraph => !paragraph.trim().startsWith('**Startup'))
+    .join('\n\n')
+    .trim()
+}
+
+export async function removeLegacyStartupDirectives({ cwd = process.cwd() } = {}) {
+  const agentsDir = path.join(cwd, '.opencode', 'agents')
+  if (!await fse.pathExists(agentsDir)) return 0
+
+  let updated = 0
+  for (const fileName of await fse.readdir(agentsDir)) {
+    if (!fileName.endsWith('.md')) continue
+    const filePath = path.join(agentsDir, fileName)
+    const content = await fse.readFile(filePath, 'utf-8')
+    const cleaned = stripStartupDirective(content)
+    if (cleaned === content.trim()) continue
+    await fse.writeFile(filePath, `${cleaned}\n`, 'utf-8')
+    updated++
+  }
+  return updated
+}
+
+export async function generateFullstackEngineer({ cwd = process.cwd(), updateMode = false } = {}) {
+  const agentsDir = path.join(cwd, '.opencode', 'agents')
+  await fse.ensureDir(agentsDir)
+  const filePath = path.join(agentsDir, FULLSTACK_FILE)
+
+  if (updateMode && await fse.pathExists(filePath)) {
+    return { generated: false, preserved: true }
+  }
+
+  let existingAbilities = null
+  let existingIdentity = null
+  if (await fse.pathExists(filePath)) {
+    const content = await fse.readFile(filePath, 'utf-8')
+    const abilitiesMatch = content.match(/## Abilities\n([\s\S]*?)$/)
+    if (abilitiesMatch) existingAbilities = abilitiesMatch[1].trim()
+    const identityMatch = content.match(/^---\n[\s\S]*?\n---\n\n(.*?)(?:\n\n## Abilities)/s)
+    if (identityMatch) existingIdentity = stripStartupDirective(identityMatch[1])
+  }
+
+  const frontmatter = [
+    '---',
+    `description: ${FULLSTACK_DESCRIPTION}`,
+    'mode: primary',
+    'color: warning',
+    'permission:',
+    '  edit: allow',
+    '  bash: allow',
+    '  read: allow',
+    '  glob: allow',
+    '  grep: allow',
+    '  question: allow',
+    '  todowrite: allow',
+    '---',
+  ]
+
+  const identity = existingIdentity ?? FULLSTACK_IDENTITY
+
+  const abilities = existingAbilities ?? [
+    '- Guardrails: @pc-guardrails-generic, @pc-guardrails-project',
+  ].join('\n')
+
+  const content = `${frontmatter.join('\n')}\n\n${identity}\n\n## Abilities\n${abilities}\n`
+
+  await fse.writeFile(filePath, content, 'utf-8')
+  success(`Generated ${FULLSTACK_FILE}`)
+  return { generated: true }
+}

package/src/steps/copy/index.js

@@ -0,0 +1,88 @@
+import fse from "fs-extra"
+import path from "path"
+import { fileURLToPath } from "url"
+import { copyContent, recordManagedContent } from "../../utils/copy.js"
+import { error, header, success } from "../../utils/exec.js"
+import { exit } from "../../utils/process.js"
+import { patchAgentGuidance, patchAgentsMd } from "./agents.js"
+import { patchArchiveCommand, patchOpsShip, patchOpsReview, patchOpsBacklog, patchOpsEvidence } from "./commands.js"
+import { installSkills } from "./skills.js"
+import { generateFullstackEngineer, removeLegacyStartupDirectives } from "./fullstack-engineer.js"
+import { patchOpencodeJson, patchOpencodePackage } from "./opencode-json.js"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CONTENT_DIR = path.resolve(__dirname, "../../content")
+
+export async function copyContentStep(platform, ctx = {}) {
+  header("Step 5, Copying agent-harness files")
+
+  const dest = process.cwd()
+
+  // Support both old single-string platform and new { backlogPlatform, repoPlatform }
+  const backlogPlatform = typeof platform === 'object' ? platform.backlogPlatform : platform
+  const repoPlatform = typeof platform === 'object' ? platform.repoPlatform : platform
+
+  try {
+    await copyContent(CONTENT_DIR, dest, platform, ctx)
+
+    // .gitignore is stripped by npm during publish, so the source file is _gitignore.
+    // Also, fse.copy with overwrite:false won't overwrite an existing .gitignore,
+    // so merge manually to preserve both opencode's defaults and our additions.
+    const srcGitignore = path.join(CONTENT_DIR, ".opencode", "_gitignore")
+    const destGitignore = path.join(dest, ".opencode", ".gitignore")
+    if (await fse.pathExists(srcGitignore)) {
+      const srcLines = (await fse.readFile(srcGitignore, "utf-8")).split("\n").map(l => l.trim()).filter(Boolean)
+      const destLines = (await fse.pathExists(destGitignore))
+        ? (await fse.readFile(destGitignore, "utf-8")).split("\n").map(l => l.trim()).filter(Boolean)
+        : []
+      const merged = Array.from(new Set([...destLines, ...srcLines]))
+      await fse.writeFile(destGitignore, `${merged.join("\n")}\n`, "utf-8")
+    }
+
+    // Remove the _gitignore template from dest: it was only needed for the merge above.
+    const destGitignoreTemplate = path.join(dest, ".opencode", "_gitignore")
+    if (await fse.pathExists(destGitignoreTemplate)) {
+      await fse.remove(destGitignoreTemplate)
+    }
+
+    const rootsFile = path.join(dest, ".opencode", "source-roots.json")
+    if (!ctx.updateMode || !await fse.pathExists(rootsFile)) {
+      await fse.writeJson(
+        rootsFile,
+        {
+          mode: ctx.sourceMode || "current",
+          // An empty array is truthy, so `|| [dest]` never kicked in and reruns
+          // wrote `roots: []`, leaving agents with no source scope.
+          roots: ctx.sourceRoots?.length ? ctx.sourceRoots : [dest],
+        },
+        { spaces: 2 },
+      )
+    }
+
+    await patchAgentGuidance(backlogPlatform, repoPlatform)
+    await patchOpsReview({ backlogPlatform, repoPlatform })
+    await patchOpsBacklog({ backlogPlatform, repoPlatform })
+    await patchOpencodeJson()
+    await patchOpencodePackage()
+    if (!ctx.updateMode) await patchAgentsMd(ctx)
+
+    if (!ctx.skipSkills) {
+      await installSkills(backlogPlatform, repoPlatform, {
+        forceOverwrite: ctx.forceOverwrite,
+        updateMode: ctx.updateMode,
+      })
+    }
+    // These patch SKILL.md files (pc-plan-archive, pc-ops-ship, pc-ops-evidence),
+    // so they must run after installSkills has copied the skills into the project.
+    await patchArchiveCommand({ backlogPlatform, repoPlatform })
+    await patchOpsShip({ backlogPlatform, repoPlatform })
+    await patchOpsEvidence({ backlogPlatform, repoPlatform })
+    await generateFullstackEngineer({ updateMode: ctx.updateMode })
+    await removeLegacyStartupDirectives()
+    await recordManagedContent(CONTENT_DIR, dest, { updateMode: ctx.updateMode })
+    success("Files copied to project root")
+  } catch (err) {
+    error(`Failed to copy content: ${err.message}`)
+    exit(1)
+  }
+}

package/src/steps/copy/opencode-json.js

@@ -0,0 +1,129 @@
+import fse from 'fs-extra'
+import { applyEdits, modify, parse } from 'jsonc-parser'
+import path from 'node:path'
+import { success } from '../../utils/exec.js'
+
+// The reminder plugin loads every agent ability before work, including
+// user-installed skills outside the pc-* and openspec-* namespaces.
+const SHARED_PERMISSIONS = [
+  ['question', 'allow'],
+  ['todowrite', 'allow'],
+]
+
+function applyModify(text, jsonPath, value) {
+  const edits = modify(text, jsonPath, value, {
+    formattingOptions: { insertSpaces: true, tabSize: 2 },
+  })
+  return applyEdits(text, edits)
+}
+
+export async function patchOpencodeJson(cwd = process.cwd()) {
+  const opencodePath = path.join(cwd, 'opencode.jsonc')
+
+  let text
+  if (await fse.pathExists(opencodePath)) {
+    text = await fse.readFile(opencodePath, 'utf-8')
+  } else {
+    text = JSON.stringify({ $schema: 'https://opencode.ai/config.json' }, null, 2)
+  }
+
+  const errors = []
+  const parsed = parse(text, errors)
+  if (errors.length > 0 || typeof parsed !== 'object') {
+    return { patched: false, reason: 'parse error' }
+  }
+
+  const needsAgentDisable = !(
+    parsed?.agent?.build?.disable === true &&
+    parsed?.agent?.plan?.disable === true
+  )
+  const needsSkillPermission = parsed?.permission?.skill !== 'allow'
+  const missingSharedPermissions = SHARED_PERMISSIONS.filter(
+    ([key, value]) => parsed?.permission?.[key] !== value,
+  )
+  // opencode only scans .opencode/skills/ by default, but we install to .agents/skills/
+  const needsSkillsPaths = !(
+    Array.isArray(parsed?.skills?.paths) &&
+    parsed.skills.paths.includes('.agents/skills')
+  )
+  const needsCompaction = !(
+    parsed?.compaction?.auto === true &&
+    parsed?.compaction?.prune === true
+  )
+
+  if (!needsAgentDisable && !needsSkillPermission && missingSharedPermissions.length === 0 && !needsSkillsPaths && !needsCompaction) {
+    return { patched: false }
+  }
+
+  // Apply edits sequentially so offsets stay correct
+  if (needsAgentDisable) {
+    text = applyModify(text, ['agent', 'build', 'disable'], true)
+    text = applyModify(text, ['agent', 'plan', 'disable'], true)
+  }
+  if (needsSkillPermission) text = applyModify(text, ['permission', 'skill'], 'allow')
+  for (const [key, value] of missingSharedPermissions) {
+    text = applyModify(text, ['permission', key], value)
+  }
+
+  // Ensure .agents/skills is in skills.paths so opencode discovers installed skills
+  if (needsSkillsPaths) {
+    const existingPaths = Array.isArray(parsed?.skills?.paths) ? parsed.skills.paths : []
+    if (!existingPaths.includes('.agents/skills')) {
+      const updatedPaths = [...existingPaths, '.agents/skills']
+      text = applyModify(text, ['skills', 'paths'], updatedPaths)
+    }
+  }
+
+  // Enable context pruning to reduce token costs in long agent sessions
+  if (needsCompaction) {
+    text = applyModify(text, ['compaction', 'auto'], true)
+    text = applyModify(text, ['compaction', 'prune'], true)
+    text = applyModify(text, ['compaction', 'reserved'], 10000)
+  }
+
+  await fse.writeFile(opencodePath, text, 'utf-8')
+  if (needsAgentDisable) {
+    success('Disabled built-in build/plan agents in opencode.jsonc')
+  }
+  if (needsSkillPermission) {
+    success('Allowed skill loading in opencode.jsonc')
+  }
+  if (missingSharedPermissions.length > 0) {
+    success('Allowed question/todowrite tools in opencode.jsonc')
+  }
+  if (needsSkillsPaths) {
+    success('Added .agents/skills to skills.paths in opencode.jsonc')
+  }
+  if (needsCompaction) {
+    success('Enabled context pruning (compaction.prune) in opencode.jsonc')
+  }
+
+  return { patched: true }
+}
+
+const OPENCODE_PACKAGE_DEPENDENCIES = {
+  '@opencode-ai/plugin': '1.18.19',
+  '@opentui/core': '0.5.6',
+  '@opentui/solid': '0.5.6',
+  'solid-js': '1.9.12',
+}
+
+export async function patchOpencodePackage(cwd = process.cwd()) {
+  const packagePath = path.join(cwd, '.opencode', 'package.json')
+  if (!await fse.pathExists(packagePath)) return { patched: false }
+
+  const packageJson = await fse.readJson(packagePath).catch(() => null)
+  if (!packageJson?.dependencies) return { patched: false }
+
+  let patched = false
+  for (const [name, version] of Object.entries(OPENCODE_PACKAGE_DEPENDENCIES)) {
+    if (!(name in packageJson.dependencies) || packageJson.dependencies[name] === version) continue
+    packageJson.dependencies[name] = version
+    patched = true
+  }
+  if (!patched) return { patched: false }
+
+  await fse.writeJson(packagePath, packageJson, { spaces: 2 })
+  success('Updated OpenCode plugin dependencies in .opencode/package.json')
+  return { patched: true }
+}