@happy-nut/monacori 0.1.3 → 0.1.5

package/README.md

@@ -1,24 +1,10 @@
 # monacori
 
-**Validation control plane for AI-generated code changes.** After an AI edits your repository, `monacori` produces verification evidence a human can actually trust.
-
-It is *not* an agent orchestrator. It does not manage panes, sessions, worktrees, or model adapters. Its job is narrow on purpose: validate what the AI just did.
+**A local desktop diff-review app for AI-generated code changes.** After an AI edits your repo, run `mo` to open a side-by-side diff — read it, comment on it, and send your comments straight to an AI CLI running in the built-in terminal.
 
 ## Why
 
-AI coding output is hard to trust when review depends on chat memory or a vague "done" claim. `monacori` keeps the review artifacts inside the repository, so the state of a change can be inspected, rerun, and discussed instead of taken on faith.
-
-The loop is simple:
-
-```text
-AI edits code.
-monacori runs verification.
-monacori creates a reviewable diff artifact.
-You inspect the evidence before accepting the change.
-```
-
-![Diff review](assets/screenshots/diff-review.png)
-*Local desktop review app: side-by-side diff with changed lines highlighted and IntelliJ-style git status colors in the sidebar.*
+A chat log or a "done" claim is a poor way to review what an AI changed. monacori puts the change in front of you as a real diff you can read and annotate — then turns your comments into a prompt you hand right back to `claude` or `codex`, without leaving the app or copy-pasting between windows.
 
 ## Install
 
@@ -30,21 +16,16 @@ After install, the short command is `mo`. A Homebrew tap (`happy-nut/monacori/mo
 
 ## What you get
 
-- **Local desktop review app** — diff review with changed-line highlighting and an IntelliJ-style sidebar that colors files by git status. Reads the repo directly, refreshes on change, no HTTP server.
-- **Integrated terminal** — run AI CLIs like `claude` or `codex` inside the app, and send a "merged prompt" (your question or fix request bundled with the relevant code context) straight to the session.
-- **Inline comments** — annotate the diff while you review.
-- **Verification logs & reports** — repeatable verification under `.monacori/logs/` and compact validation reports under `.monacori/reports/`.
-
-![Integrated terminal](assets/screenshots/terminal.png)
-*Run your AI CLI inside the review app, next to the diff it just produced.*
+- **Desktop diff review** — side-by-side diff with changed-line highlighting and an IntelliJ-style sidebar that colors files by git status. Reads the repo directly, refreshes on change, no HTTP server.
+- **Integrated terminal** — run AI CLIs like `claude` or `codex` right inside the app, split into panes.
+- **Comments → session** — annotate any line, then send your comments (bundled with their code context) into a terminal pane as one merged prompt: pick the target pane visually and press Enter.
 
 ## Quick start
 
-Inside the repository you want to validate:
+Inside the repository you want to review:
 
 ```bash
-mo                              # open the desktop review app for the current dir
-monacori check --include-untracked   # run verification, write a log, diff, and report
+mo
 ```
 
 On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes untracked files so new AI-created files show up immediately.
@@ -53,36 +34,21 @@ On first run, `mo` creates `.monacori/`, adds it to `.gitignore`, and includes u
 
 | Command | What it does |
 | --- | --- |
-| `mo` | Open the desktop review app (alias for `monacori open`). |
-| `monacori check` | Run verification, then create a diff and a validation report. `-- <cmd>` overrides commands for one run. |
-| `monacori verify` | Run configured verification commands and store the log. Exits non-zero on failure. |
-| `monacori diff` | Generate a browser-based side-by-side diff page. `--watch` serves a live-reloading review. |
+| `mo` | Open the desktop diff-review app (alias for `monacori open`). |
 | `monacori app` | Launch the desktop review app (same as `mo`). |
-| `monacori report` | Store a manual report under `.monacori/reports/`. |
-| `monacori status` | Print branch, git status, diff stat, verification commands, and recent reports/logs. |
+| `monacori init` | Initialize `.monacori/` in the current directory. |
+| `monacori install` | Initialize and write agent instruction snippets. `--apply-agent-docs` patches `AGENTS.md` / `CLAUDE.md`. |
 
 ## Repository state
 
-`monacori init` (run automatically by `mo`) creates:
-
-```text
-.monacori/
-  config.json   verification commands and diff defaults
-  state.md      compact validation history
-  diffs/        generated browser diff reviews
-  reports/      validation reports
-  logs/         verification logs
-```
-
-Keep `.monacori/` ignored unless your team explicitly wants to commit validation state.
+`monacori init` (run automatically by `mo`) creates a git-ignored `.monacori/` directory holding generated diff reviews and local config. Keep it ignored unless your team explicitly wants to commit review state.
 
 ## Design principles
 
-- Verification evidence beats chat memory.
-- Generated artifacts are plain Markdown, JSON, logs, or static HTML.
+- A real diff beats a chat log or a "done" claim.
+- Review, comment, and hand-off live in one window — no copy-paste loop.
+- Generated artifacts are plain static HTML and JSON.
 - No required AI agent, terminal multiplexer, editor, or worktree strategy.
-- The default command should be useful after any AI-generated edit.
-- A change is not accepted until the evidence is clear or the gap is documented.
 
 ## License
 

package/dist/app-main.js

@@ -71,8 +71,37 @@ ipcMain.handle("monacori:pty-spawn", (_event, size) => {
         if (mainWindow && !mainWindow.isDestroyed())
             mainWindow.webContents.send(channel, payload);
     };
-    t.onData((data) => deliver("monacori:pty-data", { id, data }));
-    t.onExit(() => { terms.delete(id); deliver("monacori:pty-exit", { id }); });
+    // pty output can arrive as many tiny chunks (thousands/sec under fast output). One IPC per chunk floods
+    // the renderer, so coalesce: buffer chunks and flush on a short timer, or immediately once the buffer is
+    // large — bounding both IPC traffic and added latency.
+    let outBuf = "";
+    let flushTimer;
+    const flushOut = () => {
+        flushTimer = undefined;
+        if (!outBuf)
+            return;
+        const data = outBuf;
+        outBuf = "";
+        deliver("monacori:pty-data", { id, data });
+    };
+    t.onData((data) => {
+        outBuf += data;
+        if (outBuf.length >= 64 * 1024) {
+            if (flushTimer)
+                clearTimeout(flushTimer);
+            flushOut();
+        }
+        else if (!flushTimer) {
+            flushTimer = setTimeout(flushOut, 12);
+        }
+    });
+    t.onExit(() => {
+        if (flushTimer)
+            clearTimeout(flushTimer);
+        flushOut(); // deliver any buffered tail before signaling exit
+        terms.delete(id);
+        deliver("monacori:pty-exit", { id });
+    });
     return { ok: true, id };
 });
 ipcMain.on("monacori:pty-write", (_event, msg) => { terms.get(msg?.id)?.write(msg.data); });
@@ -151,6 +180,8 @@ app.whenReady().then(async () => {
         submenu: [
             { label: "All questions", accelerator: "Control+Command+Shift+/", click: () => sendMerged("q") },
             { label: "All change requests", accelerator: "Control+Command+Shift+.", click: () => sendMerged("c") },
+            // Cmd/Ctrl+Shift+N opens (and toggles) the single freeform prompt memo — a Markdown scratchpad.
+            { label: "Prompt memo", accelerator: "CommandOrControl+Shift+N", click: () => mainWindow?.webContents.send("monacori:open-memo") },
             { type: "separator" },
             // Whitespace-ignore re-runs git diff with --ignore-all-space and reloads (main-process action,
             // so a menu checkbox is simpler than a renderer IPC round-trip).
@@ -190,7 +221,7 @@ app.whenReady().then(async () => {
             { type: "separator" },
             { label: "Focus Previous Pane", accelerator: "CommandOrControl+Alt+[", click: () => mainWindow?.webContents.send("monacori:terminal-pane-focus", -1) },
             { label: "Focus Next Pane", accelerator: "CommandOrControl+Alt+]", click: () => mainWindow?.webContents.send("monacori:terminal-pane-focus", 1) },
-            { label: "Rename Pane", accelerator: "F2", click: () => mainWindow?.webContents.send("monacori:terminal-pane-rename") },
+            { label: "Rename Pane", accelerator: "CommandOrControl+Alt+R", click: () => mainWindow?.webContents.send("monacori:terminal-pane-rename") },
         ],
     });
     Menu.setApplicationMenu(Menu.buildFromTemplate(menuTemplate));
@@ -222,7 +253,10 @@ app.whenReady().then(async () => {
     // paint and swap it in. The first build used to run synchronously *before* the window existed, so the
     // screen stayed blank for the first few seconds of startup; now the user sees a loading screen instead.
     await mainWindow.loadURL("data:text/html;charset=utf-8," + encodeURIComponent(LOADING_HTML));
-    setImmediate(() => {
+    // Give the loading spinner a few frames to actually paint before the (synchronous) first build blocks
+    // the main process — otherwise the spinner looks frozen until the build finishes. The boot overlay in
+    // the review HTML then takes over, so there's no blank gap when loadFile swaps the page in.
+    setTimeout(() => {
         try {
             const firstBuild = writeReviewFile(options);
             currentSignature = firstBuild.signature;
@@ -235,7 +269,7 @@ app.whenReady().then(async () => {
             console.error(error instanceof Error ? error.message : String(error));
             app.quit();
         }
-    });
+    }, 60);
 }).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     app.quit();
@@ -260,7 +294,13 @@ async function refreshIfChanged() {
         const next = writeReviewFile(options);
         if (next.signature !== currentSignature) {
             currentSignature = next.signature;
-            mainWindow.webContents.reloadIgnoringCache();
+            // Refresh the diff in place instead of reloading the window. A full reload re-runs the renderer,
+            // whose beforeunload kills every pty — so an integrated terminal running claude/codex would die on
+            // each working-tree change. We send only the compact update payload (diff/trees/status/data — no
+            // xterm blob), and the renderer transplants it + re-fetches per-file bodies/source over the existing
+            // IPC (currentBodies/currentSourceData were just refreshed by writeReviewFile above).
+            if (next.update)
+                mainWindow.webContents.send("monacori:diff-update", next.update);
         }
     }
     catch (error) {
@@ -284,7 +324,7 @@ function writeReviewFile(input) {
     writeFileSync(reviewPath(), build.html);
     currentBodies = build.lazyBodies ?? [];
     currentSourceData = build.lazySourceData ?? "[]";
-    return { signature: build.signature };
+    return { signature: build.signature, html: build.html, update: build.update };
 }
 function reviewPath() {
     return join(options.root, FLOW_DIR, REVIEW_FILE);

package/dist/build.js

@@ -3,7 +3,7 @@ import { basename } from "node:path";
 import { isGitRepository } from "./git.js";
 import { collectHttpEnvironments, collectReviewFileStates, collectSourceFiles, parseUnifiedDiff, readUnifiedDiff } from "./diff.js";
 import { renderDiff2Html } from "./highlight.js";
-import { diffSubtitle, renderDiffHtml, renderNotGitRepoHtml, shouldLazyRender, splitDiffForLazy } from "./render.js";
+import { diffSubtitle, renderDiffHtml, renderDiffTree, renderNotGitRepoHtml, renderReviewStatus, renderSourceTree, shouldLazyRender, splitDiffForLazy } from "./render.js";
 export function buildDiffReview(input) {
     if (!isGitRepository(process.cwd())) {
         return {
@@ -65,6 +65,27 @@ export function buildDiffReview(input) {
         signature,
         generatedAt,
     });
+    // Compact payload for in-place refresh: just the regions the renderer swaps on a watch change. Reuses
+    // the same fragment renderers as the full page, minus the heavy bits (xterm blob, embedded source).
+    const update = {
+        signature,
+        generatedAt,
+        diffContainer: diffSplit.container || '<div class="empty" data-i18n="diff.noDiff">No diff to review.</div>',
+        changesPanel: renderDiffTree(files),
+        filesTree: renderSourceTree(sourceFiles),
+        reviewStatus: renderReviewStatus({
+            files: files.length,
+            hunks,
+            embeddedFiles: sourceFiles.filter((file) => file.embedded).length,
+            sourceFileCount: sourceFiles.length,
+            ignoreWhitespace: input.ignoreWhitespace,
+            watch: input.watch,
+            generatedAt,
+        }),
+        fileStates,
+        sourceFilesMeta: lazyLoad ? sourceFiles.map((file) => ({ ...file, content: "", image: "" })) : sourceFiles,
+        httpEnvironments,
+    };
     return {
         html,
         files: files.length,
@@ -73,5 +94,6 @@ export function buildDiffReview(input) {
         generatedAt,
         lazyBodies: diffSplit.bodies,
         lazySourceData: lazyLoad ? JSON.stringify(sourceFiles) : undefined,
+        update,
     };
 }

package/dist/commands.js

@@ -1,12 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { AGENT_SNIPPET_FILE, CONFIG_FILE, DECISIONS_FILE, FLOW_DIR, GITIGNORE_FILE, STATE_FILE } from "./constants.js";
-import { codeBlock, listRecentFiles, parsePositiveInteger, readOption, readStdin, sanitizeFilePart, summarizeForState, timestampForFile } from "./util.js";
-import { git, readGitSnapshot } from "./git.js";
-import { createDiffReview, serveDiffWatch } from "./server.js";
+import { parsePositiveInteger, readOption } from "./util.js";
+import { git } from "./git.js";
 const nodeRequire = createRequire(import.meta.url);
 export function main() {
     const rawArgs = process.argv.slice(2);
@@ -27,16 +26,6 @@ export function main() {
             case "install":
                 installFlow(args);
                 break;
-            case "check":
-            case "go":
-                runCheck(args);
-                break;
-            case "verify":
-                runVerification(args);
-                break;
-            case "diff":
-                renderDiffReview(args);
-                break;
             case "app":
             case "review":
                 launchReviewApp(args);
@@ -44,12 +33,6 @@ export function main() {
             case "open":
                 openCurrentRepository(args);
                 break;
-            case "status":
-                printStatus();
-                break;
-            case "report":
-                recordReport(args);
-                break;
             case "--help":
             case "-h":
             case "help":
@@ -94,7 +77,7 @@ function initFlow(args) {
         if (ignored) {
             console.log(`Updated ${GITIGNORE_FILE} to ignore ${FLOW_DIR}/ validation artifacts.`);
         }
-        console.log("Next: run `monacori app --include-untracked` to inspect changes, then `monacori check --include-untracked` to record verification.");
+        console.log("Next: run `mo` to open the diff review app.");
     }
 }
 function installFlow(args) {
@@ -115,117 +98,6 @@ function installFlow(args) {
         console.log(`Next: add ${FLOW_DIR}/${AGENT_SNIPPET_FILE} to your agent instructions if desired.`);
     }
 }
-function runCheck(args) {
-    if (args.includes("--help") || args.includes("-h")) {
-        printCheckHelp();
-        return;
-    }
-    ensureWritableFlowState();
-    const config = loadConfig();
-    const separator = args.indexOf("--");
-    const commandArgs = separator >= 0 ? args.slice(separator + 1) : [];
-    const optionArgs = separator >= 0 ? args.slice(0, separator) : args;
-    const noVerify = optionArgs.includes("--no-verify");
-    const noDiff = optionArgs.includes("--no-diff");
-    const openInBrowser = optionArgs.includes("--open");
-    const includeUntracked = optionArgs.includes("--include-untracked") || config.diff.includeUntracked;
-    const staged = optionArgs.includes("--staged");
-    const base = readOption(optionArgs, "--base");
-    const contextValue = readOption(optionArgs, "--context");
-    const context = contextValue ? parsePositiveInteger(contextValue, "--context") : config.diff.context;
-    const verification = noVerify
-        ? { commands: [], failed: false, skipped: true }
-        : executeVerification(commandArgs.join(" "));
-    let review;
-    if (!noDiff) {
-        review = createDiffReview({
-            base,
-            staged,
-            includeUntracked,
-            context,
-            output: join(process.cwd(), FLOW_DIR, "diffs", `${timestampForFile()}-check.html`),
-            title: "monacori validation diff",
-        });
-        if (openInBrowser) {
-            spawnSync("open", [review.path], { stdio: "ignore" });
-        }
-    }
-    const reportPath = writeCheckReport({ verification, review });
-    console.log("# monacori check");
-    console.log(`Verification: ${verification.skipped ? "skipped" : verification.failed ? "failed" : "passed"}`);
-    if (verification.logPath) {
-        console.log(`Log: ${relative(process.cwd(), verification.logPath)}`);
-    }
-    if (review) {
-        console.log(`Diff review: ${relative(process.cwd(), review.path)}`);
-        console.log(`Files: ${review.files}`);
-        console.log(`Hunks: ${review.hunks}`);
-    }
-    console.log(`Report: ${relative(process.cwd(), reportPath)}`);
-    if (verification.failed) {
-        process.exit(1);
-    }
-}
-function runVerification(args) {
-    const separator = args.indexOf("--");
-    const explicitCommand = separator >= 0 ? args.slice(separator + 1).join(" ") : "";
-    const result = executeVerification(explicitCommand, { requireCommands: true });
-    if (result.logPath) {
-        console.log(`Verification log: ${relative(process.cwd(), result.logPath)}`);
-    }
-    if (result.failed) {
-        console.error("Verification failed.");
-        process.exit(1);
-    }
-    console.log("Verification passed.");
-}
-function renderDiffReview(args) {
-    if (args.includes("--help") || args.includes("-h")) {
-        printDiffHelp();
-        return;
-    }
-    ensureWritableFlowState();
-    const config = loadConfig();
-    const contextValue = readOption(args, "--context");
-    const context = contextValue ? parsePositiveInteger(contextValue, "--context") : config.diff.context;
-    const base = readOption(args, "--base");
-    const staged = args.includes("--staged");
-    const includeUntracked = args.includes("--include-untracked") || config.diff.includeUntracked;
-    const openInBrowser = args.includes("--open");
-    const watch = args.includes("--watch");
-    const ignoreWhitespace = args.includes("--ignore-whitespace");
-    if (watch) {
-        serveDiffWatch({
-            base,
-            staged,
-            includeUntracked,
-            context,
-            openInBrowser,
-            port: readOption(args, "--port"),
-            ignoreWhitespace,
-        });
-        return;
-    }
-    const output = readOption(args, "--output") ??
-        join(process.cwd(), FLOW_DIR, "diffs", `${timestampForFile()}-review.html`);
-    const result = createDiffReview({
-        base,
-        staged,
-        includeUntracked,
-        context,
-        output,
-        title: "monacori diff review",
-        ignoreWhitespace,
-    });
-    if (openInBrowser) {
-        spawnSync("open", [result.path], { stdio: "ignore" });
-    }
-    console.log(`Diff review: ${relative(process.cwd(), result.path)}`);
-    console.log(`URL: ${result.url}`);
-    console.log(`Files: ${result.files}`);
-    console.log(`Hunks: ${result.hunks}`);
-    console.log("Keys: F7 next hunk, Shift+F7 previous hunk, Shift Shift search files, Cmd/Ctrl+E recent files, Cmd/Ctrl+Down jump to symbol.");
-}
 function launchReviewApp(args) {
     if (args.includes("--help") || args.includes("-h")) {
         printAppHelp();
@@ -290,138 +162,6 @@ function resolveElectronBinary() {
 function appMainPath() {
     return join(dirname(fileURLToPath(import.meta.url)), "app-main.js");
 }
-function printStatus() {
-    ensureInitialized();
-    const config = loadConfig();
-    const git = readGitSnapshot(process.cwd());
-    const reports = listRecentFiles(join(process.cwd(), FLOW_DIR, "reports"), 5);
-    const logs = listRecentFiles(join(process.cwd(), FLOW_DIR, "logs"), 5);
-    console.log(`# ${config.projectName} validation status`);
-    console.log("");
-    console.log(`Branch: ${git.branch || "(unknown)"}`);
-    console.log("");
-    console.log("## Git status");
-    console.log(git.status || "clean");
-    console.log("");
-    console.log("## Diff stat");
-    console.log(git.diffStat || "no diff");
-    console.log("");
-    console.log("## Verification commands");
-    const commands = getVerificationCommands(config);
-    if (commands.length === 0) {
-        console.log("none configured");
-    }
-    else {
-        for (const command of commands) {
-            console.log(`- ${command}`);
-        }
-    }
-    console.log("");
-    console.log("## Recent reports");
-    console.log(reports.length === 0 ? "none" : reports.map((path) => `- ${relative(process.cwd(), path)}`).join("\n"));
-    console.log("");
-    console.log("## Recent logs");
-    console.log(logs.length === 0 ? "none" : logs.map((path) => `- ${relative(process.cwd(), path)}`).join("\n"));
-}
-function recordReport(args) {
-    ensureWritableFlowState();
-    const file = readOption(args, "--file");
-    const label = readOption(args, "--label") ?? "manual";
-    const body = file ? readFileSync(file, "utf8") : readStdin();
-    if (body.trim().length === 0) {
-        throw new Error("No report content provided. Pass --file or pipe report text on stdin.");
-    }
-    const timestamp = timestampForFile();
-    const reportDir = join(process.cwd(), FLOW_DIR, "reports");
-    mkdirSync(reportDir, { recursive: true });
-    const reportPath = join(reportDir, `${timestamp}-${sanitizeFilePart(label)}.md`);
-    writeFileSync(reportPath, [
-        `# Monacori Report: ${label}`,
-        "",
-        `Recorded: ${new Date().toISOString()}`,
-        "",
-        body.trim(),
-        "",
-    ].join("\n"));
-    appendToState(`\n## Report ${timestamp} (${label})\n\n${summarizeForState(body)}\n`);
-    console.log(`Recorded ${relative(process.cwd(), reportPath)}`);
-}
-function executeVerification(explicitCommand = "", options = {}) {
-    ensureWritableFlowState();
-    const config = loadConfig();
-    const commands = explicitCommand.trim() ? [explicitCommand.trim()] : getVerificationCommands(config);
-    if (commands.length === 0) {
-        if (options.requireCommands) {
-            throw new Error(`No verification commands found. Add them to ${FLOW_DIR}/${CONFIG_FILE} or pass \`-- <command>\`.`);
-        }
-        return { commands: [], failed: false, skipped: true };
-    }
-    const logPath = join(process.cwd(), FLOW_DIR, "logs", `verify-${timestampForFile()}.log`);
-    const chunks = [];
-    let failed = false;
-    for (const command of commands) {
-        chunks.push(`$ ${command}\n`);
-        const result = spawnSync(command, {
-            cwd: process.cwd(),
-            shell: true,
-            encoding: "utf8",
-            env: process.env,
-            maxBuffer: 1024 * 1024 * 100,
-        });
-        chunks.push(result.stdout ?? "");
-        chunks.push(result.stderr ?? "");
-        chunks.push(`\nexit: ${result.status ?? 1}\n\n`);
-        if ((result.status ?? 1) !== 0) {
-            failed = true;
-            break;
-        }
-    }
-    writeFileSync(logPath, chunks.join(""));
-    return { commands, failed, skipped: false, logPath };
-}
-function writeCheckReport(input) {
-    const timestamp = timestampForFile();
-    const git = readGitSnapshot(process.cwd());
-    const reportDir = join(process.cwd(), FLOW_DIR, "reports");
-    mkdirSync(reportDir, { recursive: true });
-    const reportPath = join(reportDir, `${timestamp}-check.md`);
-    const verificationStatus = input.verification.skipped
-        ? "skipped"
-        : input.verification.failed
-            ? "failed"
-            : "passed";
-    const report = [
-        "# Monacori Validation Check",
-        "",
-        `Recorded: ${new Date().toISOString()}`,
-        `Branch: ${git.branch || "(unknown)"}`,
-        `Verification: ${verificationStatus}`,
-        input.verification.logPath ? `Log: ${relative(process.cwd(), input.verification.logPath)}` : "",
-        input.review ? `Diff review: ${relative(process.cwd(), input.review.path)}` : "",
-        input.review ? `Changed files: ${input.review.files}` : "",
-        input.review ? `Changed hunks: ${input.review.hunks}` : "",
-        "",
-        "## Commands",
-        input.verification.commands.length === 0
-            ? "- none"
-            : input.verification.commands.map((command) => `- \`${command}\``).join("\n"),
-        "",
-        "## Git Status",
-        codeBlock(git.status || "clean"),
-        "",
-        "## Diff Stat",
-        codeBlock(git.diffStat || "no diff"),
-        "",
-    ].filter((line) => line !== "").join("\n");
-    writeFileSync(reportPath, report);
-    appendToState(`\n## Check ${timestamp}\n\n- Verification: ${verificationStatus}\n${input.review ? `- Diff review: ${relative(process.cwd(), input.review.path)}\n` : ""}`);
-    return reportPath;
-}
-function appendToState(content) {
-    const path = join(process.cwd(), FLOW_DIR, STATE_FILE);
-    const current = existsSync(path) ? readFileSync(path, "utf8") : "";
-    writeFileSync(path, `${current.trimEnd()}\n${content}`);
-}
 function initialState(config) {
     return [
         "# Monacori Validation State",
@@ -442,27 +182,24 @@ function initialDecisions() {
     return [
         "# Monacori Decisions",
         "",
-        "Record durable validation decisions here so future checks do not depend on chat memory.",
+        "Record durable review decisions here so they do not depend on chat memory.",
         "",
     ].join("\n");
 }
 function agentSnippet() {
     return [
         "<!-- MONACORI:START -->",
-        "## monacori Validation",
+        "## monacori Diff Review",
         "",
-        "This repository uses monacori to verify AI-generated code changes.",
+        "This repository uses monacori to help humans review AI-generated code changes side-by-side.",
         "",
-        "Before claiming completion on a code change:",
+        "After making code changes:",
         "",
-        "- Run `monacori check --include-untracked` or a more specific `monacori verify -- <command>`.",
-        "- Use `monacori app --include-untracked` while changes are still moving.",
+        "- The user can run `mo` to open the diff review app and inspect your changes.",
         "- Inspect changed hunks with F7 / Shift+F7.",
         "- Use Shift Shift in the diff review to search indexed files, including unchanged files.",
         "- In source previews, use Cmd/Ctrl+Down to jump to the declaration-like match under the cursor.",
-        "- Report the verification commands, results, and remaining risks.",
-        "",
-        "Do not claim a change is done without verification evidence or a precise explanation of why verification could not run.",
+        "- Inline comments left in the review are bundled into a prompt and sent back to the session.",
         "<!-- MONACORI:END -->",
         "",
     ].join("\n");
@@ -508,9 +245,6 @@ function loadConfig() {
         },
     };
 }
-function getVerificationCommands(config) {
-    return config.verification.commands.filter((command) => command.trim().length > 0);
-}
 function writeIfMissing(path, content, force) {
     if (!force && existsSync(path)) {
         return;
@@ -582,26 +316,14 @@ function packageScriptCommand(manager, script) {
 function printHelp() {
     console.log(`monacori
 
-Validation control plane for AI-generated code changes.
+Desktop review app for AI-generated code changes.
 
 Usage:
   mo
   monacori open [--base HEAD] [--staged] [--tracked-only]
-  monacori check [--include-untracked] [--open] [--no-verify] [--no-diff] [-- <command>]
+  monacori app [--base HEAD] [--staged] [--include-untracked]
   monacori init [--force]
   monacori install [--force] [--apply-agent-docs]
-  monacori verify [-- <command>]
-  monacori diff [--base HEAD] [--staged] [--include-untracked] [--open] [--watch]
-  monacori app [--base HEAD] [--staged] [--include-untracked]
-  monacori review [--base HEAD] [--staged] [--include-untracked]
-  monacori status
-  monacori report [--label manual] [--file report.md]
-
-Default loop:
-  1. Let an AI agent edit code.
-  2. Run: mo
-  3. Run: monacori check --include-untracked
-  4. Only accept the change when verification evidence is clear.
 
 Diff review keys:
   F7         next changed hunk
@@ -626,42 +348,6 @@ Options:
   --tracked-only  inspect tracked changes only
 `);
 }
-function printCheckHelp() {
-    console.log(`monacori check
-
-Run configured verification and create a reviewable diff artifact.
-
-Usage:
-  monacori check [--include-untracked] [--staged] [--base HEAD] [--context 12] [--open] [--no-verify] [--no-diff] [-- <command>]
-
-Examples:
-  monacori check --include-untracked --open
-  monacori check -- npm test
-  monacori check --no-verify --include-untracked
-`);
-}
-function printDiffHelp() {
-    console.log(`monacori diff
-
-Generate a browser-based side-by-side Git diff review.
-
-Usage:
-  monacori diff [--base HEAD] [--staged] [--include-untracked] [--context 12] [--output review.html] [--open] [--watch] [--port 0]
-
-Keys in the review page:
-  F7         next changed hunk
-  Shift+F7  previous changed hunk
-  ] / [     fallback hunk navigation
-  Shift Shift search indexed files, including unchanged files
-  Cmd/Ctrl+E recent files
-  Cmd/Ctrl+Down jump to symbol under cursor
-
-The sidebar groups changed files as a folder tree. Use Search to filter paths and indexed file contents.
-The Files tab opens read-only source previews, including unchanged files when they fit the local review budget.
-Viewed marks are tied to file signatures, so a changed file becomes unviewed again after reload.
-Use --watch to serve a live review that reloads when the working tree changes.
-`);
-}
 function printAppHelp() {
     console.log(`monacori app