From 5bde7c2d7e099fd9c8b2615602ab1d096bd9b6be Mon Sep 17 00:00:00 2001 From: soryu Date: Tue, 28 Apr 2026 21:26:11 +0100 Subject: revert PRs #93-#98; enforce strict-linear-DAG + mandatory directive verify (#100) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * revert: roll back PRs #93-#98 to pre-Lexical baseline Reverts the entire chain of directive document UI work and the homepage redesign, restoring the working tree to the state at 3679ceb (before c8b169d / PR #93). PRs reverted: - #93 c8b169d feat: Document UI for directive orchestration with Lexical editor - #94 d6f01a6 fix: compilation error and warnings already merged via PR #93 - #95 5aa3faf fix: resolve compilation error and warnings in Rust backend - #97 d513f93 feat: document UI with contract blocks, expandable logs, and interaction controls - #96 6366941 feat: Redesign homepage with professional PC-98 styling - #98 d1fdfb1 feat: revert broken directive PRs, re-implement Lexical document orchestrator The directive Document UI experiments produced fragile output and merge artifacts; follow-up commits in this PR change orchestration to favor strictly linear DAGs and add goal/conflict verification so future runs do not require this kind of cleanup. Co-Authored-By: Claude Opus 4.7 (1M context) * feat(directive): strict-linear-DAG planning + mandatory `directive verify` Tightens directive orchestration so the final PR almost never needs a hand-merge: 1. Planning prompts now strongly bias toward strictly linear DAGs. Parallel steps are reserved for genuinely independent work (e.g. disjoint modules); the default for "in doubt" is sequential. Linear chains inherit each previous step's worktree, so the final merge is typically just a rebase against the base branch. 2. New CLI command `makima directive verify` does a local in-memory `git merge-tree` of HEAD against `/` and exits non-zero with a list of conflicting files if the PR would not merge cleanly. Pure-local — no API call, no working-tree mutation. 3. Completion / PR-creation prompts now mandate three pre-push checks: a. build (`cargo check` and/or `tsc --noEmit`), b. `makima directive verify --base ` must exit 0, and c. an explicit goal-alignment self-check against the diff. The orchestrator is told NOT to push, create the PR, or call `makima directive update` until all three pass. Skipping any of them is documented as a directive failure. The combination means that with a linear DAG the final PR-creation task should almost never see a real conflict — when it does, that is treated as a planning bug to escalate rather than something to paper over with `-X theirs`. Co-Authored-By: Claude Opus 4.7 (1M context) * fix(frontend): TS errors pre-existing on master - TaskSlideOutPanel: declare missing `selectedFileDiff` / `selectedFilePath` state hooks that were referenced everywhere but never created, and re-balance the JSX so the `<>...` fragment in the non-diff branch is closed (the previous indentation/braces would not parse). - api.ts: add a `getWorktreeDiff` thin wrapper around `getTaskDiff` so TaskDetail's per-file click handler type-checks (the per-file slice is a future improvement; today both return the full task diff). - WorktreeFilesPanel: remove unused `isClickable` local; the gating already reads `onFileClick` directly inline. Run after revert: `npx tsc --noEmit` exits 0. Co-Authored-By: Claude Opus 4.7 (1M context) --------- Co-authored-by: Claude Opus 4.7 (1M context) --- makima/src/daemon/cli/directive.rs | 26 ++++++++++++++++++++++++++ makima/src/daemon/cli/mod.rs | 7 +++++++ 2 files changed, 33 insertions(+) (limited to 'makima/src/daemon/cli') diff --git a/makima/src/daemon/cli/directive.rs b/makima/src/daemon/cli/directive.rs index cc7b224..0f04720 100644 --- a/makima/src/daemon/cli/directive.rs +++ b/makima/src/daemon/cli/directive.rs @@ -177,6 +177,32 @@ pub struct CreateOrderArgs { pub labels: Option, } +/// Arguments for verify command — checks the current worktree can merge into the +/// directive's base branch with no conflicts. Runs entirely locally; no API call. +#[derive(Args, Debug)] +pub struct VerifyArgs { + /// Base branch to attempt merging into (e.g., "master", "main"). + #[arg(long, default_value = "master")] + pub base: String, + + /// Remote name to fetch from (default: "origin"). + #[arg(long, default_value = "origin")] + pub remote: String, + + /// Head ref to verify (default: current HEAD). + #[arg(long)] + pub head: Option, + + /// Skip the `git fetch` step (use already-fetched remote ref). + #[arg(long, default_value = "false")] + pub skip_fetch: bool, + + /// Optional directive goal text. When provided the goal is echoed back as a + /// reminder so the calling orchestrator can self-check goal alignment. + #[arg(long)] + pub goal: Option, +} + /// Arguments for update command. #[derive(Args, Debug)] pub struct UpdateArgs { diff --git a/makima/src/daemon/cli/mod.rs b/makima/src/daemon/cli/mod.rs index af6f885..7affc55 100644 --- a/makima/src/daemon/cli/mod.rs +++ b/makima/src/daemon/cli/mod.rs @@ -255,6 +255,13 @@ pub enum DirectiveCommand { /// Create an order for future work (spike or chore only) CreateOrder(directive::CreateOrderArgs), + + /// Verify the current worktree merges cleanly into the directive's base branch. + /// + /// Mandatory pre-flight before creating or pushing a directive PR — fails + /// with a non-zero exit code (and a list of conflicting files) if the merge + /// would conflict with the base branch. + Verify(directive::VerifyArgs), } impl Cli { -- cgit v1.2.3