oh-my-opencode 4.9.2 → 4.11.0

package/packages/shared-skills/skills/ulw-plan/scripts/scaffold-plan.mjs

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+// scaffold-plan.mjs - generate the ulw-plan draft + plan skeleton deterministically.
+//
+// Zero external dependencies (node:fs/path/process/url builtins only) so it runs
+// byte-identically under `node` and `bun` on macOS, Linux, and Windows with no uv
+// bootstrap, no npm/pip install, and no POSIX-shell or python3 precondition - the
+// two things genuinely not guaranteed on native Windows across the omo harnesses.
+//
+// Usage:  node "<skill-root>/scripts/scaffold-plan.mjs" <slug> [--clear|--unclear] [--reset [--force]]
+//
+// RESUME-SAFE: run it ONCE at plan generation. A plain re-run on an existing
+// ulw-plan artifact is a NO-OP success (it never overwrites your appended todos),
+// so a model resuming after compaction cannot crash the turn or clobber the plan.
+// Destructive overwrite is reserved behind --reset, and --reset refuses to discard
+// a hand-edited file unless --force is also passed.
+//
+// WRITE BOUNDARY: the prometheus-md-only hook gates Write/Edit but NOT Bash, so
+// this node:fs script writes out of band of that hook. It self-guards THIS script's
+// own writes to resolve under .omo/ (it does not, and cannot, contain other Bash
+// commands; it only guarantees the mandated generator never escapes .omo). Mirrors
+// packages/omo-opencode/src/hooks/prometheus-md-only/path-policy.ts.
+
+import { lstat, mkdir, writeFile, readFile, realpath } from "node:fs/promises";
+import { dirname, join, relative, resolve, isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// The canonical AI-plan section headers, in order. references/full-workflow.md
+// documents this exact list; a build-time test asserts the two never drift.
+export const PLAN_SECTION_HEADERS = [
+	"## TL;DR (For humans)",
+	"## Scope",
+	"## Verification strategy",
+	"## Execution strategy",
+	"## Todos",
+	"## Final verification wave",
+	"## Commit strategy",
+	"## Success criteria",
+];
+
+export const FINAL_VERIFICATION_ITEMS = [
+	"F1. Plan compliance audit",
+	"F2. Code quality review",
+	"F3. Real manual QA",
+	"F4. Scope fidelity",
+];
+
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
+
+export function parseArgs(argv) {
+	const rest = argv.slice(2);
+	let slug;
+	let intent = "unspecified";
+	let force = false;
+	let reset = false;
+	for (const arg of rest) {
+		if (arg === "--clear") intent = "clear";
+		else if (arg === "--unclear") intent = "unclear";
+		else if (arg === "--reset") reset = true;
+		else if (arg === "--force") force = true;
+		else if (arg.startsWith("--")) throw new Error(`unknown flag: ${arg}`);
+		else if (slug === undefined) slug = arg;
+		else throw new Error(`unexpected argument: ${arg}`);
+	}
+	if (!slug) throw new Error('usage: scaffold-plan.mjs <slug> [--clear|--unclear] [--reset [--force]]');
+	if (!SLUG_PATTERN.test(slug)) {
+		throw new Error(`invalid slug "${slug}" - use lowercase letters, digits, and hyphens only`);
+	}
+	return { slug, intent, reset, force };
+}
+
+// Resolve a project-relative path and confine it under .omo/ - the script's own
+// enforcement of the prometheus planner write boundary.
+export function resolveSafeOmoPath(cwd, relPath) {
+	const resolved = resolve(cwd, relPath);
+	const rel = relative(cwd, resolved);
+	if (rel.startsWith("..") || isAbsolute(rel)) {
+		throw new Error(`refused: path escapes the workspace root: ${relPath}`);
+	}
+	if (!/(^|[/\\])\.omo([/\\]|$)/i.test(rel)) {
+		throw new Error(`refused: ulw-plan may only write under .omo/: ${relPath}`);
+	}
+	if (!resolved.toLowerCase().endsWith(".md")) {
+		throw new Error(`refused: ulw-plan may only write .md files: ${relPath}`);
+	}
+	return resolved;
+}
+
+function assertContainedPath(parent, child, message) {
+	const rel = relative(parent, child);
+	if (rel.startsWith("..") || isAbsolute(rel)) {
+		throw new Error(message);
+	}
+}
+
+async function mkdirWithoutSymlinks(dir, stopAt) {
+	if (dir === stopAt) return;
+	const parent = dirname(dir);
+	if (parent === dir || relative(stopAt, dir).startsWith("..") || isAbsolute(relative(stopAt, dir))) {
+		throw new Error(`refused: path escapes the workspace root: ${dir}`);
+	}
+	await mkdirWithoutSymlinks(parent, stopAt);
+	const stat = await lstat(dir).catch((err) => {
+		if (err && err.code === "ENOENT") return null;
+		throw err;
+	});
+	if (stat) {
+		if (stat.isSymbolicLink()) {
+			throw new Error(`refused: path component is a symlink: ${dir}`);
+		}
+		if (!stat.isDirectory()) {
+			throw new Error(`refused: path component is not a directory: ${dir}`);
+		}
+		return;
+	}
+	await mkdir(dir);
+}
+
+async function assertSafeWriteParent(cwd, target) {
+	const workspaceReal = await realpath(cwd);
+	const workspaceRoot = resolve(cwd);
+	const omoRoot = resolve(cwd, ".omo");
+	const parent = dirname(target);
+	assertContainedPath(workspaceRoot, parent, `refused: path escapes the workspace root: ${target}`);
+	assertContainedPath(omoRoot, parent, `refused: ulw-plan may only write under .omo/: ${target}`);
+	await mkdirWithoutSymlinks(parent, workspaceRoot);
+	const omoReal = await realpath(omoRoot);
+	const parentReal = await realpath(parent);
+	assertContainedPath(workspaceReal, parentReal, `refused: path escapes the workspace root through symlinks: ${target}`);
+	assertContainedPath(omoReal, parentReal, `refused: ulw-plan may only write under .omo/ through real paths: ${target}`);
+}
+
+async function assertSafeWriteTarget(target) {
+	const stat = await lstat(target).catch((err) => {
+		if (err && err.code === "ENOENT") return null;
+		throw err;
+	});
+	if (stat?.isSymbolicLink()) {
+		throw new Error(`refused: target is a symlink: ${target}`);
+	}
+}
+
+// A file this script previously emitted (plan skeleton or draft), used to make a
+// plain re-run a safe no-op instead of a crash or a clobber.
+export function isUlwArtifact(content) {
+	const isPlan = content.includes("## TL;DR (For humans)") && content.includes("## Final verification wave");
+	const isDraft = content.includes("# Draft:") && content.includes("## Approval gate");
+	return isPlan || isDraft;
+}
+
+export function buildDraft(slug, intent) {
+	const assumptionsNote =
+		intent === "unclear"
+			? "Intent is UNCLEAR: research resolves ambiguity, defaults are adopted (not asked), and each is surfaced in the plan's human TL;DR for veto."
+			: "Record any default you adopt instead of asking, so the user can veto it at the gate.";
+	return `---
+slug: ${slug}
+status: drafting
+intent: ${intent}
+pending-action: write .omo/plans/${slug}.md
+approach: <fill: the approach you intend to plan>
+---
+
+# Draft: ${slug}
+
+## Components (topology ledger)
+<!-- Lock the SHAPE before depth. One row per top-level component that can succeed or fail independently. -->
+<!-- id | outcome (one line) | status: active|deferred | evidence path -->
+
+## Open assumptions (announced defaults)
+<!-- ${assumptionsNote} -->
+<!-- assumption | adopted default | rationale | reversible? -->
+
+## Findings (cited - path:lines)
+
+## Decisions (with rationale)
+
+## Scope IN
+
+## Scope OUT (Must NOT have)
+
+## Open questions
+
+## Approval gate
+status: drafting
+<!-- When exploration is exhausted and unknowns are answered, set status: awaiting-approval. -->
+<!-- That durable record is the loop guard: on a later turn read it and resume at the gate instead of re-running exploration. -->
+`;
+}
+
+export function buildPlanSkeleton(slug, intent) {
+	const decisionsLine =
+		intent === "unclear"
+			? "**Decisions I made for you:** <fill last - the best-practice defaults you adopted; the user vetoes any here>"
+			: "**Decisions to sanity-check:** <fill last - the few choices worth a human glance>";
+	return `# ${slug} - Work Plan
+
+## TL;DR (For humans)
+<!-- Fill this LAST, after the detailed plan below is written, so it summarizes the REAL plan. -->
+<!-- Plain English for a non-engineer: NO file paths, NO todo numbers, NO wave/agent/tool names. -->
+
+**What you'll get:** <fill last - deliverables in human terms, 1-2 sentences>
+
+**Why this approach:** <fill last - the one or two load-bearing decisions and why>
+
+**What it will NOT do:** <fill last - 1-3 plain lines mirroring Must NOT have>
+
+**Effort:** <Quick | Short | Medium | Large | XL>
+**Risk:** <Low | Medium | High> - <one-line driver>
+${decisionsLine}
+
+Your next move: <fill - e.g. approve, or run a high-accuracy review>. Full execution detail follows below.
+
+---
+
+> TL;DR (machine): <1 line - effort, risk, deliverables>
+
+## Scope
+### Must have
+### Must NOT have (guardrails, anti-slop, scope boundaries)
+
+## Verification strategy
+> Zero human intervention - all verification is agent-executed.
+- Test decision: <TDD | tests-after | none> + framework
+- Evidence: .omo/evidence/task-<N>-${slug}.<ext>
+
+## Execution strategy
+### Parallel execution waves
+> Target 5-8 todos per wave. Fewer than 3 (except the final) means you under-split.
+
+### Dependency matrix
+| Todo | Depends on | Blocks | Can parallelize with |
+| --- | --- | --- | --- |
+
+## Todos
+> Implementation + Test = ONE todo. Never separate.
+<!-- APPEND TASK BATCHES BELOW THIS LINE WITH edit/apply_patch - never rewrite the headers above. -->
+- [ ] 1. <title>
+  What to do / Must NOT do: <...>
+  Parallelization: Wave <N> | Blocked by: <...> | Blocks: <...>
+  References (executor has NO interview context - be exhaustive): <src/path:lines>
+  Acceptance criteria (agent-executable): <exact command or assertion>
+  QA scenarios (name the exact tool + invocation): happy + failure, Evidence .omo/evidence/task-1-${slug}.<ext>
+  Commit: <Y/N> | <type>(<scope>): <summary>
+
+## Final verification wave
+> Runs in parallel after ALL todos. ALL must APPROVE. Surface results and wait for the user's explicit okay before declaring complete.
+${FINAL_VERIFICATION_ITEMS.map((item) => `- [ ] ${item}`).join("\n")}
+
+## Commit strategy
+
+## Success criteria
+`;
+}
+
+// Resume-safe write: plain re-run on an existing ulw-plan artifact is a no-op
+// success; --reset overwrites but refuses to discard a hand-edited file unless
+// --force is also passed.
+export async function writeGuarded(cwd, relPath, content, { reset = false, force = false } = {}) {
+	const target = resolveSafeOmoPath(cwd, relPath);
+	await assertSafeWriteParent(cwd, target);
+	await assertSafeWriteTarget(target);
+	const existing = await readFile(target, "utf8").catch(() => null);
+	if (existing && existing.trim() !== "") {
+		if (!reset) {
+			if (isUlwArtifact(existing)) return { relPath, status: "exists" };
+			throw new Error(`refused: ${relPath} exists and is not a ulw-plan artifact (pass --reset to overwrite)`);
+		}
+		if (existing.trim() !== content.trim() && !force) {
+			throw new Error(`refused: ${relPath} has edits that differ from a fresh skeleton; pass --reset --force to discard them`);
+		}
+	}
+	await writeFile(target, content, "utf8");
+	return { relPath, status: existing ? "reset" : "created" };
+}
+
+export async function scaffold(cwd, { slug, intent, reset = false, force = false }) {
+	const draftRel = join(".omo", "drafts", `${slug}.md`);
+	const planRel = join(".omo", "plans", `${slug}.md`);
+	const draft = await writeGuarded(cwd, draftRel, buildDraft(slug, intent), { reset, force });
+	const plan = await writeGuarded(cwd, planRel, buildPlanSkeleton(slug, intent), { reset, force });
+	return [draft, plan];
+}
+
+async function main() {
+	const { slug, intent, reset, force } = parseArgs(process.argv);
+	const results = await scaffold(process.cwd(), { slug, intent, reset, force });
+	for (const r of results) process.stdout.write(`${r.status}: ${r.relPath}\n`);
+	const created = results.some((r) => r.status !== "exists");
+	process.stdout.write(
+		created
+			? `next: record findings/decisions in the draft, then APPEND task batches into the "## Todos" region of the plan; fill "## TL;DR (For humans)" LAST.\n`
+			: `skeleton already present - left untouched. APPEND task batches into the "## Todos" region; the human "## TL;DR (For humans)" stays on top.\n`,
+	);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await main().catch((err) => {
+		process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+		process.exit(1);
+	});
+}

package/packages/shared-skills/skills/visual-qa/SKILL.md

@@ -27,7 +27,7 @@ If the change touches both, run both capture tracks and feed both into the passe
 ### Web
 
 1. Capture a REFERENCE image: the user's mock/target, or a known-good baseline. Save as PNG.
-2. Capture the ACTUAL rendered screenshot at the same viewport size using the project's browser tooling (the playwright, agent-browser, or dev-browser skill). Save as PNG.
+2. Capture the ACTUAL rendered screenshot at the same viewport size using the project's browser tooling (the playwright, agent-browser, or dev-browser skill). Save as PNG. If none is configured or available, install [agent-browser](https://github.com/vercel-labs/agent-browser) (`bun add -g agent-browser && agent-browser install`) and capture with it — see `$SKILL_DIR/references/agent-browser-setup.md` for the full setup, including how to shoot a fixed-viewport screenshot.
 3. Run the diff and keep the JSON:
 
 ```
@@ -179,6 +179,22 @@ Completion gate: do not declare the UI done until both passes are satisfied, OR
 [Satisfied, or the exact remaining gaps and who accepted them]
 ```
 
+## Step 5 - Clone-coding mode (when the task was a clone or design port)
+
+Run this step IN ADDITION to Steps 1-4, but ONLY when the original user task was a clone or design port: "clone this site", "move this Figma design to code", "rebuild this screen", "make it look exactly like X". For these tasks the normal dual-oracle is necessary but NOT sufficient. After it returns, run the following TWO additional MANDATORY verifications and LOOP until BOTH pass.
+
+1. Pixel-perfect design-compare subagent (visual oracle). Dispatch a focused, read-only design-compare reviewer (recommend `gpt-5.5` with medium reasoning). It must crop/zoom BOTH the reference (the target / Figma export / source-site screenshot) and the ACTUAL screenshot into matching regions and read them **pixel-by-pixel** - header, nav, each card, spacing, type ramp, color tokens - not at a glance. Anchor every claim with the bundled tool:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" image-diff <reference.png> <actual.png>
+```
+
+   It judges whether layout geometry, spacing, design tokens (color, type, radius, shadow), and the design itself are identical to the target, region by region. Anything off by more than rounding is a finding.
+
+2. Code-level design-system fidelity (code oracle). Call the code-quality reviewer named EXACTLY `lazycodex-clone-fidelity-reviewer` (spawn it by that agent name). It verifies the implementation is a RIGOROUS design-system build - a real component tree, real design tokens, reused primitives - and is NOT a pasted image, a screenshot or background-image substitute, or a hardcoded one-off that merely looks right in one screenshot. If that named reviewer is not installed in this harness, fall back to an inline rigorous code review against the SAME criteria.
+
+RULE (mandatory, non-negotiable): the clone is NOT done until BOTH the pixel-compare AND the `lazycodex-clone-fidelity-reviewer` (or its inline fallback) confirm that the **layer structure, the design system, and the design itself** are strictly identical to the target. If EITHER fails, it is a MANDATORY retry: re-implement the gaps and re-run BOTH verifications from the top. Repeat the retry loop until both pass on the same revision. Never declare a clone complete on a single pass, on visual-only evidence, or on code-only evidence - both oracles must confirm on the same build.
+
 ## Reference evidence is not the verdict
 
 The script quantifies pixels and columns. It cannot judge whether the result is a real design system, whether features work, or whether intent was met. A 99/100 `similarityScore` can still hide a pasted-image fake, a broken interaction, or clipped CJK descenders. Use the numbers to aim the oracles, then trust the synthesized review.

package/packages/shared-skills/skills/visual-qa/references/agent-browser-setup.md

@@ -0,0 +1,44 @@
+# agent-browser setup (Web capture fallback)
+
+Use this when the project has **no** browser tooling configured or available for the Web
+capture path in Step 2 (no playwright / dev-browser skill, no usable headless browser).
+[agent-browser](https://github.com/vercel-labs/agent-browser) is a standalone CLI that
+drives a real Chromium and can screenshot a page at a fixed viewport — exactly what the
+`image-diff` evidence step needs.
+
+Repo: https://github.com/vercel-labs/agent-browser
+
+## Install
+
+```
+bun add -g agent-browser && agent-browser install
+```
+
+`bun add -g agent-browser` installs the CLI globally; `agent-browser install` downloads the
+managed browser it drives. (Equivalent with npm: `npm install -g agent-browser && agent-browser install`.)
+
+Confirm it is ready and discover the current flags:
+
+```
+agent-browser --help
+```
+
+## Capture a screenshot at a fixed viewport
+
+Set the viewport first, then screenshot — this guarantees the ACTUAL capture matches the
+REFERENCE viewport so `image-diff` compares like-for-like:
+
+```
+agent-browser set viewport 1280 720      # width height (add a third arg, e.g. 2, for retina scale)
+agent-browser screenshot actual.png      # add --full for full-page, --screenshot-dir ./shots for a custom dir
+```
+
+Then feed the PNG into the diff exactly as in Step 2:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" image-diff <reference.png> actual.png
+```
+
+Match the viewport numbers to whatever the reference/mock was captured at; mismatched
+dimensions make `dimensionsMatch` false and inflate `diffRatio`. Run `agent-browser --help`
+for the full command set (navigation, batch, annotate, format/quality flags).

package/packages/shared-skills/skills/visual-qa/scripts/skill-prompt-contract.test.ts

@@ -5,6 +5,15 @@ import { dirname, join } from "node:path"
 const repoRoot = findRepoRoot(import.meta.dir)
 const sharedSkillPath = join(repoRoot, "packages", "shared-skills", "skills", "visual-qa", "SKILL.md")
 const codexSkillPath = join(repoRoot, "packages", "omo-codex", "plugin", "skills", "visual-qa", "SKILL.md")
+const referencesPath = join(
+	repoRoot,
+	"packages",
+	"shared-skills",
+	"skills",
+	"visual-qa",
+	"references",
+	"agent-browser-setup.md",
+)
 
 type PromptFixture = {
 	readonly label: string
@@ -30,10 +39,11 @@ function findRepoRoot(start: string): string {
 }
 
 function fixtures(): readonly PromptFixture[] {
-	return [
-		{ label: "shared skill", text: readPrompt(sharedSkillPath) },
-		{ label: "codex plugin copy", text: readPrompt(codexSkillPath) },
-	]
+	const promptFixtures: PromptFixture[] = [{ label: "shared skill", text: readPrompt(sharedSkillPath) }]
+	if (existsSync(codexSkillPath)) {
+		promptFixtures.push({ label: "codex plugin copy", text: readPrompt(codexSkillPath) })
+	}
+	return promptFixtures
 }
 
 function sectionBetween(text: string, startMarker: string, endMarker: string): string {
@@ -80,4 +90,38 @@ describe("visual-qa skill prompt contract", () => {
 			expect(outputBlock, fixture.label).toContain("BLOCKING:")
 		}
 	})
+
+	test("#given the Web capture path #when no browser tooling is configured #then it falls back to agent-browser", () => {
+		for (const fixture of fixtures()) {
+			const web = sectionBetween(fixture.text, "### Web", "### TUI")
+
+			expect(web, fixture.label).toContain("agent-browser")
+			expect(fixture.text, fixture.label).toContain("bun add -g agent-browser")
+			expect(fixture.text, fixture.label).toContain("https://github.com/vercel-labs/agent-browser")
+			expect(fixture.text, fixture.label).toContain("references/agent-browser-setup.md")
+		}
+	})
+
+	test("#given the agent-browser fallback #when documenting setup #then a references doc lists install, link, and help", () => {
+		expect(existsSync(referencesPath)).toBe(true)
+		const doc = readFileSync(referencesPath, "utf8")
+
+		expect(doc).toContain("bun add -g agent-browser")
+		expect(doc).toContain("agent-browser install")
+		expect(doc).toContain("https://github.com/vercel-labs/agent-browser")
+		expect(doc).toContain("agent-browser --help")
+	})
+
+	test("#given a clone/design-port task #when in clone-coding mode #then dual pixel + code-fidelity verification loops until both pass", () => {
+		for (const fixture of fixtures()) {
+			const cloneMode = sectionBetween(fixture.text, "## Step 5", "## Reference evidence is not the verdict")
+			const lowerCloneMode = cloneMode.toLowerCase()
+
+			expect(lowerCloneMode, fixture.label).toContain("clone")
+			expect(cloneMode, fixture.label).toContain("pixel-by-pixel")
+			expect(cloneMode, fixture.label).toContain("image-diff")
+			expect(cloneMode, fixture.label).toContain("lazycodex-clone-fidelity-reviewer")
+			expect(lowerCloneMode, fixture.label).toContain("retry")
+		}
+	})
 })

package/dist/cli/doctor/constants.d.ts

@@ -1,32 +0,0 @@
-export declare const SYMBOLS: {
-    readonly check: string;
-    readonly cross: string;
-    readonly warn: string;
-    readonly info: string;
-    readonly arrow: string;
-    readonly bullet: string;
-    readonly skip: string;
-};
-export declare const STATUS_COLORS: {
-    readonly pass: import("picocolors/types").Formatter;
-    readonly fail: import("picocolors/types").Formatter;
-    readonly warn: import("picocolors/types").Formatter;
-    readonly skip: import("picocolors/types").Formatter;
-};
-export declare const CHECK_IDS: {
-    readonly SYSTEM: "system";
-    readonly CONFIG: "config";
-    readonly TUI_PLUGIN: "tui-plugin";
-    readonly TOOLS: "tools";
-    readonly MODELS: "models";
-    readonly TEAM_MODE: "team-mode";
-    readonly CODEX: "codex";
-};
-export declare const CHECK_NAMES: Record<string, string>;
-export declare const EXIT_CODES: {
-    readonly SUCCESS: 0;
-    readonly FAILURE: 1;
-};
-export declare const MIN_OPENCODE_VERSION = "1.4.0";
-export declare const PACKAGE_NAME = "oh-my-opencode";
-export declare const OPENCODE_BINARIES: readonly ["opencode", "opencode-desktop"];

package/dist/cli/doctor/spawn-with-timeout.d.ts

@@ -1,8 +0,0 @@
-import type { SpawnOptions } from "../../shared/spawn-with-windows-hide";
-export interface SpawnWithTimeoutResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-    timedOut: boolean;
-}
-export declare function spawnWithTimeout(command: string[], options: SpawnOptions, timeoutMs?: number): Promise<SpawnWithTimeoutResult>;

package/dist/cli/doctor/types.d.ts

@@ -1,148 +0,0 @@
-export type DoctorMode = "default" | "status" | "verbose";
-export type DoctorTarget = "opencode" | "codex";
-export interface DoctorOptions {
-    mode: DoctorMode;
-    json?: boolean;
-    target?: DoctorTarget;
-}
-export interface DoctorIssue {
-    title: string;
-    description: string;
-    fix?: string;
-    affects?: string[];
-    severity: "error" | "warning";
-}
-export type CheckStatus = "pass" | "fail" | "warn" | "skip";
-export interface CheckResult {
-    name: string;
-    status: CheckStatus;
-    message: string;
-    details?: string[];
-    issues: DoctorIssue[];
-    duration?: number;
-}
-export type CheckFunction = () => Promise<CheckResult>;
-export interface CheckDefinition {
-    id: string;
-    name: string;
-    check: CheckFunction;
-    critical?: boolean;
-}
-export interface SystemInfo {
-    opencodeVersion: string | null;
-    opencodePath: string | null;
-    pluginVersion: string | null;
-    loadedVersion: string | null;
-    bunVersion: string | null;
-    configPath: string | null;
-    configValid: boolean;
-    isLocalDev: boolean;
-}
-export interface ToolsSummary {
-    lspServers: Array<{
-        id: string;
-        extensions: string[];
-    }>;
-    astGrepCli: boolean;
-    astGrepNapi: boolean;
-    commentChecker: boolean;
-    ghCli: {
-        installed: boolean;
-        authenticated: boolean;
-        username: string | null;
-    };
-    mcpBuiltin: string[];
-    mcpUser: string[];
-}
-export interface DoctorSummary {
-    total: number;
-    passed: number;
-    failed: number;
-    warnings: number;
-    skipped: number;
-    duration: number;
-}
-export interface DoctorResult {
-    results: CheckResult[];
-    systemInfo: SystemInfo;
-    tools: ToolsSummary;
-    summary: DoctorSummary;
-    exitCode: number;
-    target?: DoctorTarget;
-    codex?: CodexDoctorSummary;
-}
-export interface CodexConfigSummary {
-    readonly exists: boolean;
-    readonly marketplaceConfigured: boolean;
-    readonly pluginEnabled: boolean;
-    readonly pluginsFeatureEnabled: boolean;
-    readonly pluginHooksFeatureEnabled: boolean;
-}
-export interface CodexDoctorSummary {
-    readonly codexPath: string | null;
-    readonly codexSource: string | null;
-    readonly codexAppId: string | null;
-    readonly marketplaceName: string;
-    readonly pluginName: string;
-    readonly pluginVersion: string | null;
-    readonly pluginVersionStamped: boolean;
-    readonly installerVersion: string;
-    readonly packageName: string | null;
-    readonly packageVersion: string | null;
-    readonly pluginRoot: string | null;
-    readonly configPath: string;
-    readonly config: CodexConfigSummary;
-    readonly linkedBins: readonly string[];
-    readonly agents: readonly string[];
-}
-export type CheckCategory = "installation" | "configuration" | "authentication" | "dependencies" | "tools" | "updates";
-export interface OpenCodeInfo {
-    installed: boolean;
-    version: string | null;
-    path: string | null;
-    binary: "opencode" | "opencode-desktop" | null;
-}
-export interface PluginInfo {
-    registered: boolean;
-    configPath: string | null;
-    entry: string | null;
-    isPinned: boolean;
-    pinnedVersion: string | null;
-}
-export interface ConfigInfo {
-    exists: boolean;
-    path: string | null;
-    format: "json" | "jsonc" | null;
-    valid: boolean;
-    errors: string[];
-}
-export type AuthProviderId = "anthropic" | "openai" | "google";
-export interface AuthProviderInfo {
-    id: AuthProviderId;
-    name: string;
-    pluginInstalled: boolean;
-    configured: boolean;
-    error?: string;
-}
-export interface DependencyInfo {
-    name: string;
-    required: boolean;
-    installed: boolean;
-    version: string | null;
-    path: string | null;
-    installHint?: string;
-}
-export interface McpServerInfo {
-    id: string;
-    type: "builtin" | "user";
-    enabled: boolean;
-    valid: boolean;
-    error?: string;
-}
-export interface VersionCheckInfo {
-    currentVersion: string | null;
-    latestVersion: string | null;
-    isUpToDate: boolean;
-    isLocalDev: boolean;
-    isPinned: boolean;
-}

package/dist/features/builtin-skills/skills/frontend-ui-ux.d.ts

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

package/dist/hooks/session-recovery/constants.d.ts

@@ -1,4 +0,0 @@
-export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared";
-export declare const THINKING_TYPES: Set<string>;
-export declare const META_TYPES: Set<string>;
-export declare const CONTENT_TYPES: Set<string>;

package/dist/hooks/session-recovery/detect-error-type.d.ts

@@ -1,4 +0,0 @@
-export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "thinking_block_modified" | "assistant_prefill_unsupported" | "unavailable_tool" | null;
-export declare function extractMessageIndex(error: unknown): number | null;
-export declare function extractUnavailableToolName(error: unknown): string | null;
-export declare function detectErrorType(error: unknown): RecoveryErrorType;

package/dist/hooks/session-recovery/error-recovery.d.ts

@@ -1,4 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import type { ExperimentalConfig } from "../../config";
-import type { MessageInfo, SessionRecoveryCallbacks } from "./hook-types";
-export declare function createSessionErrorRecoveryHandler(ctx: PluginInput, callbacks: SessionRecoveryCallbacks, experimental?: ExperimentalConfig): (info: MessageInfo) => Promise<boolean>;