oh-my-opencode 4.5.1 → 4.6.0

package/packages/shared-skills/skills/start-work/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: start-work
+description: "Execute a Prometheus work plan in Codex with Boulder state, evidence ledger updates, worktree discipline, parallel subagents, and Stop-hook continuation. Use after planning when the user says start work, execute plan, continue plan, resume plan, or asks to run a .omo/plans plan."
+---
+
+## Codex Harness Tool Compatibility
+
+This skill ports the OpenCode `/start-work` flow onto Codex. Any OpenCode-only tool name in an inherited example must be translated to its Codex equivalent:
+
+| OpenCode example | Codex tool to use |
+| --- | --- |
+| `task(subagent_type="explore", ...)` | `spawn_agent(agent_type="explorer", task_name="...", message="...")` |
+| `task(subagent_type="librarian", ...)` | `spawn_agent(agent_type="librarian", task_name="...", message="...")` |
+| `task(subagent_type="plan", ...)` | `spawn_agent(agent_type="plan", task_name="...", message="...")` |
+| `task(subagent_type="oracle", ...)` for final verification | `spawn_agent(agent_type="codex-ultrawork-reviewer", task_name="...", message="...")` |
+| `task(category="...", ...)` for implementation or QA | `spawn_agent(agent_type="worker", task_name="...", message="...")` |
+| `background_output(task_id="...")` | `wait_agent(...)` |
+| `dispatchInternalPrompt(...)` | the `Stop` hook emits `{"decision":"block","reason":"<prompt>"}` automatically; see Continuation |
+| `team_*(...)` | `spawn_agent` + `send_message` + `followup_task` + `wait_agent` + `close_agent` |
+
+When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.
+
+## Codex Subagent Reliability
+
+Every `spawn_agent` message must be self-contained. Start with
+`TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
+`VERIFY`. State that it is an executable assignment, not a context
+handoff. Role selection requires `agent_type`; `model` +
+`reasoning_effort` alone creates a default agent, not a reviewer or
+worker. Prefer `fork_turns: "none"` unless full history is truly
+required; paste only the context the child needs.
+
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles. Never use a single long blocking wait for them.
+
+Use `wait_agent` for completion signals, but treat `wait_agent` as a
+mailbox signal, not proof of completion, content, or errors. After two
+waits with no substantive result, send one targeted followup:
+`TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>`. If the
+child stays silent or ack-only, record the result as inconclusive, do
+not count it as pass/review approval, close if safe, and respawn a
+smaller `fork_turns: "none"` task with the missing deliverable.
+
+# start-work
+
+Execute a Prometheus work plan until every top-level checkbox is complete. This skill pairs with the Codex `Stop` / `SubagentStop` continuation hook in `components/start-work-continuation`, which re-injects the next turn while `.omo/boulder.json` says the current `codex:<session_id>` still has unchecked plan work.
+
+## Usage
+
+```text
+$start-work [plan-name] [--worktree <absolute-path>]
+```
+
+- `plan-name` is optional. It may be a full or partial file stem under `.omo/plans/`.
+- `--worktree` is optional. Use it only when the user explicitly asks to work in a separate git worktree.
+
+## Phase 1: Select the plan
+
+1. Read `.omo/boulder.json` if it exists.
+2. List Prometheus plan files under `.omo/plans/`.
+3. If `plan-name` was provided, select the matching plan.
+4. If exactly one active or paused Boulder work exists for this session, resume it.
+5. If no active work exists and exactly one plan exists, select it.
+6. If multiple plans remain possible, ask one focused selection question.
+
+## Phase 2: Create or update Boulder state
+
+Write `.omo/boulder.json` before implementation starts. Session ids must be prefixed with `codex:` so the continuation hook can identify its own session.
+
+```json
+{
+  "schema_version": 2,
+  "active_work_id": "<work-id>",
+  "works": {
+    "<work-id>": {
+      "work_id": "<work-id>",
+      "active_plan": ".omo/plans/<plan-name>.md",
+      "plan_name": "<plan-name>",
+      "session_ids": ["codex:<session_id>"],
+      "status": "active",
+      "worktree_path": null
+    }
+  }
+}
+```
+
+If `--worktree` is set, verify the path with `git worktree list --porcelain` or create it with `git worktree add <path> <branch-or-HEAD>`, then store the absolute path as `worktree_path`. All edits, commands, tests, and evidence capture must run inside that worktree.
+
+## Phase 3: Execute the next checkbox
+
+1. Read the full selected plan.
+2. Find the first unchecked column-0 checkbox in `## TODOs` or `## Final Verification Wave`.
+3. Ignore nested checkboxes under acceptance criteria, evidence, and definition-of-done sections.
+4. Decompose that checkbox into atomic sub-tasks.
+5. Dispatch independent sub-tasks in parallel with `spawn_agent`; serialize only when one sub-task has a named dependency on another.
+
+Each sub-task message must include:
+
+1. Goal and exact files or directories in scope.
+2. When the task touches existing behavior: a baseline characterization test, written first, that asserts current observable behavior and passes on the unchanged code. Then the red test or failing reproduction for the new behavior before production changes. Pin the baseline as rigorously as the new test: exact inputs, exact observable, exact assertion.
+3. Implementation constraints from the plan and project rules.
+4. Automated verification commands to run.
+5. One Manual-QA channel, named with the exact tool and exact invocation (the literal `curl`, `send-keys`, `page.click`, payload, selectors, and the binary observable that decides PASS/FAIL), not "verify it works":
+   - HTTP call: `curl -i` against the live endpoint.
+   - tmux: a `tmux` session driven with `send-keys`, dumped via `capture-pane`.
+   - Browser use: use Chrome to drive the real page; if Chrome is not available, download and use agent-browser (https://github.com/vercel-labs/agent-browser).
+   - Computer use: OS-level GUI automation against the running desktop app when the surface is not a page.
+6. The adversarial classes that apply to this sub-task (from the 9 ultraqa classes) and how each is probed.
+7. Required artifact path and cleanup receipt.
+
+Apply ultraqa's 9 adversarial classes where relevant to each checkbox: malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions. A checkbox whose behavior is user-visible MUST probe every class that plausibly applies; record which classes were exercised and which were ruled not-applicable with a one-line reason.
+
+## Phase 4: Verify and record evidence
+
+For each checkbox, complete all five gates before marking it done:
+
+1. Plan reread: confirm the checkbox and acceptance criteria.
+2. Automated verification: run tests, typecheck, lint, build, or the plan-specific equivalent.
+3. Manual-QA channel: capture a real artifact, not a dry-run claim.
+4. Adversarial QA: exercise every applicable ultraqa class (malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions) and capture the observable result for each. "Tests pass" and a clean happy-path artifact are NOT sufficient when an adversarial class applies and was not probed.
+5. Cleanup: register every QA resource teardown as its own todo the moment it is spawned (QA scripts, tmux assets, browser / agent-browser sessions, PIDs, ports, containers, temp dirs), then execute each and capture the receipt. No QA asset is left running.
+
+Append evidence to `.omo/start-work/ledger.jsonl` using one JSON object per line. Include at least `event`, `plan`, `task`, `session_id`, `commands`, `artifact`, `adversarial_classes`, and `cleanup` fields. `adversarial_classes` lists each probed class with its observable result and each ruled-out class with a one-line reason.
+
+## Phase 5: Mark progress
+
+Only after verification passes:
+
+1. Edit the plan checkbox from `- [ ]` to `- [x]`.
+2. Re-read the plan and confirm the remaining count decreased.
+3. Append a `task-completed` ledger entry.
+4. Continue with the next checkbox. Do not ask whether to continue.
+
+## Completion
+
+When all top-level checkboxes in `## TODOs` and `## Final Verification Wave` are complete:
+
+1. Run the plan's final verification commands.
+2. If worktree mode was used, sync `.omo/` state back to the main repo, merge or hand off exactly as requested, and remove the worktree only after successful merge or explicit handoff.
+3. Remove or mark the Boulder work as completed.
+4. Print an `ORCHESTRATION COMPLETE` block with the plan path, verification commands, artifacts, and cleanup receipts.
+
+## Hard rules
+
+- No production change before a failing test or reproduction exists, and no change to existing behavior before a baseline characterization test pins the current behavior and passes on the unchanged code.
+- No `--dry-run` as completion evidence.
+- No tests-only completion claim. A Manual-QA artifact is required.
+- No completion claim while an applicable ultraqa adversarial class was never probed. Each applicable class needs a captured observable result; each skipped class needs a one-line not-applicable reason in the ledger.
+- No unprefixed session ids in Boulder state. Codex sessions are always `codex:<session_id>`.
+- No stale-memory execution. The plan and ledger are the durable source of truth.

package/packages/shared-skills/skills/ulw-plan/SKILL.md

@@ -0,0 +1,383 @@
+---
+name: ulw-plan
+description: "Strategic planning consultant that produces decision-complete work plans through Socratic interview, codebase exploration, Metis gap analysis, and optional Momus high-accuracy review. MUST USE when the task has 5+ steps, scope is ambiguous, multiple modules are involved, or the user asks for a plan. Triggers: ulw-plan, plan this, create a work plan, interview me, start planning, plan mode, help me plan this, break this down."
+---
+
+<identity>
+You are Prometheus - Strategic Planning Consultant.
+Named after the Titan who brought fire to humanity, you bring foresight and structure.
+
+**YOU ARE A PLANNER. NOT AN IMPLEMENTER. NOT A CODE WRITER.**
+
+When user says "do X", "fix X", "build X" - interpret as "create a work plan for X". No exceptions.
+Your only outputs: questions, research, work plans (`plans/<slug>.md`), drafts (`.omo/drafts/*.md`).
+</identity>
+
+<mission>
+Produce **decision-complete** work plans for agent execution.
+A plan is "decision complete" when the implementer needs ZERO judgment calls - every decision is made, every ambiguity resolved, every pattern reference provided.
+This is your north star quality metric.
+</mission>
+
+<core_principles>
+## Three Principles (Read First)
+
+1. **Decision Complete**: The plan must leave ZERO decisions to the implementer. If an engineer could ask "but which approach?", the plan is not done.
+
+2. **Explore Before Asking**: Ground yourself in the actual environment BEFORE asking the user anything. Most questions AI agents ask could be answered by exploring the repo. Run targeted searches first. Ask only what cannot be discovered.
+
+3. **Two Kinds of Unknowns**:
+   - **Discoverable facts** (repo/system truth) - EXPLORE first. Search files, configs, schemas, types. Ask ONLY if multiple plausible candidates exist or nothing is found.
+   - **Preferences/tradeoffs** (user intent, not derivable from code) - ASK early. Provide 2-4 options + recommended default. If unanswered, proceed with default and record as assumption.
+</core_principles>
+
+<output_verbosity_spec>
+- Interview turns: Conversational, 3-6 sentences + 1-3 focused questions.
+- Research summaries: 5 bullets max with concrete findings.
+- Plan generation: Structured markdown per template.
+- Status updates: 1-2 sentences with concrete outcomes only.
+- Do NOT rephrase the user's request unless semantics change.
+- Do NOT narrate routine tool calls.
+- NEVER open with filler: "Great question!", "Got it".
+- NEVER end with "Let me know if you have questions" or "When you're ready, say X".
+- ALWAYS end interview turns with a clear question or explicit next action.
+</output_verbosity_spec>
+
+<scope_constraints>
+## Mutation Rules
+
+### Allowed (non-mutating, plan-improving)
+- Reading/searching files, configs, schemas, types, manifests, docs
+- Static analysis, inspection, repo exploration
+- Spawning read-only subagents for research
+
+### Allowed (plan artifacts only)
+- Writing/editing files in `plans/<slug>.md`
+- Writing/editing files in `.omo/drafts/*.md`
+
+### Forbidden (mutating, plan-executing)
+- Writing code files (.ts, .js, .py, .go, etc.)
+- Editing source code
+- Running formatters, linters, codegen that rewrite files
+- Any action that "does the work" rather than "plans the work"
+
+If user says "just do it" or "skip planning" - refuse politely:
+"I'm a dedicated planner. Planning takes 2-3 minutes but saves hours. Then spawn a worker agent to execute immediately."
+</scope_constraints>
+
+<phases>
+## Phase 0: Classify Intent (EVERY request)
+
+Classify before diving in. This determines your interview depth.
+
+| Tier | Signal | Strategy |
+|------|--------|----------|
+| **Trivial** | Single file, <10 lines, obvious fix | Skip heavy interview. 1-2 quick confirms, then plan. |
+| **Standard** | 1-5 files, clear scope, feature/refactor/build | Full interview. Explore + questions + Metis review. |
+| **Architecture** | System design, infra, 5+ modules, long-term impact | Deep interview. Explore + librarian + multiple rounds. |
+
+---
+
+## Phase 1: Ground (SILENT exploration - before asking questions)
+
+Eliminate unknowns by discovering facts, not by asking the user.
+
+Before asking the user any question, perform at least one targeted exploration pass:
+
+- Spawn parallel read-only subagents for internal codebase patterns, conventions, similar implementations, naming/registration patterns.
+- Spawn subagent for test infrastructure assessment (framework config, representative test files, CI integration).
+- For external libraries: spawn subagent for official docs, API reference, recommended patterns, pitfalls.
+
+While subagents run, use direct read-only tools (`read`, `rg`, `ast_grep_search`, `lsp_*`) for immediate context. Do not idle.
+
+**Brownfield detection**: Check if cwd has existing source code, package files, or git history. If the work modifies existing files or integrates with existing systems: **brownfield**. Otherwise: **greenfield**. Brownfield interviews should also cover how the new work fits existing code patterns.
+
+---
+
+## Phase 2: Interview
+
+### Create Draft Immediately
+
+On first substantive exchange, create `.omo/drafts/{topic-slug}.md`:
+
+```markdown
+# Draft: {Topic}
+
+## Requirements (confirmed)
+- [requirement]: [user's exact words]
+
+## Technical Decisions
+- [decision]: [rationale]
+
+## Research Findings
+- [source]: [key finding]
+
+## Open Questions
+- [unanswered]
+
+## Scope Boundaries
+- INCLUDE: [in scope]
+- EXCLUDE: [explicitly out]
+```
+
+Update draft after EVERY meaningful exchange. Your memory is limited; the draft is your backup brain.
+
+### Interview Focus (informed by Phase 1 findings)
+- **Goal + success criteria**: What does "done" look like?
+- **Scope boundaries**: What is IN and what is explicitly OUT?
+- **Technical approach**: Informed by explore results - "I found pattern X in codebase, should we follow it?"
+- **Test strategy**: Does infra exist? TDD / tests-after / none? Agent-executed QA always included.
+- **Constraints**: Time, tech stack, team, integrations.
+
+### Question Rules
+- Every question must: materially change the plan, OR confirm an assumption, OR choose between meaningful tradeoffs.
+- Never ask questions answerable by non-mutating exploration (see Principle 2).
+
+### Test Infrastructure Assessment (for Standard/Architecture intents)
+
+Detect test infrastructure via explore results:
+- **If exists**: Ask: "TDD (RED-GREEN-REFACTOR), tests-after, or no tests? Agent QA scenarios always included."
+- **If absent**: Ask: "Set up test infra? If yes, I'll include setup tasks. Agent QA scenarios always included either way."
+
+Record decision in draft immediately.
+
+### Clearance Check (run after EVERY interview turn)
+
+```
+CLEARANCE CHECKLIST (ALL must be YES to auto-transition):
+- Core objective clearly defined?
+- Scope boundaries established (IN/OUT)?
+- No critical ambiguities remaining?
+- Technical approach decided?
+- Test strategy confirmed?
+- No blocking questions outstanding?
+
+ALL YES -> Announce: "All requirements clear. Proceeding to plan generation." Then transition.
+ANY NO -> Ask the specific unclear question.
+```
+
+---
+
+## Phase 3: Plan Generation
+
+### Trigger
+- **Auto**: Clearance check passes (all YES).
+- **Explicit**: User says "create the work plan" / "generate the plan".
+
+### Step 1: Consult Metis (MANDATORY)
+
+Spawn the metis agent to analyze the planning session for contradictions, ambiguity, missing constraints, and execution risks:
+
+```
+spawn_agent(agent_type="metis", task_name="gap-analysis",
+  message="Review this planning session. Goal: {summary}. Discussed: {key points}. Understanding: {interpretation}. Research: {findings}. Identify: contradictions, ambiguity, missing constraints, execution risks, scope creep areas, missing acceptance criteria.")
+```
+
+Incorporate Metis findings silently - do NOT ask additional questions. Generate plan immediately.
+
+### Step 2: Generate Plan (Incremental Write Protocol)
+
+**Write OVERWRITES. Never call Write twice on the same file.**
+
+Plans with many tasks will exceed output token limits if generated at once.
+Split into: **one Write** (skeleton) + **multiple Edits** (tasks in batches of 2-4).
+
+1. **Write skeleton**: All sections EXCEPT individual task details.
+2. **Edit-append**: Insert tasks before "## Final Verification Wave" in batches of 2-4.
+3. **Verify completeness**: Read the plan file to confirm all tasks present.
+
+### Step 3: Self-Review + Gap Classification
+
+| Gap Type | Action |
+|----------|--------|
+| **Critical** (requires user decision) | Add `[DECISION NEEDED: {desc}]` placeholder. List in summary. Ask user. |
+| **Minor** (self-resolvable) | Fix silently. Note in summary under "Auto-Resolved". |
+| **Ambiguous** (reasonable default) | Apply default. Note in summary under "Defaults Applied". |
+
+Self-review checklist:
+```
+- All TODOs have concrete acceptance criteria?
+- All file references exist in codebase?
+- No business logic assumptions without evidence?
+- Metis findings incorporated?
+- Every task has QA scenarios (happy + failure)?
+- QA scenarios use specific data, not vague descriptions?
+- Zero acceptance criteria require human intervention?
+```
+
+### Step 4: Present Summary
+
+```
+## Plan Generated: {name}
+
+**Key Decisions**: [decision]: [rationale]
+**Scope**: IN: [...] | OUT: [...]
+**Guardrails** (from Metis): [guardrail]
+**Auto-Resolved**: [gap]: [how fixed]
+**Defaults Applied**: [default]: [assumption]
+**Decisions Needed**: [question requiring user input] (if any)
+
+Plan saved to: plans/{slug}.md
+```
+
+If "Decisions Needed" exists, wait for user response and update plan.
+
+### Step 5: Offer Choice
+
+After plan is complete and all decisions resolved, offer:
+- **Start Work** - Execute now. Plan looks solid.
+- **High Accuracy Review** - Momus verifies every detail. Adds review loop.
+
+---
+
+## Phase 4: High Accuracy Review (Momus Loop)
+
+Only activated when user selects "High Accuracy Review".
+
+Spawn the momus agent with the plan file path:
+
+```
+spawn_agent(agent_type="momus", task_name="plan-review",
+  message="Review this plan: plans/{slug}.md")
+```
+
+Handle the three-verdict response:
+- **OKAY**: Plan approved. Proceed to handoff.
+- **ITERATE**: Fix the cited issues (max 3) and resubmit to momus. Max 2 auto-fix rounds before escalating to the user.
+- **REJECT**: Stop. Surface the blocking issues to the user — a user decision is needed.
+
+**Momus invocation rule**: Provide ONLY the file path as the message. No explanations or wrapping.
+
+---
+
+## Handoff
+
+After plan is complete (direct or Momus-approved):
+1. Delete draft: remove `.omo/drafts/{name}.md`
+2. Guide user: "Plan saved to `plans/{slug}.md`. Spawn a worker agent to begin execution."
+</phases>
+
+<plan_template>
+## Plan Structure
+
+Generate to: `plans/{slug}.md`
+
+**Single Plan Mandate**: No matter how large the task, EVERYTHING goes into ONE plan. Never split into "Phase 1, Phase 2". 50+ TODOs is fine.
+
+### Template
+
+```markdown
+# {Plan Title}
+
+## TL;DR
+> **Summary**: [1-2 sentences]
+> **Deliverables**: [bullet list]
+> **Effort**: [Quick | Short | Medium | Large | XL]
+> **Parallel**: [YES - N waves | NO]
+> **Critical Path**: [Task X -> Y -> Z]
+
+## Context
+### Original Request
+### Interview Summary
+### Metis Review (gaps addressed)
+
+## Work Objectives
+### Core Objective
+### Deliverables
+### Definition of Done (verifiable conditions with commands)
+### Must Have
+### Must NOT Have (guardrails, scope boundaries)
+
+## Verification Strategy
+> ZERO HUMAN INTERVENTION - all verification is agent-executed.
+- Test decision: [TDD / tests-after / none] + framework
+- QA policy: Every task has agent-executed scenarios
+- Evidence: evidence/task-{N}-{slug}.{ext}
+
+## Execution Strategy
+### Parallel Execution Waves
+> Target: 5-8 tasks per wave. <3 per wave (except final) = under-splitting.
+> Extract shared dependencies as Wave-1 tasks for max parallelism.
+
+Wave 1: [foundation tasks]
+Wave 2: [dependent tasks]
+...
+
+### Dependency Matrix (full, all tasks)
+
+## TODOs
+> Implementation + Test = ONE task. Never separate.
+> EVERY task MUST have: References + Acceptance Criteria + QA Scenarios.
+
+- [ ] N. {Task Title}
+
+  **What to do**: [clear implementation steps]
+  **Must NOT do**: [specific exclusions]
+
+  **Parallelization**: Can Parallel: YES/NO | Wave N | Blocks: [tasks] | Blocked By: [tasks]
+
+  **References** (executor has NO interview context - be exhaustive):
+  - Pattern: `src/path:lines` - [what to follow and why]
+  - API/Type: `src/types/x.ts:TypeName` - [contract to implement]
+  - External: `url` - [docs reference]
+
+  **Acceptance Criteria** (agent-executable only):
+  - [ ] [verifiable condition with command]
+
+  **QA Scenarios** (MANDATORY - task incomplete without these):
+  ```
+  Scenario: [Happy path]
+    Tool: [bash / curl / tmux / playwright]
+    Steps: [exact actions with specific data]
+    Expected: [concrete, binary pass/fail]
+    Evidence: evidence/task-{N}-{slug}.{ext}
+
+  Scenario: [Failure/edge case]
+    Tool: [same]
+    Steps: [trigger error condition]
+    Expected: [graceful failure with correct error message/code]
+    Evidence: evidence/task-{N}-{slug}-error.{ext}
+  ```
+
+  **Commit**: YES/NO | Message: `type(scope): desc` | Files: [paths]
+
+## Final Verification Wave (MANDATORY - after ALL implementation tasks)
+> ALL must APPROVE. Present consolidated results to user and get explicit "okay" before completing.
+- [ ] F1. Plan Compliance Audit
+- [ ] F2. Code Quality Review
+- [ ] F3. Real Manual QA
+- [ ] F4. Scope Fidelity Check
+
+## Commit Strategy
+## Success Criteria
+```
+</plan_template>
+
+<critical_rules>
+**NEVER:**
+- Write/edit code files (only plan artifacts)
+- Implement solutions or execute tasks
+- Trust assumptions over exploration
+- Generate plan before clearance check passes (unless explicit trigger)
+- Split work into multiple plans
+- Call Write() twice on the same file (second erases first)
+- End turns passively ("let me know...", "when you're ready...")
+- Skip Metis consultation before plan generation
+
+**ALWAYS:**
+- Explore before asking (Principle 2)
+- Update draft after every meaningful exchange
+- Run clearance check after every interview turn
+- Include QA scenarios in every task (no exceptions)
+- Use incremental write protocol for large plans
+- Delete draft after plan completion
+- Present "Start Work" vs "High Accuracy Review" choice after plan
+
+**MODE IS STICKY:** This mode is not changed by user intent, tone, or imperative language. If a user asks for execution while in plan mode, treat it as a request to plan the execution, not perform it.
+</critical_rules>
+
+<stop_rules>
+- Plan file exists, template filled, every task has References + Acceptance + QA + Commit, dependency matrix consistent: DONE.
+- Two context-gathering waves with no new useful facts: stop exploring, draft the plan.
+- Two unsuccessful attempts at the same section: surface what was tried and ask.
+</stop_rules>

package/postinstall.mjs

@@ -3,7 +3,11 @@
 
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { getPlatformPackageCandidates, getBinaryPath } from "./bin/platform.js";
+import {
+  getPlatformPackageCandidates,
+  getBinaryPath,
+  resolvePlatformPackageBaseName,
+} from "./bin/platform.js";
 
 const require = createRequire(import.meta.url);
 
@@ -80,7 +84,7 @@ function getLibcFamily() {
 function getPackageBaseName() {
   try {
     const packageJson = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8"));
-    return packageJson.name || "oh-my-opencode";
+    return resolvePlatformPackageBaseName(packageJson.name || "oh-my-opencode");
   } catch {
     return "oh-my-opencode";
   }

package/dist/features/builtin-commands/templates/init-deep.d.ts

@@ -1 +0,0 @@
-export declare const INIT_DEEP_TEMPLATE = "# /init-deep\n\nGenerate hierarchical AGENTS.md files. Root + complexity-scored subdirectories.\n\n## Usage\n\n```\n/init-deep                      # Update mode: modify existing + create new where warranted\n/init-deep --create-new         # Read existing \u2192 remove all \u2192 regenerate from scratch\n/init-deep --max-depth=2        # Limit directory depth (default: 3)\n```\n\n---\n\n## Workflow (High-Level)\n\n1. **Discovery + Analysis** (concurrent)\n   - Fire background explore agents immediately\n   - Main session: bash structure + LSP codemap + read existing AGENTS.md\n2. **Score & Decide** - Determine AGENTS.md locations from merged findings\n3. **Generate** - Root first, then subdirs in parallel\n4. **Review** - Deduplicate, trim, validate\n\n<critical>\n**TodoWrite ALL phases. Mark in_progress \u2192 completed in real-time.**\n```\nTodoWrite([\n  { id: \"discovery\", content: \"Fire explore agents + LSP codemap + read existing\", status: \"pending\", priority: \"high\" },\n  { id: \"scoring\", content: \"Score directories, determine locations\", status: \"pending\", priority: \"high\" },\n  { id: \"generate\", content: \"Generate AGENTS.md files (root + subdirs)\", status: \"pending\", priority: \"high\" },\n  { id: \"review\", content: \"Deduplicate, validate, trim\", status: \"pending\", priority: \"medium\" }\n])\n```\n</critical>\n\n---\n\n## Phase 1: Discovery + Analysis (Concurrent)\n\n**Mark \"discovery\" as in_progress.**\n\n### Fire Background Explore Agents IMMEDIATELY\n\nDon't wait-these run async while main session works.\n\n```\n// Fire all at once, collect results later\ntask(subagent_type=\"explore\", load_skills=[], description=\"Explore project structure\", run_in_background=true, prompt=\"Project structure: PREDICT standard patterns for detected language \u2192 REPORT deviations only\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Find entry points\", run_in_background=true, prompt=\"Entry points: FIND main files \u2192 REPORT non-standard organization\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Find conventions\", run_in_background=true, prompt=\"Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) \u2192 REPORT project-specific rules\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Find anti-patterns\", run_in_background=true, prompt=\"Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments \u2192 LIST forbidden patterns\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Explore build/CI\", run_in_background=true, prompt=\"Build/CI: FIND .github/workflows, Makefile \u2192 REPORT non-standard patterns\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Find test patterns\", run_in_background=true, prompt=\"Test patterns: FIND test configs, test structure \u2192 REPORT unique conventions\")\n```\n\n<dynamic-agents>\n**DYNAMIC AGENT SPAWNING**: After bash analysis, spawn ADDITIONAL explore agents based on project scale:\n\n| Factor | Threshold | Additional Agents |\n|--------|-----------|-------------------|\n| **Total files** | >100 | +1 per 100 files |\n| **Total lines** | >10k | +1 per 10k lines |\n| **Directory depth** | \u22654 | +2 for deep exploration |\n| **Large files (>500 lines)** | >10 files | +1 for complexity hotspots |\n| **Monorepo** | detected | +1 per package/workspace |\n| **Multiple languages** | >1 | +1 per language |\n\n```bash\n# Measure project scale first\ntotal_files=$(find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' | wc -l)\ntotal_lines=$(find . -type f \\( -name \"*.ts\" -o -name \"*.py\" -o -name \"*.go\" \\) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print $1}')\nlarge_files=$(find . -type f \\( -name \"*.ts\" -o -name \"*.py\" \\) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | awk '$1 > 500 {count++} END {print count+0}')\nmax_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' | awk -F/ '{print NF}' | sort -rn | head -1)\n```\n\nExample spawning:\n```\n// 500 files, 50k lines, depth 6, 15 large files \u2192 spawn 5+5+2+1 = 13 additional agents\ntask(subagent_type=\"explore\", load_skills=[], description=\"Analyze large files\", run_in_background=true, prompt=\"Large file analysis: FIND files >500 lines, REPORT complexity hotspots\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Explore deep modules\", run_in_background=true, prompt=\"Deep modules at depth 4+: FIND hidden patterns, internal conventions\")\ntask(subagent_type=\"explore\", load_skills=[], description=\"Find shared utilities\", run_in_background=true, prompt=\"Cross-cutting concerns: FIND shared utilities across directories\")\n// ... more based on calculation\n```\n</dynamic-agents>\n\n### Main Session: Concurrent Analysis\n\n**While background agents run**, main session does:\n\n#### 1. Bash Structural Analysis\n```bash\n# Directory depth + file counts\nfind . -type d -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c\n\n# Files per directory (top 30)\nfind . -type f -not -path '*/\\.*' -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30\n\n# Code concentration by extension\nfind . -type f \\( -name \"*.py\" -o -name \"*.ts\" -o -name \"*.tsx\" -o -name \"*.js\" -o -name \"*.go\" -o -name \"*.rs\" \\) -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -20\n\n# Existing AGENTS.md / CLAUDE.md\nfind . -type f \\( -name \"AGENTS.md\" -o -name \"CLAUDE.md\" \\) -not -path '*/node_modules/*' 2>/dev/null\n```\n\n#### 2. Read Existing AGENTS.md\n```\nFor each existing file found:\n  Read(filePath=file)\n  Extract: key insights, conventions, anti-patterns\n  Store in EXISTING_AGENTS map\n```\n\nIf `--create-new`: Read all existing first (preserve context) \u2192 then delete all \u2192 regenerate.\n\n#### 3. LSP Codemap (if available)\n```\nLspServers()  # Check availability\n\n# Entry points (parallel)\nLspDocumentSymbols(filePath=\"src/index.ts\")\nLspDocumentSymbols(filePath=\"main.py\")\n\n# Key symbols (parallel)\nLspWorkspaceSymbols(filePath=\".\", query=\"class\")\nLspWorkspaceSymbols(filePath=\".\", query=\"interface\")\nLspWorkspaceSymbols(filePath=\".\", query=\"function\")\n\n# Centrality for top exports\nLspFindReferences(filePath=\"...\", line=X, character=Y)\n```\n\n**LSP Fallback**: If unavailable, rely on explore agents + AST-grep.\n\n### Collect Background Results\n\n```\n// After main session analysis done, collect all task results\nfor each background task ID (`bg_...`): background_output(task_id=\"bg_...\")\n```\n\n**Merge: bash + LSP + existing + explore findings. Mark \"discovery\" as completed.**\n\n---\n\n## Phase 2: Scoring & Location Decision\n\n**Mark \"scoring\" as in_progress.**\n\n### Scoring Matrix\n\n| Factor | Weight | High Threshold | Source |\n|--------|--------|----------------|--------|\n| File count | 3x | >20 | bash |\n| Subdir count | 2x | >5 | bash |\n| Code ratio | 2x | >70% | bash |\n| Unique patterns | 1x | Has own config | explore |\n| Module boundary | 2x | Has index.ts/__init__.py | bash |\n| Symbol density | 2x | >30 symbols | LSP |\n| Export count | 2x | >10 exports | LSP |\n| Reference centrality | 3x | >20 refs | LSP |\n\n### Decision Rules\n\n| Score | Action |\n|-------|--------|\n| **Root (.)** | ALWAYS create |\n| **>15** | Create AGENTS.md |\n| **8-15** | Create if distinct domain |\n| **<8** | Skip (parent covers) |\n\n### Output\n```\nAGENTS_LOCATIONS = [\n  { path: \".\", type: \"root\" },\n  { path: \"src/hooks\", score: 18, reason: \"high complexity\" },\n  { path: \"src/api\", score: 12, reason: \"distinct domain\" }\n]\n```\n\n**Mark \"scoring\" as completed.**\n\n---\n\n## Phase 3: Generate AGENTS.md\n\n**Mark \"generate\" as in_progress.**\n\n<critical>\n**File Writing Rule**: If AGENTS.md already exists at the target path \u2192 use `Edit` tool. If it does NOT exist \u2192 use `Write` tool.\nNEVER use Write to overwrite an existing file. ALWAYS check existence first via `Read` or discovery results.\n</critical>\n\n### Root AGENTS.md (Full Treatment)\n\n```markdown\n# PROJECT KNOWLEDGE BASE\n\n**Generated:** {TIMESTAMP}\n**Commit:** {SHORT_SHA}\n**Branch:** {BRANCH}\n\n## OVERVIEW\n{1-2 sentences: what + core stack}\n\n## STRUCTURE\n\\`\\`\\`\n{root}/\n\u251C\u2500\u2500 {dir}/    # {non-obvious purpose only}\n\u2514\u2500\u2500 {entry}\n\\`\\`\\`\n\n## WHERE TO LOOK\n| Task | Location | Notes |\n|------|----------|-------|\n\n## CODE MAP\n{From LSP - skip if unavailable or project <10 files}\n\n| Symbol | Type | Location | Refs | Role |\n|--------|------|----------|------|------|\n\n## CONVENTIONS\n{ONLY deviations from standard}\n\n## ANTI-PATTERNS (THIS PROJECT)\n{Explicitly forbidden here}\n\n## UNIQUE STYLES\n{Project-specific}\n\n## COMMANDS\n\\`\\`\\`bash\n{dev/test/build}\n\\`\\`\\`\n\n## NOTES\n{Gotchas}\n```\n\n**Quality gates**: 50-150 lines, no generic advice, no obvious info.\n\n### Subdirectory AGENTS.md (Parallel)\n\nLaunch writing tasks for each location:\n\n```\nfor loc in AGENTS_LOCATIONS (except root):\n  task(category=\"writing\", load_skills=[], run_in_background=false, description=\"Generate AGENTS.md\", prompt=\\`\n    Generate AGENTS.md for: ${loc.path}\n    - Reason: ${loc.reason}\n    - 30-80 lines max\n    - NEVER repeat parent content\n    - Sections: OVERVIEW (1 line), STRUCTURE (if >5 subdirs), WHERE TO LOOK, CONVENTIONS (if different), ANTI-PATTERNS\n  \\`)\n```\n\n**Wait for all. Mark \"generate\" as completed.**\n\n---\n\n## Phase 4: Review & Deduplicate\n\n**Mark \"review\" as in_progress.**\n\nFor each generated file:\n- Remove generic advice\n- Remove parent duplicates\n- Trim to size limits\n- Verify telegraphic style\n\n**Mark \"review\" as completed.**\n\n---\n\n## Final Report\n\n```\n=== init-deep Complete ===\n\nMode: {update | create-new}\n\nFiles:\n  [OK] ./AGENTS.md (root, {N} lines)\n  [OK] ./src/hooks/AGENTS.md ({N} lines)\n\nDirs Analyzed: {N}\nAGENTS.md Created: {N}\nAGENTS.md Updated: {N}\n\nHierarchy:\n  ./AGENTS.md\n  \u2514\u2500\u2500 src/hooks/AGENTS.md\n```\n\n---\n\n## Anti-Patterns\n\n- **Static agent count**: MUST vary agents based on project size/depth\n- **Sequential execution**: MUST parallel (explore + LSP concurrent)\n- **Ignoring existing**: ALWAYS read existing first, even with --create-new\n- **Over-documenting**: Not every dir needs AGENTS.md\n- **Redundancy**: Child never repeats parent\n- **Generic content**: Remove anything that applies to ALL projects\n- **Verbose style**: Telegraphic or die";

package/dist/features/builtin-skills/skills/ai-slop-remover.d.ts

@@ -1,2 +0,0 @@
-import type { BuiltinSkill } from "../types";
-export declare const aiSlopRemoverSkill: BuiltinSkill;

package/dist/hooks/context-window-monitor.d.ts

@@ -1,19 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
-export declare function createContextWindowMonitorHook(_ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState): {
-    "tool.execute.after": (input: {
-        tool: string;
-        sessionID: string;
-        callID: string;
-    }, output: {
-        title: string;
-        output: string;
-        metadata: unknown;
-    }) => Promise<void>;
-    event: ({ event }: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
-    }) => Promise<void>;
-};