@jabworks/condux 0.25.2 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jabworks/condux",
-  "version": "0.25.2",
+  "version": "0.26.0",
   "description": "OpenCode plugin for the condux workflow toolkit — bundles the condux skills and injects the specialist agents (coder, explorer, planner, researcher) plus an opt-in plan-review listener.",
   "type": "module",
   "publishConfig": {

package/skills/finalize/SKILL.md

@@ -77,7 +77,7 @@ Tests fail
 
 ## Output Format
 
-The `Plan` line below only appears when no matching plan doc was found for the inferred feature slug — it's omitted entirely otherwise.
+The `Plan` line below only appears when no matching plan doc was found for the inferred feature slug — it's omitted entirely otherwise. In a mobile app project a `Native` line joins `Env` (see Companion Files); the example below is a web project, so it has none.
 
 ```
 ## Finalize: [task or feature name]
@@ -119,6 +119,13 @@ until it breaks someone else's checkout.
   example file (`.env.example`, `.env.sample`, or whatever it uses) gains the
   same key in the same change — placeholder value only, never a real secret.
 - Report `Env  ✓ n/a` when the diff adds none, so the check is visibly running.
+- **Native (mobile app projects only).** None of the gates above compiles the
+  native layer, so a diff that touches it passes everything and still is not
+  in the app until it is rebuilt and reinstalled. Classify the diff as
+  `JS only` or `native rebuild` and report it as a `Native` line; on a native
+  rebuild, end "Ready to commit — native rebuild needed before it can run" and
+  name the project's rebuild command. The path list, the fingerprint check and
+  when to omit the line are in `references/native-change.md`.
 
 ## What Does NOT Happen
 
@@ -134,3 +141,4 @@ until it breaks someone else's checkout.
 ## See Also
 
 - `references/rationalization-table.md` — common rationalizations for skipping finalize and why they're wrong
+- `references/native-change.md` — mobile apps: when a diff needs a native rebuild, the fingerprint check, the `Native` line

package/skills/finalize/references/native-change.md

@@ -0,0 +1,106 @@
+# Native-change check
+
+A mobile app has two layers. JavaScript reloads in seconds; the native binary
+(Kotlin/Swift, native modules, the compiled app config) only changes when the
+app is **rebuilt and reinstalled**. None of the JS gates — typecheck, lint,
+format, tests — compile the native layer, so a change that touches it can pass
+every gate and still not exist in the app on the device. This check makes that
+visible. It never blocks.
+
+Its verdict is used in three places: finalize reports it, workflow mentions it
+at tier confirmation, and live-verification acts on it before driving the app.
+
+## When it applies
+
+Only in an app project: an `expo` or `react-native` dependency in
+`package.json`, or a committed `android/` or `ios/` directory. Anywhere else,
+omit the `Native` line entirely — a web repo gets no noise from it.
+
+## The verdict
+
+Two outcomes. Name the escalation, lightest first:
+
+| Verdict | Means | To see the change |
+|---|---|---|
+| **JS only** | Nothing in the diff reaches the binary | Fast Refresh or a JS reload; restart the app process if a native module is left in a bad state |
+| **Native rebuild** | The diff touches something compiled into the binary | Rebuild the app (dev client or release build) and reinstall it; clear the app's data too when the change touches native state that persists across installs (notification channels, permissions, keychain entries, database schema created natively) |
+
+## How to decide
+
+**Precise — when a recorded fingerprint exists.** Expo projects can hash
+their native layer. If `.condux/native/fingerprint-<platform>.json` exists
+(recorded after the last native build — see below), generate a fresh one the
+same way and compare the two JSONs' `hash` fields:
+
+```bash
+# with expo-updates installed — per platform, the same hash EAS uses:
+npx expo-updates fingerprint:generate --platform android > .condux/native/now-android.json
+# without it — covers both platforms at once:
+npx @expo/fingerprint fingerprint:generate > .condux/native/now-all.json
+```
+
+Equal hashes are **JS only**. Different hashes are **Native rebuild** — then
+name what moved with
+`npx @expo/fingerprint fingerprint:diff <recorded> <now>`. The `now-*` file is
+overwritten on every check. Compare against the recording for the platform
+you are building; a both-platforms fingerprint also moves on iOS-only changes,
+so say which one you used. The fingerprint covers what a path list cannot
+see — autolinked native modules inside `node_modules`, config-plugin output,
+patches to native packages.
+
+**Core — always available.** Otherwise, read the task's diff. Any of these
+means **Native rebuild**:
+
+- local native code: `modules/**` (Expo modules), any `.kt`, `.java`, `.swift`,
+  `.m`, `.mm`, `.cpp`, `.h` file, `*.podspec`, `build.gradle*`
+- committed native projects: `android/**`, `ios/**` (if they are generated by
+  prebuild, the real change is upstream of them — find it)
+- app config compiled into the binary: in `app.json` / `app.config.*`, the
+  `plugins`, `permissions`, `android`/`ios` blocks, `name`, `scheme`, `version`,
+  `runtimeVersion`, splash and icon assets; any config-plugin source file
+- dependencies: a package added, removed or version-changed in `package.json`
+  that ships native code (it has an `android/` or `ios/` directory, or an
+  `expo-module.config.json`), and every Expo SDK or React Native upgrade
+- patches: `patches/**` touching a native package, `cng-patches/**`
+- `eas.json` build-profile changes that alter what is compiled
+
+When a file's effect is unclear, say **Native rebuild** and name the file —
+a wasted rebuild costs minutes; a verification against a stale binary costs
+the whole verification.
+
+**Project override.** If `AGENTS.md` lists the project's native paths or its
+rebuild command, those win over the lists above.
+
+## Recording the fingerprint
+
+The precise check needs a baseline, so whoever rebuilds and installs the app
+records one straight after the install succeeds:
+
+```bash
+mkdir -p .condux/native
+npx expo-updates fingerprint:generate --platform android > .condux/native/fingerprint-android.json
+# or, without expo-updates:
+npx @expo/fingerprint fingerprint:generate > .condux/native/fingerprint-all.json
+```
+
+It lives in `.condux/` (working state, gitignored) because it describes the
+build installed on *this* machine's device or emulator, not the repository.
+Only Expo projects record one — the fingerprint reads the Expo config, and
+`npx` fetches the tool if it isn't installed. Bare React Native and native-only
+projects use the core check alone.
+
+## Reporting
+
+In finalize's output, beside `Env`:
+
+```
+Native     ✓ JS only (android fingerprint unchanged) — a reload shows it
+Native     ⚠ native rebuild — modules/app-lock/android/…/AppLockModule.kt, app.json plugins
+             not compiled by any gate; rebuild with `npx expo run:android` and reinstall before verifying
+```
+
+Take the rebuild command from `AGENTS.md` or `package.json` scripts; if
+neither names one, say "rebuild the app" and stop — never guess a build
+command. On **Native rebuild**, finalize ends "Ready to commit — native rebuild
+needed before it can run": the code is clean; the app just does not contain it
+yet.

package/skills/live-verification/SKILL.md

@@ -43,6 +43,15 @@ Do not assume a dev server. In order:
 Start it in the background, wait for it to actually serve (poll the URL — do
 not `sleep` and hope), and note the URL in the report.
 
+**Mobile app: rebuild first when the change is native.** If finalize's
+`Native` line said *native rebuild* (or the diff touches the native layer —
+see finalize's native-change check), the installed app does not contain the
+change. Rebuild and reinstall it before driving anything, and clear the app's
+data when the change touches native state that persists across installs. On
+an Expo project, record the new fingerprint as that check describes. A verdict
+driven on the old binary is a verdict on code that isn't there — if the
+rebuild can't run here, stop and report that instead.
+
 ### Step 2 — Enumerate the claims
 
 Before touching the UI, write down what the change claims to do — one line

package/skills/workflow/SKILL.md

@@ -70,7 +70,11 @@ Every tier ends with `preflight` then `finalize` — no exceptions.
 ## The Router
 
 1. **Infer the tier.** How many files? Requirement clear or needs design? Crosses
-   service/package boundaries? Unknowns needing exploration first?
+   service/package boundaries? Unknowns needing exploration first? In a mobile
+   app, also: does it touch the native layer (finalize's native-change check
+   lists what does)? That doesn't change the tier — a one-line Kotlin fix is
+   still SMALL — but say so when confirming, because nothing can verify it
+   until the app is rebuilt and reinstalled.
 2. **Spec lookup.** Detect the package root (walk up from CWD to git root, find the
    nearest `package.json` / `Cargo.toml` / `go.mod` / `pyproject.toml`). Check both
    scopes (deduplicate if identical):