AI Flow

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

@@ -12,6 +12,16 @@ Install: `adom-wiki pkg install adom/adom-aiflow` (one Rust binary; `service-kic  Every state-changing command takes `--ai-thread "<your thread name>"`. Every run lives in one directory (`--run DIR`, default `./aiflow-run`) with a `run.json` manifest: the clock, the plan, the decisions, every stage's start and end, the outcomes, the capture markers and the summary. The manifest is the comparison; nothing counts that is not in it. +## Continue to the requested finish line++Keep the original deliverable active across status questions, dashboard changes, tool repairs and other supporting requests. Completing a subtask is not a reason to end the turn. Report progress briefly, then execute the next available engineering action. On resume, read the run and project completion plan, verify the live target, and continue the earliest incomplete gate.++For reversible engineering choices, use the user's stated priorities and record a clearly labeled working assumption. Ask optional questions asynchronously while continuing independent work. Do not convert an assistant-invented target into a mandatory user decision. Never reduce a user-required rating, relax safety limits, invent evidence or bypass a gate to obtain a pass.++Reserve a final handoff for the completed requested scope, an explicit pause, or a concrete dependency that prevents further useful authorized work. A real blocker report names the failed gate, evidence, attempted remedies and the smallest missing input. Keep unresolved gates visible and continue other useful work when possible. `done` stops session accounting only; it neither completes the engineering run nor authorizes stopping early. `finish` and the requested delivery remain separate requirements.++Skills and CLI hints guide the calling AI; they cannot restart an ended chat turn or guarantee autonomous execution outside the host's runtime. Do not claim a background continuation mechanism unless it is implemented and verified.+ ## The flow  The flow is a file, `flows/board.json`: the steps in order (intake, rules, test-plan, components, libraries, models, placement, routing, thermal-vias, pours, outline, current, thermal, fields, nets, silkscreen, 3d, finish, export; the `sequence` per lane is enforced, see No step is skipped), who does each, what the binary offers at each, and the steps that come later (components, libraries, schematic, simulation before the board; moleculize, paste, probe after it). `models` (kicad_model_check) refuses to go on while any footprint lacks its 3D model, so the board renders as it will be built. `nets` (`tour nets`) selects each key net as a whole through the IPC API, pours, tracks, vias and pads together, and frames it with Zoom to Selected Objects, one net at a time on camera. `3d` (`tour 3d`) opens the 3D Viewer and runs the walkthrough by View-menu commands (kicad_3d_view: fit, top, tilt, orbit, zoom, swing, front, bottom, flip), no mouse, with the viewer window as the step's camera. `plan` prints the flow.

@@ -179,7 +179,7 @@ enum Cmd {     Status,     /// A new human prompt on this run (a follow-up: "add the walkthroughs", "recut the video"): the AI's time for it counts from here to its `done`. --at is the paste time when you start late.     Prompt { #[arg(long)] text: String, #[arg(long)] at: Option<String> },-    /// The AI's answer to the current prompt is complete ("done, here is ..."): the session's clock stops here. `deliver` is the done of the first task.+    /// Stop session accounting after the requested scope is complete or a genuine blocking handoff. This does not complete the engineering run.     Done { #[arg(long)] message: String },     /// The run as sessions: each human prompt, the AI's active time on it, the idle gaps cut out (a gap over --idle-minutes with no command running is unobserved activity, not proven human idle).     Sessions { #[arg(long)] json: bool },@@ -3326,7 +3326,7 @@ fn main() {             r.log("prompt", json!({"n": n, "text": text, "at": at}));             r.data["clock"]["lastPromptTime"] = json!(at);             r.save().unwrap();-            ok(&format!("prompt {n} at {at}: the AI's time on it counts from here"), &["Say `done --message \"...\"` the moment your answer to this prompt is complete; the clock of this session stops there, and what sits idle after it is not charged to you.".into(), "Every step, clip and drawing you make until then belongs to this session on the run page.".into(), "Measure external work with adom-aiflow exec -- <program> <args>. Unwrapped long gaps are unobserved and may undercount active work, not proof of idle time.".into()]);+            ok(&format!("prompt {n} at {at}: the AI's time on it counts from here"), &["Continue the original requested scope after supporting tasks and status updates. Use `done --message \"...\"` only at completion, an explicit pause, or a genuine blocking handoff; it stops session accounting, not the engineering run.".into(), "Every step, clip and drawing you make until then belongs to this session on the run page.".into(), "Measure external work with adom-aiflow exec -- <program> <args>. Unwrapped long gaps are unobserved and may undercount active work, not proof of idle time.".into()]);         }         Cmd::Done { message } => {             thread(&cli);

@@ -0,0 +1,3 @@+# AIFlow 0.1.76++Clarify continuation through the original requested scope. Supporting tasks and status updates are not stopping points. Prompt hints and the main skill distinguish session accounting (`done`) from engineering acceptance and delivery. Optional assumptions use user priorities while preserving required ratings and safety gates. This is guidance, not a host auto-resume implementation.

@@ -1,7 +1,7 @@ {   "slug": "adom-aiflow",   "type": "app",-  "version": "0.1.75",+  "version": "0.1.76",   "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.",