fimo 0.15.0 → 0.16.0-experimental.2

package/assets/skills/fimo-migration/references/url-evidence.md

@@ -0,0 +1,242 @@
+# URL-only source evidence
+
+Use this reference only when no source repository or export exists. The live
+site is the source, so reconstruction requires rendered, interaction-aware
+evidence. A fetch crawl is a useful route and asset seed; it is not proof of
+hydrated layout, lazy content, responsive behavior, or motion.
+
+## Establish browser capability
+
+Use an existing rendered-browser adapter when it can do all of the following:
+
+- isolate concurrent sessions and run JavaScript before the first navigation;
+- navigate, scroll, hover, focus, click, and emulate viewport, color scheme,
+  and reduced motion;
+- capture DOM/HTML, accessibility output, computed styles, screenshots, and
+  browser errors;
+- record requests or a HAR, including response metadata and bodies when safe;
+- inspect `document.getAnimations()`, animation and transition lifecycle
+  events, canvases, and time-separated rendered state; and
+- capture a short video or trace when keyframes do not describe the behavior.
+
+Capability belongs to the harness, not the model. Codex, Claude, or another
+model may use any adapter that passes this gate. Record the adapter and version
+in the Source Evidence Pack.
+
+Prefer Fimo's tested `agent-browser@0.33.1` when no equivalent adapter exists.
+Before installing or upgrading it, ask the user because installation changes
+the execution environment. Use a direct question such as:
+
+> No available browser can capture the DOM, network, interactions, and early
+> motion this URL migration needs. May I install `agent-browser@0.33.1` and its
+> Chromium binary in this environment?
+
+After approval:
+
+```bash
+npm install -g agent-browser@0.33.1
+agent-browser install
+```
+
+On Linux, use `agent-browser install --with-deps` when Chromium system
+dependencies are missing. Then run `agent-browser --version`,
+`agent-browser doctor`, and `agent-browser skills get core --full`. Do not use
+an unpinned `npx` fallback or silently install/upgrade a browser. If the user
+declines and no equivalent adapter exists, stop the URL-only lane as
+`draft-only` with the missing capability recorded.
+
+## Source Evidence Pack
+
+Write one folder at `.fimo/migration/source-evidence/`:
+
+```text
+source-evidence/
+├── index.json
+├── routes.json
+├── site-system.json
+├── assets.json
+└── pages/
+    └── <route-id>/
+        ├── summary.json
+        ├── dom.html
+        ├── accessibility.txt
+        ├── motion.json
+        ├── interactions.json
+        ├── desktop.png
+        ├── mobile.png
+        └── raw/
+```
+
+`index.json` is a small versioned index, not a second website model. It records:
+
+- `schemaVersion`, source origin, capture time, approved route scope, browser
+  adapter/version, and desktop/mobile viewports;
+- every intended route with its page directory, discovery source, capture
+  states, artifact IDs, and completeness status;
+- every artifact's stable ID, kind, relative path, SHA-256, route, viewport or
+  interaction state, and capture time;
+- pointers to `routes.json`, `site-system.json`, and `assets.json`; and
+- unresolved or unsupported observations with user-visible impact and the
+  next owner action.
+
+Use this shape and add fields only when the source proves they are needed:
+
+```json
+{
+  "schemaVersion": 1,
+  "source": {
+    "origin": "https://example.com",
+    "capturedAt": "2026-01-01T00:00:00.000Z",
+    "approvedPaths": ["/", "/about"]
+  },
+  "browser": { "adapter": "agent-browser", "version": "0.33.1" },
+  "viewports": {
+    "desktop": { "width": 1440, "height": 1000 },
+    "mobile": { "width": 390, "height": 844 }
+  },
+  "routes": [
+    {
+      "id": "home",
+      "path": "/",
+      "url": "https://example.com/",
+      "pageDir": "pages/home",
+      "states": {
+        "desktop": "captured",
+        "mobile": "captured",
+        "scrollSweep": "captured",
+        "earlyMotion": "captured",
+        "interactions": "captured",
+        "reducedMotion": "captured",
+        "specialRenderers": "not-applicable"
+      },
+      "artifactIds": ["home-dom", "home-desktop", "home-motion"],
+      "status": "complete"
+    }
+  ],
+  "artifacts": [
+    {
+      "id": "home-dom",
+      "kind": "dom",
+      "path": "pages/home/dom.html",
+      "sha256": "<sha256>",
+      "route": "/",
+      "capturedAt": "2026-01-01T00:00:01.000Z"
+    }
+  ],
+  "shared": {
+    "routes": "routes.json",
+    "siteSystem": "site-system.json",
+    "assets": "assets.json"
+  },
+  "unresolved": []
+}
+```
+
+Normalized files contain source facts with artifact IDs and confidence. Large
+DOM, accessibility output, HAR/network bodies, screenshots, recordings, and
+runtime samples stay as raw artifacts and are loaded only for a targeted
+question. Do not write a hand-compressed `source-summary.md` that can silently
+erase evidence.
+
+`assets.json` is an ordered table. Each observed asset records its consumer or
+route, requested and resolved/current URL, local path when downloaded, SHA-256,
+MIME type, intrinsic dimensions, source alt text, nearest link, load status,
+provenance, and confidence. Preserve source order for repeated collections.
+
+## Observation sequence
+
+1. **Scope and routes.** Start from user-approved origins and paths. Inspect
+   same-origin links, sitemap/robots, canonical links, navigation, and
+   client-side route changes. Do not expand to a new origin or authenticated
+   surface without approval.
+2. **Instrument before navigation.** Register an init script before the first
+   real page load. It records `animationstart`, `animationend`,
+   `transitionrun`, `transitionstart`, `transitionend`, and
+   `transitioncancel`; wraps `Element.prototype.animate`; and samples
+   `document.getAnimations()` at early and settled checkpoints. Navigating
+   first and sampling later loses entrance and stagger evidence.
+3. **Shared system.** Observe header, footer, navigation, grids, breakpoints,
+   typography, colors, spacing, fonts, reusable components, cookies/banners,
+   and shared motion once. Cite representative pages.
+4. **Page pass.** Give each page observer its own browser session and route
+   directory. Capture desktop and mobile from a fresh load, DOM, accessibility,
+   computed layout, visible content, screenshots, errors, public API/network
+   responses, and early/settled motion.
+5. **Scroll sweep.** Scroll through the entire page in viewport-sized steps,
+   pausing for hydration and lazy loading. Return to important sections and
+   verify asset counts and load state after the sweep.
+6. **Interactions.** Exercise representative hover, focus, navigation,
+   accordion/menu, pointer, and scroll-linked behavior. Sample before, during,
+   and after each interaction. Repeat the route with reduced motion enabled.
+7. **Special renderers.** Detect canvas, WebGL, SVG animation, Lottie, video,
+   and procedural or spring behavior. Record CSS and intrinsic dimensions,
+   device-pixel ratio, animation ownership, time-separated pixel or state
+   samples, and any discoverable source-bundle clues.
+8. **Normalize.** The normalizer deduplicates shared facts, preserves route and
+   collection order, builds motion recipes, hashes artifacts, and marks capture
+   completeness. It does not infer missing behavior as `none`.
+
+When using `agent-browser`, load its version-matched core skill and follow this
+command shape rather than guessing flags:
+
+```bash
+agent-browser --version
+agent-browser skills get core --full
+agent-browser --session <route-id> --init-script <motion-init.js> open about:blank
+agent-browser --session <route-id> network har start
+agent-browser --session <route-id> set viewport 1440 1000
+agent-browser --session <route-id> open <url>
+agent-browser --session <route-id> snapshot
+agent-browser --session <route-id> get html html
+agent-browser --session <route-id> screenshot --full <desktop.png>
+agent-browser --session <route-id> eval <motion-or-layout-probe>
+agent-browser --session <route-id> network har stop <source.har>
+agent-browser --session <route-id> close
+```
+
+Use new sessions for fresh mobile and reduced-motion loads. The init script
+must install its event listeners and `Element.prototype.animate` wrapper before
+the source URL opens, expose bounded timestamped samples for collection, and
+avoid changing page layout or animation timing.
+
+Use short recordings only when static/keyframe evidence cannot preserve feel:
+canvas or WebGL, pointer physics, scroll-linked motion, Lottie, video, springs,
+or another procedural effect. One representative recording per distinct
+recipe is enough; ordinary CSS/WAAPI motion needs keyframes and timed samples,
+not continuous video. A settled screenshot cannot prove motion.
+
+## Motion recipe
+
+For each distinct behavior, normalize the trigger, target selector/role,
+properties and keyframes, duration, delay, easing or spring observations,
+iteration/fill/direction, sequence or stagger, responsive differences,
+reduced-motion behavior, and raw artifact IDs. Continuous or procedural
+effects also record renderer type, CSS/intrinsic dimensions, device-pixel
+ratio, frame or pixel samples, recording ID, and source-code/bundle clues when
+available.
+
+## Network safety
+
+Capture only traffic needed to understand public rendering and content. Before
+retaining a HAR or request body, remove cookies, `Set-Cookie`, authorization
+and proxy-authorization headers, tokens, signed query parameters, personal
+identifiers, and request bodies unrelated to reconstruction. When safe
+redaction cannot be proved, retain a sanitized request/asset table instead of
+the raw HAR. Never recover source credentials from browser state or bundles.
+
+## Completeness gate
+
+Reconstruction may start only when every intended route is captured or listed
+as unresolved and each captured route records:
+
+- fresh desktop and mobile loads;
+- full scroll/lazy-load completion;
+- DOM/accessibility and asset coverage;
+- early and settled motion capture, even when the result is no motion;
+- applicable hover/focus/navigation/scroll states;
+- reduced-motion behavior; and
+- every special renderer as captured, not applicable, or unresolved.
+
+Close every browser session after fan-in. The normalizer returns the pack path,
+route and asset counts, incomplete states, unresolved items, and the exact
+browser adapter/version to the coordinator.

package/assets/skills/fimo-migration/references/workers/content-execution.md

@@ -0,0 +1,39 @@
+# Content execution workers
+
+Execute the content planner's text handoff. Do not rediscover the source,
+reclassify values, redesign schemas, or edit files outside the assigned batch.
+If the handoff is incomplete, report the missing item to the coordinator so the
+planner can repair it.
+
+## Data worker
+
+Own one bounded schema/locale payload. Start only after every referenced asset
+has a confirmed Fimo mapping and, during conversion, the framework gate passes.
+Perform create-or-update writes and read the batch back before returning.
+
+For entry batches, use
+`fimo entries bulk-create <Uid> --file <payload> --upsert-by slug` and report
+per-chunk created, updated, reconciled, and conflict counts. Do not leave a
+payload as evidence of an import. An unavailable dependency blocks promptly;
+do not poll indefinitely.
+
+## Code worker
+
+Start only after this batch's real records read back as non-empty. Own exactly
+the consumer files assigned by the planner.
+
+1. Load the active framework's `fimo-code` reference.
+2. Establish the generated Fimo client/adapter needed by the batch.
+3. Replace every planned `sourceFile`/`sourceKey` at its existing consumer in
+   place. Appending a disconnected duplicate section is not wiring.
+4. Preserve executable React/MDX children in order around editable prose.
+5. Render at least one real imported item through every Server-to-Client or
+   plain-JSON boundary in the batch. Use the framework's generated
+   serialization/hydration contract; do not partially unwrap tracked values.
+6. Confirm each original literal or data source is gone only where its Fimo
+   replacement now renders once.
+
+A loader that reads Fimo while the consuming markup is missing, an imported
+entry no route consumes, or a successful build over empty data is incomplete.
+Return source items wired, files changed, read-back/render evidence, and any
+unresolved item in plain text.

package/assets/skills/fimo-migration/references/workers/content-planner.md

@@ -0,0 +1,64 @@
+# Content planning worker
+
+Own semantic discovery, schema authoring, payload preparation, and the text
+handoff. Do not import entries or rewrite application consumers.
+
+1. Inspect every content-bearing source and consumer: Markdown/MDX bodies and
+   frontmatter, JSX/TSX modules, hardcoded arrays and objects, imports, data
+   clients, and call sites. Read local exports and public APIs directly. A
+   private API requires a user-provided export or narrowly scoped server-side
+   credential; never recover or copy secret values.
+2. Classify each value as collection content, single content, an
+   editor-visible label, or application-owned code. Repetition is evidence,
+   not an automatic collection rule. Assistive text, identifiers, and values
+   that drive behavior are not labels.
+3. Define complete schemas from source evidence: types, requiredness, defaults,
+   uniqueness, locale behavior, media constraints, references, and
+   cardinalities. Do not invent constraints. Load `references/decision.md` and
+   the target project's Fimo schema guidance.
+4. Trace every item to the route, component, loader, query, or render module
+   that consumes it. Record its `sourceFile`, `sourceKey`, target files, payload
+   file, and worker batch. Finding data without consumers is incomplete.
+5. Enumerate every media field and rich-text image node as an asset obligation.
+6. Write and push `src/schemas/*.json`, generate required clients/types, and
+   write self-contained JSON payloads for the data workers.
+7. Write `.fimo/migration/content-plan.md` before any entry, label, single, or
+   content-driven code rewrite begins.
+
+The text plan has one source item per independently migrated construct and
+groups them into non-overlapping data and code batches. Every object in a
+hardcoded content array is an item. MDX prose and executable imports/components
+are separate items when needed; executable JSX cannot disappear inside a
+rich-text conversion.
+
+Keep the handoff short:
+
+```md
+## BlogPost
+
+- Source: `content/blog/post.mdx`
+- Schema: `src/schemas/BlogPost.json` (pushed)
+- Payload: `.fimo/migration/content/BlogPost.en.json`
+- Items: title, body, cover, `CoverageChart` behavior
+- Consumers: `src/app/blog/[slug]/page.tsx`
+- Data worker: `BlogPost/en`
+- Code worker: `blog-rendering`, owns the consumer above
+
+## Unresolved
+
+- `content/blog/post.mdx:11`: `CoverageChart` implementation is absent; owner
+  must restore it. Do not remove the node silently.
+```
+
+A construct is unresolved only when it genuinely cannot be migrated. Include
+its exact source, user-visible impact, reason, and owner action; "custom" is not
+a reason.
+
+## Optional extraction helpers
+
+Start with `rg` and targeted reads. A bounded read-only helper under
+`.fimo/migration/tmp/` may parse repeated frontmatter, JSON/YAML exports, or
+literal structures while preserving source locations. Spot-check its output.
+The agent still owns classification, schema design, and consumer tracing. Do
+not build a generic codemod system or let the helper write Fimo data or app
+code.

package/assets/skills/fimo-migration/references/workers/framework.md

@@ -0,0 +1,37 @@
+# Framework conversion worker
+
+Use this worker only after the user explicitly chose a framework conversion.
+Preserve mode never uses it.
+
+`fimo migrate init` creates the target first. Inspect the initialized template
+and its real paths before writing. Own all structural target code: dependencies,
+framework config, root layout and providers, app tree, route modules, 404,
+redirects, headers, middleware, sitemap/robots/OG structure, and locale-routing
+structure. There is no separate runtime or route writer during conversion.
+
+Port the source APIs, loaders, hardcoded content, integrations, and visible
+behavior into the new framework unchanged. Do not migrate those values to Fimo
+in this pass; schemas, data, and Fimo consumer wiring belong to later content
+workers. The content planner may inspect the source in parallel but must not
+edit structural target code.
+
+Load the target framework's `fimo-code` and hosting references. For Next.js,
+also load `references/frameworks/nextjs.md` and translate portable hosting
+behavior before declaring provider-specific behavior unresolved.
+
+## Framework gate
+
+Before returning, self-check and report:
+
+- dependencies install cleanly;
+- the framework build succeeds;
+- every source route maps to a target route and renders locally with its
+  expected status, including 404 behavior;
+- representative source text landmarks appear;
+- exactly one app tree and one root layout exist; and
+- primary routes have no runtime or console errors.
+
+Return a plain-text route map, files changed, check results, preserved behavior,
+and unresolved behavior. The coordinator independently reruns the build and
+representative route checks. Content data cannot start until this gate and the
+asset gate pass.

package/assets/skills/fimo-migration/references/workers/url-observer.md

@@ -0,0 +1,71 @@
+# URL observation workers
+
+Use these workers only for URL-only evidence. They inspect the live source and
+write the Source Evidence Pack; they do not edit application code, create Fimo
+schemas, import content, deploy, or publish.
+
+## Schedule and ownership
+
+| worker                 | owns                                    | output                                                        |
+| ---------------------- | --------------------------------------- | ------------------------------------------------------------- |
+| route scout            | approved route discovery                | candidate route table with source and scope disposition       |
+| shared-system observer | cross-page shell and design behavior    | shared system observations with artifact IDs                  |
+| page observer          | one route directory and browser session | raw page artifacts plus normalized page observations          |
+| evidence normalizer    | shared pack files and completeness      | `index.json`, routes, assets, shared facts, unresolved states |
+
+Run the route scout and shared-system observer first. After the coordinator
+approves the bounded route list, start page observers in batches of five to ten
+when the harness and browser can isolate sessions safely. Each observer owns
+exactly one route directory. The normalizer starts only after all observers are
+terminal and is the only worker allowed to write shared pack files.
+
+## Route scout
+
+- Stay within the user-approved origins and path scope.
+- Combine rendered navigation, same-origin links, sitemap/robots, canonicals,
+  and client-side navigation evidence.
+- Mark duplicates, redirects, locale variants, external links, blocked routes,
+  and discovered routes outside scope; never crawl a newly discovered origin
+  automatically.
+- Return the ordered route list, discovery evidence, and open scope questions.
+
+## Shared-system observer
+
+- Compare representative routes at desktop and mobile.
+- Record shared chrome, layout/grid rules, breakpoints, typography, fonts,
+  colors, spacing, reusable components, global assets, and shared interaction
+  or motion recipes.
+- Distinguish observed facts from inference and cite raw artifact IDs.
+- Do not duplicate every page observer's raw artifacts.
+
+## Page observer
+
+Follow `references/url-evidence.md`. Start with a fresh isolated session and
+pre-navigation motion instrumentation. Capture a fresh desktop load, full
+scroll sweep, interactions, fresh mobile load, reduced-motion load, network and
+asset state, early/settled motion, console errors, and special renderers.
+
+Write only the assigned route directory. `summary.json`, `motion.json`, and
+`interactions.json` cite the raw artifacts that prove each fact. A missing
+observation is `unresolved`, not `none`.
+
+Return status, duration, route, browser adapter/version, artifacts written,
+content and asset counts, detected motion/special renderers, incomplete states,
+and unresolved items.
+
+## Evidence normalizer
+
+- Verify every page report and referenced artifact exists.
+- Deduplicate shared facts without dropping route-specific differences.
+- Preserve exact route, content, collection, and asset order.
+- Build the ordered asset table and motion recipes from observations.
+- Hash every retained artifact and write the versioned `index.json`.
+- Mark each completeness state as captured, not applicable with evidence, or
+  unresolved with impact and next action.
+- Keep raw evidence out of default reconstruction prompts; workers receive the
+  compact normalized files and request raw artifacts only by ID.
+
+The normalizer does not judge the future target and does not rewrite the source
+facts into an implementation plan. Its final status is `ready` only when the
+URL evidence completeness gate passes; otherwise reconstruction remains
+`draft-only`.

package/assets/skills/fimo-migration/references/workers/validator.md

@@ -0,0 +1,31 @@
+# Migration validator
+
+The validator is an independent read-only worker. It did not author the
+migration and starts only after all writers return.
+
+Compare the source, content plan, actual `git diff`, real Fimo state, and local
+application behavior. A worker report is a claim, not evidence.
+
+Verify:
+
+- every source route renders with expected status and representative content;
+- for URL-only sources, every intended route passed the Source Evidence Pack
+  completeness gate and every normalized fact cites a raw artifact;
+- schemas, entries, singles, labels, media, forms, and locales exist through
+  CLI read-back;
+- every planned source item is consumed at its original behavior path, not in
+  an appended duplicate section;
+- media URLs load as their expected media type;
+- native Fimo APIs are used without migration-only wrappers;
+- imports are safe to rerun;
+- build and representative browser interactions pass;
+- source and target motion are compared at matched early, settled, hover,
+  focus, scroll, and reduced-motion phases where the source pack records them;
+- procedural canvas, WebGL, spring, or scroll-linked effects are compared with
+  time-separated samples or short recordings rather than one screenshot; and
+- every unsupported item names its impact and owner action.
+
+Return a plain-text report with status, duration, checks run, counts, failing
+source items, and suggested bounded repair surface. The coordinator may run one
+repair for that surface and rerun validation. It does not restart every worker
+or loop indefinitely.

package/assets/skills/fimo-migration/references/workers.md

@@ -0,0 +1,104 @@
+# Migration workers
+
+The root coding agent is the coordinator. It inspects the initialized target,
+writes a short text plan, starts independent workers through its native
+subagent mechanism, and fans their results back in. If subagents are
+unavailable, run the same lanes sequentially; never skip a surface silently.
+
+The CLI does not start language models. JSON is reserved for Fimo schemas and
+content payloads, plus the URL-only Source Evidence Pack described in
+`references/url-evidence.md`. Worker ownership, dependencies, reports, and
+unresolved work stay in `.fimo/migration/*.md` or the agents' plain-text
+responses.
+
+## URL-only observation crew
+
+Before reconstruction, run the observation crew in
+`references/workers/url-observer.md`:
+
+```text
+route scout + shared-system observer
+  -> independent page observers in bounded batches
+  -> one evidence normalizer
+  -> Source Evidence Pack completeness gate
+  -> reconstruction workers below
+```
+
+Do not let every reconstruction worker scrape the live site independently.
+Page observers own separate route directories and isolated browser sessions;
+the normalizer alone owns the shared index, route table, asset table, and
+cross-page summaries.
+
+## Schedule
+
+Plan a lane only when the source proves that surface exists:
+
+| worker          | owns                                            | starts when              |
+| --------------- | ----------------------------------------------- | ------------------------ |
+| runtime         | framework/runtime files and provider config     | immediately              |
+| routes          | route modules, redirects, SEO and host behavior | immediately              |
+| content planner | schemas, content payloads, and content handoff  | immediately              |
+| locales         | locale setup and translated UI copy             | immediately              |
+| assets/forms    | media uploads and form behavior                 | after content planner    |
+| content data    | one schema/locale import                        | after assets             |
+| content code    | listed consuming files                          | after its data read-back |
+| validator       | read-only final checks                          | after all writers        |
+
+This is preserve mode, the default. When the user explicitly chose a framework
+conversion, one framework worker replaces runtime and routes and owns all
+structural target code. The content planner may run beside it. Data then waits
+for both the asset and framework gates, and code waits for real imported-data
+read-back.
+
+## Ownership
+
+- **runtime** preserves the detected framework, router, runtime, dependencies,
+  provider setup, environment wiring, and provider-specific configuration. An
+  unclear or unsupported setup produces a question, not a silent conversion.
+- **routes** preserves every route, redirect, 404, SEO/OG/social output,
+  sitemap, robots, feeds, headers, and other observable host behavior. A file
+  that consumes migrated content belongs to its later content-code worker.
+- **content planner** discovers and models all editable content, labels,
+  consumers, schemas, payloads, media obligations, and execution batches. It
+  never imports entries or rewrites consumers. Read
+  `references/workers/content-planner.md`.
+- **assets/forms** uploads every planner media obligation and patches payload
+  references. It replaces a form or integration only when Fimo preserves its
+  behavior end to end; otherwise it preserves or reports it.
+- **content data and code** execute the planner handoff without rediscovering
+  or redesigning it. Read `references/workers/content-execution.md`.
+- **locales** owns locale configuration, locale routing, and translated
+  visitor-visible labels.
+- **framework conversion** is used only after explicit user choice. Read
+  `references/workers/framework.md`.
+- **validator** authors nothing. Read `references/workers/validator.md`.
+
+If two lanes need one file, name one owner in the text plan and sequence the
+other after it. Do not add a metadata format for a small overlap.
+
+## Coordinator gates
+
+1. Run `fimo migrate init` and inspect the real target paths before workers
+   write.
+2. For URL-only sources, finish the Source Evidence Pack and its completeness
+   gate before reconstruction.
+3. Start runtime/routes/content-planner/locales together, or the framework
+   worker plus content planner/locales in conversion mode.
+4. After the content plan, upload every planned asset and patch payloads.
+5. Start data workers only after the asset gate and, in conversion mode, the
+   framework gate.
+6. Start each code worker only after its own imported records read back as
+   non-empty. A build over empty data proves nothing.
+7. Start the independent validator only after every writer has returned.
+
+Each prompt names the worker's source paths, exact target ownership, applicable
+reference above, and dependencies. Each report states status, duration, source
+evidence, files changed, Fimo writes, source items handled, unresolved work,
+and the next action. The coordinator verifies those claims against `git diff`,
+CLI read-back, and rendered routes.
+
+A source item is covered only when its target value exists and the application
+consumes it at the original behavior path, or when an explicit unresolved item
+names the impact and owner action. If validation fails, create one bounded
+repair task for that surface and rerun the validator; do not restart every
+worker.