oh-my-harness 0.14.0 → 0.16.0

package/README.md

@@ -60,8 +60,30 @@ omh init "Android Kotlin app with Hilt, JUnit, Gradle"
 omh catalog list
 omh test          # Dry-run verify your harness
 omh stats         # TUI analytics dashboard
+omh diff          # Preview what `omh sync` would change
+omh sync --check  # Fail (exit 1) if generated files are out of date — CI gate
 ```
 
+### 🔄 Keeping generated files in sync
+
+`harness.yaml` is the source of truth, so the committed `CLAUDE.md`, hooks, and
+runtime configs can drift if someone edits `harness.yaml` without re-running
+`omh sync`. Three commands keep them honest:
+
+| Command | Use |
+|---------|-----|
+| `omh sync --check` | CI gate — exits non-zero (and lists the files) when generated output is stale, writes nothing |
+| `omh diff` | Human preview of exactly what `omh sync` would change |
+| `omh doctor --strict` | Health check that also fails on drift (plain `omh doctor` warns) |
+
+```yaml
+# .github/workflows/ci.yml
+- run: npx oh-my-harness sync --check   # fails the build if the harness is out of date
+```
+
+The hook manifest records the oh-my-harness version that generated it, so an
+upgrade that changes output is surfaced as a "re-run `omh sync`" hint.
+
 ### 📁 What Gets Generated
 
 ```text
@@ -251,6 +273,9 @@ omh hook remove auto-pr                   # Remove a hook
 
 # 🔄 Sync & manage
 omh sync                                 # Regenerate all files from harness.yaml
+omh uninstall --dry-run                  # Preview generated-file cleanup
+omh uninstall -y                         # Remove generated files, keep user content
+omh uninstall -y --purge                 # Also remove harness.yaml
 
 # 🩺 Verify & monitor
 omh doctor                               # Health check
@@ -258,6 +283,35 @@ omh test                                  # Dry-run verify all hooks
 omh stats                                 # TUI analytics dashboard
 ```
 
+### 🧹 `omh uninstall` — Safe generated-file cleanup
+
+`omh uninstall` removes oh-my-harness generated artifacts while preserving user
+content in merged files.
+
+```bash
+omh uninstall --dry-run
+omh uninstall -y
+omh uninstall -y --purge
+```
+
+Safety behavior:
+
+- Prints the same uninstall plan for dry-run and real execution.
+- Recommends backing up before execution; use `--skip-backup-warning` only for
+  automation that already handles backups.
+- Keeps `harness.yaml` by default; `--purge` removes it.
+- Preserves user content in `CLAUDE.md`, `AGENTS.md`, `.claude/settings.json`,
+  `.codex/hooks.json`, `.codex/config.toml`, and user Pi extensions.
+- Removes only OMH-owned hook commands that point at this project's
+  `.omh/hooks` directory.
+- Warns when `.codex/config.toml` feature flags (`hooks`/`goals`) are removed,
+  because manually-owned feature settings cannot be distinguished from OMH
+  generated settings.
+- Warns that `.codex/config.toml` comments may be lost when TOML is rewritten.
+- Uses backups for modified files and restores them on stop-on-error failures;
+  `--continue-on-error` records failures and keeps applying independent
+  operations.
+
 ### 🩺 `omh doctor`
 
 ```text
@@ -418,6 +472,7 @@ oh-my-harness/
 - [x] Unified `.omh/` layout — single source of truth for hooks & state across runtimes
 - [x] Pi ([pi.dev](https://pi.dev)) emitter — bridge extension (`.pi/extensions/omh-harness.ts`) reusing the same `.omh/hooks/*.sh`
 - [x] `ask` mode — request approval before executing risky tools (Claude native prompt / Pi `ctx.ui.select`; Codex falls back to block)
+- [x] `omh uninstall` — remove generated artifacts while preserving user content
 - [ ] Community harness.yaml registry — share and reuse configs
 - [ ] `omh modify "change X"` — NL config editing
 

package/dist/cli/commands/diff.d.ts

@@ -0,0 +1,17 @@
+export interface DiffOptions {
+    projectDir?: string;
+}
+export interface DiffResult {
+    exitCode: number;
+    inSync?: boolean;
+}
+/**
+ * Minimal LCS line diff — enough to show what `omh sync` would change without
+ * pulling in a diff dependency. Returns unified-style lines (" ", "-", "+").
+ */
+export declare function unifiedDiff(oldStr: string, newStr: string): string[];
+/**
+ * `omh diff`: human-readable preview of what `omh sync` would change, without
+ * writing anything.
+ */
+export declare function diffCommand(options?: DiffOptions): Promise<DiffResult>;

package/dist/cli/commands/diff.js

@@ -0,0 +1,88 @@
+import chalk from "chalk";
+import { computeDrift, HarnessNotFoundError } from "../../core/drift.js";
+/**
+ * Minimal LCS line diff — enough to show what `omh sync` would change without
+ * pulling in a diff dependency. Returns unified-style lines (" ", "-", "+").
+ */
+export function unifiedDiff(oldStr, newStr) {
+    const a = oldStr.split("\n");
+    const b = newStr.split("\n");
+    const n = a.length;
+    const m = b.length;
+    // LCS length table.
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (a[i] === b[j]) {
+            out.push(`  ${a[i]}`);
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            out.push(`- ${a[i]}`);
+            i++;
+        }
+        else {
+            out.push(`+ ${b[j]}`);
+            j++;
+        }
+    }
+    while (i < n)
+        out.push(`- ${a[i++]}`);
+    while (j < m)
+        out.push(`+ ${b[j++]}`);
+    return out;
+}
+function printChange(change) {
+    const header = change.kind === "create" ? `+++ ${change.path} (new)` : `~~~ ${change.path}`;
+    console.log(chalk.bold(header));
+    const lines = unifiedDiff(change.current ?? "", change.planned);
+    for (const line of lines) {
+        if (line.startsWith("+"))
+            console.log(chalk.green(line));
+        else if (line.startsWith("-"))
+            console.log(chalk.red(line));
+        else
+            console.log(chalk.dim(line));
+    }
+    console.log("");
+}
+/**
+ * `omh diff`: human-readable preview of what `omh sync` would change, without
+ * writing anything.
+ */
+export async function diffCommand(options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    let drift;
+    try {
+        drift = await computeDrift(projectDir);
+    }
+    catch (err) {
+        if (err instanceof HarnessNotFoundError) {
+            console.error(chalk.red(err.message));
+            console.error("Run `oh-my-harness init` to create one.");
+        }
+        else {
+            console.error(chalk.red(`omh diff failed: ${err.message}`));
+        }
+        return { exitCode: 1 };
+    }
+    if (drift.inSync) {
+        console.log(chalk.green("oh-my-harness: no changes — generated files are up to date"));
+        return { exitCode: 0, inSync: true };
+    }
+    for (const change of drift.changed) {
+        printChange(change);
+    }
+    for (const stale of drift.wouldDelete) {
+        console.log(chalk.red(`--- ${stale} (would be removed)`));
+    }
+    return { exitCode: 0, inSync: false };
+}

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

@@ -1,5 +1,7 @@
 export interface DoctorOptions {
     projectDir?: string;
+    /** When true, treat drift (out-of-sync generated files) as a health failure. */
+    strict?: boolean;
 }
 export interface DoctorResult {
     healthy: boolean;
@@ -13,6 +15,12 @@ export interface DoctorResult {
         piConfig: boolean;
         hooksExecutable: boolean;
     };
+    /**
+     * Whether generated files are up to date with harness.yaml. undefined when
+     * there is no harness.yaml (drift not evaluated). Drift is a non-fatal
+     * warning unless `strict` is set.
+     */
+    inSync?: boolean;
     messages: string[];
 }
 export declare function doctorCommand(options?: DoctorOptions): Promise<DoctorResult>;

package/dist/cli/commands/doctor.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { parse } from "smol-toml";
 import { OMH_HOOKS_DIR } from "../../utils/paths.js";
+import { computeDrift, HarnessNotFoundError } from "../../core/drift.js";
 export async function doctorCommand(options = {}) {
     const projectDir = options.projectDir ?? process.cwd();
     const messages = [];
@@ -132,10 +133,35 @@ export async function doctorCommand(options = {}) {
         // No hooks dir — acceptable if no hooks defined
         checks.hooksExecutable = true;
     }
-    const healthy = Object.values(checks).every(Boolean);
+    // 8. Drift: are generated files up to date with harness.yaml? Only evaluated
+    // when a harness.yaml is present. Non-fatal by default (a warning), fatal
+    // under --strict so CI can gate on it.
+    let inSync;
+    try {
+        const drift = await computeDrift(projectDir);
+        inSync = drift.inSync;
+        if (!drift.inSync) {
+            messages.push(`${options.strict ? "FAIL" : "WARN"}: generated files are out of sync with harness.yaml — run \`omh sync\`.`);
+        }
+        else if (drift.versionDrift) {
+            messages.push(`WARN: harness generated by oh-my-harness ${drift.versionDrift.manifestVersion}, ` +
+                `now running ${drift.versionDrift.currentVersion} — run \`omh sync\` to refresh.`);
+        }
+    }
+    catch (err) {
+        if (!(err instanceof HarnessNotFoundError)) {
+            messages.push(`WARN: could not evaluate sync status: ${err.message}`);
+        }
+        // No harness.yaml → leave inSync undefined (drift not applicable).
+    }
+    const checksHealthy = Object.values(checks).every(Boolean);
+    const healthy = checksHealthy && (!options.strict || inSync !== false);
     const exitCode = healthy ? 0 : 1;
     if (healthy) {
         console.log("oh-my-harness: all checks passed");
+        for (const msg of messages) {
+            console.log(`  ${msg}`);
+        }
     }
     else {
         console.log("oh-my-harness: some checks failed:");
@@ -143,5 +169,5 @@ export async function doctorCommand(options = {}) {
             console.log(`  ${msg}`);
         }
     }
-    return { healthy, exitCode, checks, messages };
+    return { healthy, exitCode, checks, inSync, messages };
 }

package/dist/cli/commands/sync.d.ts

@@ -1,4 +1,10 @@
 export interface SyncOptions {
     projectDir?: string;
+    /** When true, report drift without writing and exit non-zero if out of date. */
+    check?: boolean;
 }
-export declare function syncCommand(options?: SyncOptions): Promise<void>;
+export interface SyncResult {
+    exitCode: number;
+    inSync?: boolean;
+}
+export declare function syncCommand(options?: SyncOptions): Promise<SyncResult>;

package/dist/cli/commands/sync.js

@@ -5,10 +5,14 @@ import chalk from "chalk";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
 import { harnessToMergedConfigV2 } from "../../core/harness-converter-v2.js";
 import { generate } from "../../core/generator.js";
+import { computeDrift, HarnessNotFoundError } from "../../core/drift.js";
 import { writeHarnessState } from "./init.js";
 export async function syncCommand(options = {}) {
     const projectDir = options.projectDir ?? process.cwd();
     const harnessYamlPath = path.join(projectDir, "harness.yaml");
+    if (options.check) {
+        return runCheck(projectDir);
+    }
     let raw;
     try {
         raw = await fs.readFile(harnessYamlPath, "utf-8");
@@ -22,8 +26,7 @@ export async function syncCommand(options = {}) {
         else {
             console.error(chalk.red(`Failed to read harness.yaml: ${error.message}`));
         }
-        process.exit(1);
-        return;
+        return { exitCode: 1 };
     }
     let parsed;
     try {
@@ -32,8 +35,7 @@ export async function syncCommand(options = {}) {
     catch (err) {
         const error = err;
         console.error(chalk.red(`Failed to parse harness.yaml: ${error.message}`));
-        process.exit(1);
-        return;
+        return { exitCode: 1 };
     }
     const result = HarnessConfigSchema.safeParse(parsed);
     if (!result.success) {
@@ -41,8 +43,7 @@ export async function syncCommand(options = {}) {
         for (const issue of result.error.issues) {
             console.error(`  ${issue.path.join(".")}: ${issue.message}`);
         }
-        process.exit(1);
-        return;
+        return { exitCode: 1 };
     }
     const harness = result.data;
     const mergedV2 = await harnessToMergedConfigV2(harness, undefined, projectDir);
@@ -58,4 +59,43 @@ export async function syncCommand(options = {}) {
     for (const f of genResult.files) {
         console.log(`  ${f}`);
     }
+    return { exitCode: 0 };
+}
+/**
+ * `omh sync --check`: report whether generated files are up to date with
+ * harness.yaml without writing anything. exitCode 0 = in sync, 1 = drift (or a
+ * harness.yaml problem). CI-friendly, like `prettier --check`.
+ */
+async function runCheck(projectDir) {
+    let drift;
+    try {
+        drift = await computeDrift(projectDir);
+    }
+    catch (err) {
+        if (err instanceof HarnessNotFoundError) {
+            console.error(chalk.red(err.message));
+            console.error("Run `oh-my-harness init` to create one.");
+        }
+        else {
+            console.error(chalk.red(`sync --check failed: ${err.message}`));
+        }
+        return { exitCode: 1 };
+    }
+    if (drift.inSync) {
+        console.log(chalk.green("oh-my-harness: up to date"));
+        if (drift.versionDrift) {
+            console.log(chalk.yellow(`  ⚠ generated by oh-my-harness ${drift.versionDrift.manifestVersion}, ` +
+                `now running ${drift.versionDrift.currentVersion} — re-run \`omh sync\` to refresh.`));
+        }
+        return { exitCode: 0, inSync: true };
+    }
+    console.error(chalk.red("oh-my-harness: out of sync — run `omh sync`"));
+    for (const change of drift.changed) {
+        const label = change.kind === "create" ? "would create" : "would update";
+        console.error(`  ${label}: ${change.path}`);
+    }
+    for (const stale of drift.wouldDelete) {
+        console.error(`  would delete: ${stale}`);
+    }
+    return { exitCode: 1, inSync: false };
 }

package/dist/cli/commands/uninstall.d.ts

@@ -0,0 +1,16 @@
+import { type UninstallPlan, type UninstallResult } from "../../core/uninstall.js";
+export interface UninstallOptions {
+    projectDir?: string;
+    dryRun?: boolean;
+    yes?: boolean;
+    purge?: boolean;
+    skipBackupWarning?: boolean;
+    continueOnError?: boolean;
+}
+export interface UninstallCommandResult {
+    exitCode: number;
+    plan: UninstallPlan;
+    result?: UninstallResult;
+}
+export declare function renderUninstallPlan(plan: UninstallPlan, options?: UninstallOptions): string;
+export declare function uninstallCommand(options?: UninstallOptions): Promise<UninstallCommandResult>;

package/dist/cli/commands/uninstall.js

@@ -0,0 +1,76 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { applyUninstallPlan, computeUninstall, } from "../../core/uninstall.js";
+function visibleWarnings(plan, options) {
+    return plan.destructiveWarnings.filter((warning) => !(options.skipBackupWarning && warning.includes("백업 후 실행 권장")));
+}
+export function renderUninstallPlan(plan, options = {}) {
+    const warnings = visibleWarnings(plan, options);
+    const lines = [
+        "oh-my-harness uninstall plan",
+        `- delete: ${plan.delete.length} files/directories`,
+        `- modify: ${plan.modify.length} files`,
+        `- keep: ${plan.keptHarnessYaml ? "harness.yaml" : "none"}`,
+        `- warnings: ${warnings.length}`,
+    ];
+    if (warnings.length > 0) {
+        lines.push("", "Safety:");
+        for (const warning of warnings)
+            lines.push(`- ${warning}`);
+    }
+    if (plan.modify.length > 0) {
+        lines.push("", "modify:");
+        for (const item of plan.modify)
+            lines.push(`  ${item.path}`);
+    }
+    if (plan.delete.length > 0) {
+        lines.push("", "delete:");
+        for (const target of plan.delete)
+            lines.push(`  ${target}`);
+    }
+    if (plan.removeDirs.length > 0) {
+        lines.push("", "remove empty dirs:");
+        for (const dir of plan.removeDirs)
+            lines.push(`  ${dir}`);
+    }
+    return lines.join("\n");
+}
+function renderResult(result) {
+    const lines = [
+        "oh-my-harness uninstall result",
+        `modified: ${result.modified.length}`,
+        `deleted: ${result.deleted.length}`,
+        `removedDirs: ${result.removedDirs.length}`,
+        `restored: ${result.restored.length}`,
+        `failed: ${result.failed.length}`,
+    ];
+    for (const failure of result.failed) {
+        lines.push(`  ${failure.op}: ${failure.path} — ${failure.message}`);
+    }
+    return lines.join("\n");
+}
+async function confirmUninstall() {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question("Proceed with uninstall? Type 'yes' to continue: ");
+        return answer.trim().toLowerCase() === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function uninstallCommand(options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    const plan = await computeUninstall({ projectDir, purge: options.purge });
+    console.log(renderUninstallPlan(plan, options));
+    if (options.dryRun) {
+        return { exitCode: 0, plan };
+    }
+    if (!options.yes && !await confirmUninstall()) {
+        console.log("oh-my-harness: uninstall cancelled");
+        return { exitCode: 1, plan };
+    }
+    const result = await applyUninstallPlan(plan, { continueOnError: options.continueOnError });
+    console.log(renderResult(result));
+    return { exitCode: result.failed.length === 0 ? 0 : 1, plan, result };
+}

package/dist/cli/index.js

@@ -31,9 +31,22 @@ export function createCli() {
     program
         .command("doctor")
         .description("Validate harness configuration health")
-        .action(async () => {
+        .option("-d, --project-dir <dir>", "Project directory")
+        .option("--strict", "Treat drift (out-of-sync generated files) as a failure")
+        .action(async (options) => {
         const { doctorCommand } = await import("./commands/doctor.js");
-        const result = await doctorCommand();
+        const result = await doctorCommand(options);
+        if (result.exitCode !== 0) {
+            process.exitCode = result.exitCode;
+        }
+    });
+    program
+        .command("diff")
+        .description("Preview what `omh sync` would change, without writing")
+        .option("-d, --project-dir <dir>", "Project directory")
+        .action(async (options) => {
+        const { diffCommand } = await import("./commands/diff.js");
+        const result = await diffCommand(options);
         if (result.exitCode !== 0) {
             process.exitCode = result.exitCode;
         }
@@ -50,9 +63,29 @@ export function createCli() {
         .command("sync")
         .description("Regenerate files from harness.yaml")
         .option("-d, --project-dir <dir>", "Project directory")
+        .option("--check", "Report drift without writing; exit non-zero if out of date")
         .action(async (options) => {
         const { syncCommand } = await import("./commands/sync.js");
-        await syncCommand(options);
+        const result = await syncCommand(options);
+        if (result.exitCode !== 0) {
+            process.exitCode = result.exitCode;
+        }
+    });
+    program
+        .command("uninstall")
+        .description("Safely remove oh-my-harness generated files while preserving user content")
+        .option("-d, --project-dir <dir>", "Project directory")
+        .option("--dry-run", "Print the uninstall plan without writing")
+        .option("-y, --yes", "Skip confirmation prompt")
+        .option("--purge", "Also delete harness.yaml")
+        .option("--skip-backup-warning", "Suppress the backup recommendation")
+        .option("--continue-on-error", "Keep applying independent operations after failures")
+        .action(async (options) => {
+        const { uninstallCommand } = await import("./commands/uninstall.js");
+        const result = await uninstallCommand(options);
+        if (result.exitCode !== 0) {
+            process.exitCode = result.exitCode;
+        }
     });
     program
         .command("stats")

package/dist/core/drift.d.ts

@@ -0,0 +1,36 @@
+export interface DriftChange {
+    path: string;
+    /** "create": file is missing on disk; "update": content differs. */
+    kind: "create" | "update";
+    /** Content sync would write. */
+    planned: string;
+    /** Current on-disk content, or null when the file is missing. */
+    current: string | null;
+}
+export interface DriftResult {
+    /** True when no files would change and nothing would be deleted. */
+    inSync: boolean;
+    changed: DriftChange[];
+    /** Absolute paths of stale files a sync would remove. */
+    wouldDelete: string[];
+    /**
+     * Set when the manifest records a different oh-my-harness version than the
+     * one running now (a cheap "re-sync recommended after upgrade" signal). null
+     * when versions match or no manifest exists.
+     */
+    versionDrift: {
+        manifestVersion: string | null;
+        currentVersion: string;
+    } | null;
+}
+/** Raised when computeDrift is asked to run on a project without a harness.yaml. */
+export declare class HarnessNotFoundError extends Error {
+    readonly harnessPath: string;
+    constructor(harnessPath: string);
+}
+/**
+ * Compare what a sync would produce against the files currently on disk, without
+ * writing anything. Reads harness.yaml, builds the merged config, runs the
+ * generator in plan mode, and diffs each planned file against disk.
+ */
+export declare function computeDrift(projectDir: string): Promise<DriftResult>;

package/dist/core/drift.js

@@ -0,0 +1,69 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { HarnessConfigSchema } from "./harness-schema.js";
+import { harnessToMergedConfigV2 } from "./harness-converter-v2.js";
+import { planGenerate } from "./generator.js";
+import { OMH_MANIFEST } from "../utils/paths.js";
+import { OMH_VERSION } from "../utils/version.js";
+/** Raised when computeDrift is asked to run on a project without a harness.yaml. */
+export class HarnessNotFoundError extends Error {
+    harnessPath;
+    constructor(harnessPath) {
+        super(`harness.yaml not found at ${harnessPath}`);
+        this.harnessPath = harnessPath;
+        this.name = "HarnessNotFoundError";
+    }
+}
+async function readFileOrNull(path) {
+    try {
+        return await readFile(path, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+async function readManifestVersion(projectDir) {
+    const raw = await readFileOrNull(join(projectDir, OMH_MANIFEST));
+    if (raw === null)
+        return null;
+    try {
+        const manifest = JSON.parse(raw);
+        return typeof manifest.omhVersion === "string" ? manifest.omhVersion : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare what a sync would produce against the files currently on disk, without
+ * writing anything. Reads harness.yaml, builds the merged config, runs the
+ * generator in plan mode, and diffs each planned file against disk.
+ */
+export async function computeDrift(projectDir) {
+    const harnessPath = join(projectDir, "harness.yaml");
+    const raw = await readFileOrNull(harnessPath);
+    if (raw === null)
+        throw new HarnessNotFoundError(harnessPath);
+    const parsed = HarnessConfigSchema.parse(yaml.load(raw));
+    const config = await harnessToMergedConfigV2(parsed, undefined, projectDir);
+    const plan = await planGenerate({ projectDir, config });
+    const changed = [];
+    for (const file of plan.files) {
+        const current = await readFileOrNull(file.path);
+        if (current === null) {
+            changed.push({ path: file.path, kind: "create", planned: file.content, current: null });
+        }
+        else if (current !== file.content) {
+            changed.push({ path: file.path, kind: "update", planned: file.content, current });
+        }
+    }
+    const manifestVersion = await readManifestVersion(projectDir);
+    const versionDrift = manifestVersion !== null && manifestVersion !== OMH_VERSION
+        ? { manifestVersion, currentVersion: OMH_VERSION }
+        : null;
+    const inSync = changed.length === 0 && plan.wouldDelete.length === 0;
+    return { inSync, changed, wouldDelete: plan.wouldDelete, versionDrift };
+}

package/dist/core/generator.d.ts

@@ -1,4 +1,5 @@
 import type { MergedConfig } from "./merged-config.js";
+import type { GenerationPlan } from "./plan.js";
 export interface GenerateOptions {
     projectDir: string;
     config: MergedConfig;
@@ -7,3 +8,14 @@ export interface GenerateResult {
     files: string[];
 }
 export declare function generate(options: GenerateOptions): Promise<GenerateResult>;
+/**
+ * Compute every file `generate()` would write — and the stale files it would
+ * remove — WITHOUT touching disk. Backs `omh sync --check`, `omh diff`, and the
+ * doctor drift warning. Uses the same compute functions as the write path, so
+ * the plan can never disagree with what a real sync produces.
+ *
+ * The bookkeeping files that embed timestamps (.omh/manifest.json and
+ * .claude/oh-my-harness.json) are intentionally excluded — they change every
+ * run and are not part of the reproducible harness output.
+ */
+export declare function planGenerate(options: GenerateOptions): Promise<GenerationPlan>;