AI Flow

@@ -14,7 +14,7 @@ members = [ ]  [workspace.package]-version = "0.1.50"+version = "0.1.51" edition = "2021" license = "MIT" repository = "https://wiki.adom.inc/adom/adom-aiflow"

@@ -13,6 +13,14 @@ adom-aiflow --version  The same flow runs a board that lives in Autodesk Fusion: the binary plans, routes and gates offline, and every placement, trace, pour and refinement lands live in Fusion through the Fusion bridge, read back from Fusion's own export each time. See [the Fusion lane](docs/fusion-lane.md). +## Flow apps: the stages after the board++AI Flow ends at a finished board. Each later stage is its own small app with its own page, owned by whoever+builds it: ordering from JLCPCB (`adom-aiflow-jlcpcb`), probing and testing, and more to come. They start from the+board release this flow finishes with and keep their own ledger and clips. To build one, copy+[template/flow-app](template/flow-app/README.md): a Rust Linux CLI with the step engine, ledger, window recording+and the handoff schema, open source under MIT.+ ## Silkscreen that helps at the bench  > Available in v0.1.26 on the insiders channel. Install with `adom-wiki pkg install adom/adom-aiflow`. The KiCad workflow is demonstrated below; Fusion and Altium adapters still require validation.

@@ -115,7 +115,8 @@ enum Cmd {     /// The finish line; refuses until every check passes     Finish,     /// Declare the step you are working on (placement, routing, pours, current, thermal, capture, finish, or your own). --back marks a return to an earlier step; --why says what sent you back.-    Step { name: String, #[arg(long)] back: bool, #[arg(long)] why: Option<String> },+    Step { name: String, #[arg(long)] back: bool, #[arg(long)] why: Option<String>, /// film this window (hwnd on the target box) for this step and the next ones, instead of the PCB editor: a pup window driving a vendor site, a datasheet, Hydrogen's Parts Search+    #[arg(long)] hwnd: Option<i64> },     /// The end of the run as the human sees it: the moment you say "done, here is your video". Needs finish first and the video file.     Deliver { #[arg(long)] video: String, #[arg(long)] message: String, /// deliver even though a clip is flagged as having filmed nothing (say why in --message)     #[arg(long)] accept_suspect: bool },@@ -3568,7 +3569,7 @@ fn main() {             }             println!("{}", step_table(&r));         }-        Cmd::Step { name, back, why } => {+        Cmd::Step { name, back, why, hwnd: hwnd_arg } => {             thread(&cli);             let mut r = load_run(&cli);             let mut known: Vec<String> = r.data["flow"]["steps"].as_array().map(|a| a.iter().filter_map(|x| x["name"].as_str().map(str::to_string)).collect()).unwrap_or_else(|| ["intake", "placement", "routing", "pours", "current", "thermal", "capture", "finish"].iter().map(|s| s.to_string()).collect());@@ -3606,7 +3607,7 @@ fn main() {                     clip_stopped = true;                 }                 // the fields step films the app's window through `tour fields`: no editor clip for it-                let hwnd = if name == "fields" { None } else { r.data["captures"].as_array().and_then(|c| c.iter().rev().find_map(|e| e.get("hwnd").and_then(|h| h.as_i64()))).or_else(|| br.pcb_editor_hwnd()) };+                let hwnd = if let Some(h) = hwnd_arg { Some(*h) } else if name == "fields" { None } else { r.data["captures"].as_array().and_then(|c| c.iter().rev().find_map(|e| e.get("hwnd").and_then(|h| h.as_i64()))).or_else(|| br.pcb_editor_hwnd()) };                 let disk = disk_check(&dir, &br, name);                 if let Err(e) = &disk {                     r.log("clip-refused", json!({"step": name, "why": e}));

@@ -103,6 +103,9 @@ pub fn sourcing_check(bom: &str, board: Option<&(BTreeSet<String>, BTreeSet<Stri     let c_src = col(header, &["source", "supplier", "distributor", "vendor"]);     let c_vpn = col(header, &["vendor_pn", "supplier_pn", "distributor_pn", "mouser_pn", "vendor_part_number", "supplier_part_number"]);     let c_lcsc = col(header, &["lcsc", "lcsc_pn", "lcsc_part", "lcsc_part_number", "jlcpcb_part", "jlc_pn"]);+    // fit: "post" (or dnp, hand, after) = fitted after the fab's assembly (molecule contacts, machine pins, hand-soldered parts):+    // the row keeps its MPN and source, needs no LCSC number on the jlcpcb profile, and `fab export` leaves it out of the BOM and CPL+    let c_fit = col(header, &["fit", "dnp", "assembly"]);     // the dated stock column: a header carrying the date (stock_checked_2026-09-29), or a stock     // column beside a stock_date / checked column that carries the date per row     let c_stock_dated = header.iter().position(|h| h.to_ascii_lowercase().contains("stock") && date_in(h).is_some());@@ -142,6 +145,8 @@ pub fn sourcing_check(bom: &str, board: Option<&(BTreeSet<String>, BTreeSet<Stri         if adom { adom_rows += 1; } else { distributor_rows += 1; }         match profile {             "jlcpcb" => {+                let fit = get(row, c_fit).to_ascii_lowercase();+                if ["post", "dnp", "hand", "after", "no"].iter().any(|k| fit == *k || fit.starts_with(&format!("{k} "))) { continue; }                 if lcsc.is_empty() && !is_lcsc_number(&vpn) { errors.push(format!("{label} ({mpn}): no LCSC number on the jlcpcb profile (add an lcsc column, e.g. C12345)")); }             }             _ => {@@ -390,6 +395,13 @@ mod tests {         assert_eq!(out["boardChecked"], false);     } +    #[test]+    fn jlcpcb_profile_skips_rows_fitted_after_assembly() {+        let bom = "ref,mpn,source,lcsc,fit,stock_checked_2026-10-05\nU1,TPS,JLCPCB,C123456,,5000\nJ1,MachineContactMedium,Adom stock,,post,\n";+        let out = sourcing_check(bom, None, "jlcpcb", 2);+        assert!(!out["errors"].to_string().contains("J1"), "{}", out["errors"]);+    }+     #[test]     fn jlcpcb_profile_needs_lcsc_numbers() {         let bom = "ref,mpn,source,lcsc,stock_checked_2026-09-29\nU1,TPS,JLCPCB,C123456,5000\nU2,ABC,JLCPCB,,5000\n";

@@ -0,0 +1,8 @@+# AI Flow 0.1.51++AI Flow becomes a family. This app's scope is a finished board: prompt to a routed, poured, analysed, DRC-clean board. Every later stage (ordering from a fab, probing and testing) is its own small app, built from a template that now ships here.++- New `template/flow-app/`: the starting point for a flow app. A Rust Linux CLI with `init` (from a board release), `next` (the current step and what the AI must do, from a flow file), `steps`, `ledger`, and `clip start/stop` (background window recording through Adom Bridge, pulled and checked). `new-flow.sh <stage> <dir>` copies it into a new app; `build.sh` builds from source. Open source, MIT. Each app owns its copy and never depends on this repo.+- New handoff schema `adom/board-release@1` (`template/flow-app/schema/`): the board, BOM, spec and their sha256, which every later stage starts from.+- `step --hwnd <window>` records a named window for a step that is not about the PCB editor (a browser, Hydrogen's Parts Search).+- `sourcing check` on the jlcpcb profile skips rows fitted after assembly (`fit` column: post, dnp, hand, after, no).

@@ -1,7 +1,7 @@ {   "slug": "adom-aiflow",   "type": "app",-  "version": "0.1.50",+  "version": "0.1.51",   "title": "AI Flow",   "description": "Adom's AI Flow: a tool to help the AI follow all of the steps it takes to build a board. One Rust binary with a crate per step (placement helpers, a grid router with Kelvin taps, pours with keepouts, KiCad's DRC gate, live landing through the KiCad Bridge, copper measurement, current and thermal analysis) and a finish line that refuses an unfinished board. Every command answers with hints for the AI; every turn, its thinking time and every rework loop go into run.jsonl, so Claude, Codex and any other engine are compared on the same flow. KiCad today; Altium, Fusion and Adom's own web apps next.",   "summary": "Adom's AI Flow: a tool to help the AI follow all of the steps it takes to build a board. The AI thinks its way from placement through routing, pours, current and thermal analysis to a delivered video; the binary does the fast, deterministic parts of every step, hands back hints, and keeps a ledger of every turn, every return to an earlier step, and the clock from the prompt to done.",

@@ -1,7 +1,7 @@ {   "slug": "adom-aiflow",   "type": "app",-  "version": "0.1.50",+  "version": "0.1.51",   "title": "AI Flow",   "description": "Adom's AI Flow: a tool to help the AI follow all of the steps it takes to build a board. One Rust binary with a crate per step (placement helpers, a grid router with Kelvin taps, pours with keepouts, KiCad's DRC gate, live landing through the KiCad Bridge, copper measurement, current and thermal analysis) and a finish line that refuses an unfinished board. Every command answers with hints for the AI; every turn, its thinking time and every rework loop go into run.jsonl, so Claude, Codex and any other engine are compared on the same flow. KiCad today; Altium, Fusion and Adom's own web apps next.",   "summary": "Adom's AI Flow: a tool to help the AI follow all of the steps it takes to build a board. The AI thinks its way from placement through routing, pours, current and thermal analysis to a delivered video; the binary does the fast, deterministic parts of every step, hands back hints, and keeps a ledger of every turn, every return to an earlier step, and the clock from the prompt to done.",

@@ -0,0 +1 @@+target/

@@ -0,0 +1,25 @@+# A flow app: one later-stage step of making a board (ordering, probing, ...) as its own Linux CLI.+# Copied from adom/adom-aiflow template/flow-app. This copy is yours: change anything, never depend on aiflow.+[package]+name = "adom-aiflow-example"+version = "0.1.0"+edition = "2021"+license = "MIT"++[[bin]]+name = "adom-aiflow-example"+path = "src/main.rs"++[dependencies]+serde = { version = "1", features = ["derive"] }+serde_json = "1"+clap = { version = "4", features = ["derive"] }++[profile.release]+opt-level = 3+lto = true+codegen-units = 1+strip = true++# standalone: not a member of any surrounding workspace+[workspace]

@@ -0,0 +1,9 @@+MIT License++Copyright (c) 2026 Adom Industries Inc.++Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:++The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

@@ -0,0 +1,55 @@+# Flow app template++AI Flow is a family of small apps, one per stage of making a board. The board flow (adom-aiflow) takes a prompt+to a finished, routed, DRC-clean board. Every later stage (ordering from a fab, probing and testing, ...) is its+own flow app built from this template. Each one is a separate wiki page and a separate Linux CLI, owned by+whoever builds it.++## Rules++- **Its own app.** One wiki page, one Cargo project, one binary named `adom-aiflow-<stage>`. Copy this folder and+  own the copy. Never depend on adom-aiflow as a crate, and never need a PR to adom-aiflow to change your app.+  Pull improvements from this template when you want them, by hand.+- **Rust, Linux only.** One Linux binary, no Node and no Python. It runs where the AI runs (the container) and+  reaches Windows desktops through `adom-bridge`.+- **Open source.** MIT. The full source ships on the page so anyone can read it, build it with `./build.sh`, and+  send a PR. The binary in `bin/` is a convenience; `install.sh` builds from source when it does not run.+- **The binary tells the AI what to do next.** `next` names the current step and what the AI must do in it,+  from `flows/flow.json`. Every command answers `OK:` or `ERROR:` with `Hint:` lines. The binary does the+  deterministic work; the AI does the judgement the step's `do` text asks for.+- **Start from a board release.** `init --release <board-release.json>` (schema in+  `schema/board-release.schema.json`, `adom/board-release@1`). The board flow writes it when the board is+  finished; `init` refuses when a named file's sha256 no longer matches, so a stage never acts on a board that+  changed after it was finished.+- **Keep your state in one folder.** `<project>/<stage>-flow/`: `state.json`, `run.jsonl` (one line per command:+  time, AI thread, what happened), `clips/`, and the evidence each step produces. Never edit earlier ledger lines.+- **Record every step.** `clip start --name <step> --hwnd <window>` / `clip stop` records one window in the+  background. Drive browsers with pup (`pup_eval`, `pup_input_dispatch`), never the OS mouse, so clips show no+  moving cursor.+- **Ask before money and before publishing.** A step that pays, orders, posts or publishes waits for the human's+  explicit OK, recorded in the ledger.++## Start a new flow app++```bash+template/flow-app/new-flow.sh probing ~/project/adom-aiflow-probing+cd ~/project/adom-aiflow-probing+# write flows/flow.json (your steps), skills/adom-aiflow-probing/SKILL.md, add verbs in src/main.rs+./build.sh                                   # tests, release build, bin/adom-aiflow-probing+# before the first publish: fill package.json (brief, discovery_*, sample_prompts), make the hero in Hero Studio+# (docs/hero.png; the human clicks Generate), then `adom-wiki pkg lint` and `adom-wiki pkg publish --org adom --public`+```++## What is in here++| File | What it is |+|---|---|+| `src/main.rs` | the CLI: `init`, `next`, `steps`, `ledger`, `clip start/stop`; add your stage's verbs |+| `src/flow.rs` | the step engine: the first step whose `done` artifacts are missing is the current one |+| `src/ledger.rs` | the project folder, `state.json` and `run.jsonl` |+| `src/bridge.rs` | Adom Bridge calls: window recording, pull_file with a check, window screenshots, pup |+| `src/out.rs` | `OK:` / `ERROR:` with hints |+| `flows/flow.json` | your stage's steps, their artifacts and what the AI does in each |+| `schema/board-release.schema.json` | the handoff from the board flow |+| `build.sh`, `install.sh`, `uninstall.sh` | build from source; the package install and uninstall hooks |+| `new-flow.sh` | copies this folder into a new app with the names changed |

@@ -0,0 +1,9 @@+#!/bin/bash+# Build the Linux binary from source and put it where the package ships it (bin/). Anyone can run this.+set -e+HERE="$(cd "$(dirname "$0")" && pwd)"; cd "$HERE"+NAME="$(sed -n 's/^name = "\(.*\)"/\1/p' Cargo.toml | head -1)"+cargo test --release+cargo build --release+mkdir -p bin && cp "target/release/$NAME" "bin/$NAME"+echo "OK: bin/$NAME ($(bin/$NAME --version))"

@@ -0,0 +1,9 @@+{+ "name": "example",+ "description": "TEMPLATE: replace with your stage, from a board release to what this stage delivers.",+ "steps": [+  {"name": "intake", "done": ["state.json"], "do": "Run `init --release <board-release.json> --target <desktop>`. Read the release: board, BOM, spec, and what the board flow said is left for later stages."},+  {"name": "work", "done": ["work/*.json"], "do": "TEMPLATE: what the AI must do in this step, which verb does the deterministic part, and which artifact proves it is done."},+  {"name": "report", "done": ["report.md"], "do": "TEMPLATE: write the stage's report: what was delivered, the evidence, and anything the next stage must know."}+ ]+}

@@ -0,0 +1,18 @@+#!/bin/bash+# adom-wiki package install hook: the binary to ~/.local/bin, the skill to ~/.claude/skills (and ~/.codex/skills).+# Builds from source when no prebuilt binary ships or it does not run here.+set -e+HERE="$(cd "$(dirname "$0")" && pwd)"+NAME="$(sed -n 's/^name = "\(.*\)"/\1/p' "$HERE/Cargo.toml" | head -1)"+if ! "$HERE/bin/$NAME" --version >/dev/null 2>&1; then+  command -v cargo >/dev/null || { echo "ERROR: no prebuilt binary for this machine and no cargo to build one (https://rustup.rs)"; exit 1; }+  (cd "$HERE" && cargo build --release && mkdir -p bin && cp "target/release/$NAME" "bin/$NAME")+fi+mkdir -p "$HOME/.local/bin"+install -m 755 "$HERE/bin/$NAME" "$HOME/.local/bin/.$NAME-new" && mv -f "$HOME/.local/bin/.$NAME-new" "$HOME/.local/bin/$NAME"+for skill in "$HERE"/skills/*; do+  [ -f "$skill/SKILL.md" ] || continue+  for consumer in .claude .codex; do mkdir -p "$HOME/$consumer/skills/$(basename "$skill")"; cp "$skill/SKILL.md" "$HOME/$consumer/skills/$(basename "$skill")/SKILL.md"; done+done+command -v adom-bridge >/dev/null 2>&1 || echo "Hint: desktop steps need adom-bridge (the Adom Bridge CLI)"+echo "OK: $NAME installed. Run '$NAME --help'."

@@ -0,0 +1,13 @@+#!/bin/bash+# Start a new flow app from this template: new-flow.sh <stage> <dest dir>+# e.g. new-flow.sh probing ~/project/adom-aiflow-probing  ->  binary adom-aiflow-probing, project folder probing-flow/+set -e+STAGE="$1"; DEST="$2"+[ -n "$STAGE" ] && [ -n "$DEST" ] || { echo "usage: new-flow.sh <stage> <dest dir>"; exit 1; }+[ -e "$DEST" ] && { echo "ERROR: $DEST exists"; exit 1; }+HERE="$(cd "$(dirname "$0")" && pwd)"+cp -r "$HERE" "$DEST"; rm -rf "$DEST/target" "$DEST/new-flow.sh"+grep -rl "adom-aiflow-example\|example-flow" "$DEST" | xargs sed -i "s/adom-aiflow-example/adom-aiflow-$STAGE/g; s/example-flow/$STAGE-flow/g"+sed -i "s/\"name\": \"example\"/\"name\": \"$STAGE\"/" "$DEST/flows/flow.json"+mv "$DEST/skill" "$DEST/skills-tmp"; mkdir -p "$DEST/skills/adom-aiflow-$STAGE"; mv "$DEST/skills-tmp/SKILL.md" "$DEST/skills/adom-aiflow-$STAGE/SKILL.md"; rmdir "$DEST/skills-tmp"+echo "OK: adom-aiflow-$STAGE in $DEST. Next: write flows/flow.json and skills/adom-aiflow-$STAGE/SKILL.md, add your verbs, ./build.sh"

@@ -0,0 +1,32 @@+{+  "slug": "adom-aiflow-example",+  "type": "app",+  "version": "0.1.0",+  "title": "TEMPLATE flow app",+  "description": "TEMPLATE: what this stage does, from a finished board to what it delivers. Open source (MIT): the full Rust source ships on this page; build it yourself with ./build.sh.",+  "category": "Developer Tools",+  "license": "MIT",+  "bin": {+    "adom-aiflow-example": "bin/adom-aiflow-example"+  },+  "dependencies": {},+  "scripts": {+    "install": "./install.sh",+    "uninstall": "./uninstall.sh"+  },+  "bundled": true,+  "hero": {+    "path": "docs/hero.png"+  },+  "brief": "TEMPLATE: one line, what this stage does.",+  "discovery_pitch": "TEMPLATE: when an AI should reach for this app.",+  "discovery_triggers": [+    "TEMPLATE: everyday phrasings a user would say"+  ],+  "sample_prompts": [+    {+      "label": "TEMPLATE",+      "prompt": "TEMPLATE: a real user request"+    }+  ]+}

@@ -0,0 +1,25 @@+{+ "$schema": "https://json-schema.org/draft/2020-12/schema",+ "$id": "adom/board-release@1",+ "title": "Board release: the handoff from the board flow to every later stage",+ "description": "Written when a board is finished. Every later flow app (ordering, probing, ...) starts from this file and checks the sha256 of each file it names, so it never builds a board that changed after it was finished.",+ "type": "object",+ "required": ["schema", "board", "bom"],+ "properties": {+  "schema": {"const": "adom/board-release@1"},+  "name": {"type": "string", "description": "board name, e.g. buck-12v5v-molecule"},+  "page": {"type": ["string", "null"], "description": "the board's wiki page (owner/slug), if it has one"},+  "board": {"$ref": "#/$defs/file", "description": "the finished .kicad_pcb (or .brd)"},+  "schematic": {"$ref": "#/$defs/file"},+  "bom": {"$ref": "#/$defs/file", "description": "BOM csv: ref, mpn, value, plus vendor columns (lcsc, mouser...) and fit (post|dnp|hand for parts fitted after assembly)"},+  "spec": {"$ref": "#/$defs/file"},+  "sourcingProfile": {"type": "string", "description": "the profile the BOM was checked against (fab, jlcpcb, ...)"},+  "finished": {"type": "string", "format": "date-time"},+  "producedBy": {"type": "string", "description": "app and version that wrote this, e.g. adom-aiflow 0.1.52"},+  "checks": {"type": "object", "description": "what the board flow proved: drc, routed, analyses, with their results"},+  "notes": {"type": "array", "items": {"type": "string"}, "description": "anything a later stage must know"}+ },+ "$defs": {+  "file": {"type": "object", "required": ["path", "sha256"], "properties": {"path": {"type": "string"}, "sha256": {"type": "string"}}}+ }+}

@@ -0,0 +1,22 @@+---+name: adom-aiflow-example+description: >-+  TEMPLATE: one line on the stage this flow app runs, from a finished board (board-release.json) to what it delivers,+  then the trigger words an AI should match on.+---++# adom-aiflow-example++Run `adom-aiflow-example next` whenever you are unsure what to do: it names the current step and what you must do in it.+Every command answers `OK:` or `ERROR:` with `Hint:` lines; every command you run goes in `<project>/example-flow/run.jsonl`.++```+adom-aiflow-example init --release <board-release.json> --target <desktop> --ai-thread <you>+adom-aiflow-example next+adom-aiflow-example clip start --name <step> --hwnd <window> --ai-thread <you>   # record each step for the video+adom-aiflow-example clip stop --ai-thread <you>+```++## The rules that matter++TEMPLATE: the things this stage gets wrong without them.

@@ -0,0 +1,49 @@+//! The flow file (flows/flow.json, compiled in): the ordered steps, the artifacts that prove each one+//! is done, and what the AI must do in it. `next` names the first step whose artifacts are missing.+//! The binary does the deterministic parts; the AI does the thinking the `do` text asks for.+use serde::Deserialize;+use std::path::Path;++#[derive(Deserialize, Clone)]+pub struct Step { pub name: String, pub done: Vec<String>, #[serde(rename = "do")] pub todo: String }++#[derive(Deserialize)]+#[allow(dead_code)]+pub struct Flow { pub name: String, pub description: String, pub steps: Vec<Step> }++pub fn load() -> Flow { serde_json::from_str(include_str!("../flows/flow.json")).expect("flows/flow.json is valid") }++/// One artifact pattern, relative to the flow folder; `*` matches within the last path segment.+pub fn exists(flow_dir: &Path, pat: &str) -> bool {+    let full = flow_dir.join(pat);+    let name = full.file_name().and_then(|n| n.to_str()).unwrap_or("");+    if !name.contains('*') { return full.exists(); }+    let (pre, post) = name.split_once('*').unwrap_or((name, ""));+    let dir = full.parent().unwrap_or(flow_dir);+    std::fs::read_dir(dir).map(|rd| rd.flatten().any(|e| {+        let n = e.file_name().to_string_lossy().to_string();+        n.starts_with(pre) && n.ends_with(post) && n.len() >= pre.len() + post.len()+    })).unwrap_or(false)+}++pub fn current<'a>(flow: &'a Flow, flow_dir: &Path) -> Option<&'a Step> {+    flow.steps.iter().find(|s| !s.done.iter().all(|p| exists(flow_dir, p)))+}++#[cfg(test)]+mod tests {+    use super::*;++    #[test]+    fn current_step_is_the_first_with_missing_artifacts() {+        let d = std::env::temp_dir().join(format!("flow-test-{}", std::process::id()));+        std::fs::create_dir_all(d.join("work")).unwrap();+        std::fs::write(d.join("state.json"), "{}").unwrap();+        let f = load();+        assert_eq!(current(&f, &d).map(|s| s.name.as_str()), Some("work"));+        std::fs::write(d.join("work/a.json"), "{}").unwrap();+        assert!(exists(&d, "work/*.json"));+        assert_eq!(current(&f, &d).map(|s| s.name.as_str()), Some("report"));+        std::fs::remove_dir_all(&d).ok();+    }+}

@@ -0,0 +1,50 @@+//! The project's flow folder (`<project>/<flow>/`): state.json plus run.jsonl, one line per command+//! with the time, the calling AI thread and what it did. Never rewrite earlier lines.+use serde_json::{json, Value};+use std::io::Write;+use std::path::{Path, PathBuf};++pub fn now() -> String {+    let out = std::process::Command::new("date").args(["-u", "+%Y-%m-%dT%H:%M:%SZ"]).output();+    out.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string()).unwrap_or_default()+}++#[allow(dead_code)]+pub struct Project { pub dir: PathBuf, pub flow_dir: PathBuf, pub state: Value }++impl Project {+    /// The nearest folder at or above `start` that holds `<flow>/state.json`.+    pub fn find(start: &Path, flow: &str) -> Option<Project> {+        let mut d = Some(start.to_path_buf());+        while let Some(p) = d {+            let s = p.join(flow).join("state.json");+            if s.is_file() {+                let state = std::fs::read_to_string(&s).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or(json!({}));+                return Some(Project { flow_dir: p.join(flow), dir: p, state });+            }+            d = p.parent().map(Path::to_path_buf);+        }+        None+    }++    pub fn create(dir: &Path, flow: &str, state: Value) -> std::io::Result<Project> {+        let flow_dir = dir.join(flow);+        std::fs::create_dir_all(&flow_dir)?;+        let p = Project { dir: dir.to_path_buf(), flow_dir, state };+        p.save()?;+        Ok(p)+    }++    pub fn save(&self) -> std::io::Result<()> {+        std::fs::write(self.flow_dir.join("state.json"), serde_json::to_string_pretty(&self.state)? + "\n")+    }++    pub fn path(&self, rel: &str) -> PathBuf { self.flow_dir.join(rel) }++    pub fn log(&self, thread: &str, ev: &str, data: Value) {+        let line = json!({"t": now(), "aiThread": thread, "ev": ev, "data": data});+        if let Ok(mut f) = std::fs::OpenOptions::new().create(true).append(true).open(self.flow_dir.join("run.jsonl")) {+            let _ = writeln!(f, "{line}");+        }+    }+}

@@ -0,0 +1,13 @@+//! Every command answers the AI the same way: `OK: <what happened>` or `ERROR: <what is wrong>`,+//! then `Hint:` lines that depend on this project and this run. Exit 1 on ERROR.++pub fn ok(msg: &str, hints: &[String]) {+    println!("OK: {msg}");+    for h in hints.iter().filter(|h| !h.is_empty()) { println!("Hint: {h}"); }+}++pub fn err(msg: &str, hints: &[String]) -> ! {+    println!("ERROR: {msg}");+    for h in hints.iter().filter(|h| !h.is_empty()) { println!("Hint: {h}"); }+    std::process::exit(1)+}

@@ -0,0 +1,7 @@+#!/bin/bash+# adom-wiki package uninstall hook: remove the binary and the skills this app installed.+HERE="$(cd "$(dirname "$0")" && pwd)"+NAME="$(sed -n 's/^name = "\(.*\)"/\1/p' "$HERE/Cargo.toml" | head -1)"+rm -f "$HOME/.local/bin/$NAME"+for skill in "$HERE"/skills/*; do for consumer in .claude .codex; do rm -rf "$HOME/$consumer/skills/$(basename "$skill")"; done; done+echo "OK: $NAME removed"