@jabworks/condux 0.29.0 → 0.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jabworks/condux",
-  "version": "0.29.0",
+  "version": "0.31.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/preflight/SKILL.md

@@ -49,6 +49,12 @@ Run through this checklist. Every item must be answered honestly — not optimis
 │    No console.log, no debug code, no TODO comments that         │
 │    weren't there before, no commented-out blocks.               │
 │                                                                  │
+│  □ NO WORKAROUNDS                                               │
+│    Did anything here bypass a convention, widen a type,         │
+│    disable a rule, or special-case around a design just to      │
+│    make it land? Report it — the user decides whether it        │
+│    ships. Nothing bypassed → N/A, no commentary.                │
+│                                                                 │
 │  □ READY FOR FINALIZE                                           │
 │    All the above are yes → call /finalize                       │
 │    Any are no → fix first, then re-check                        │
@@ -100,6 +106,7 @@ a preflight failure like any other.
 | "The edge cases are unlikely"                  | They happen in production. Consider them now.            |
 | "The plan steps were mostly done"              | Mostly done is not done.                                 |
 | "I only changed one line, nothing could break" | One-line changes cause regressions too.                  |
+| "It's a small workaround, I'll do it properly later" | Later is a PR nobody opens. Report it; the user chooses.  |
 
 ## Output
 
@@ -112,6 +119,7 @@ a preflight failure like any other.
 □ Spec drift           ✓ / ✗ / N/A [notes]  (N/A = no spec for this task)
 □ No regressions       ✓ / ✗ [notes]
 □ Nothing left behind  ✓ / ✗ [notes]
+□ No workarounds       ✓ / ✗ / N/A [notes]  (N/A = nothing bypassed)
 
 → Ready for /finalize  [YES / NO — list blockers if NO]
 ```

package/skills/subagent-execution/SKILL.md

@@ -46,32 +46,22 @@ If you can't answer all four, don't spawn.
 
 ## Progress Ledger
 
-Conversation memory does not survive compaction. Track task completion in a
-ledger file, not only in todos.
-
-- At skill start, check for a ledger: `.condux/progress/<feature-slug>.md`
-  (slug inferred kebab-case from the plan's feature name — the same
-  convention `draft-plan` uses for its own filename). Tasks listed there as
-  complete are DONE — do not re-dispatch them; resume at the first task not
-  marked complete.
-- If no ledger exists, create it with a header naming the plan file:
-  ```
-  # Subagent Execution Progress: <feature-slug>
-
-  Plan: .condux/plans/<plan-file>.md
-
-  ```
-- When a task's review comes back clean, append one line in the same
-  message as other bookkeeping: `- [x] Task N: <name> — commits
-  <base7>..<head7>, review clean`.
-- The ledger is a recovery aid, not the source of truth — the commits it
-  names exist in git even if context no longer remembers creating them.
-  After compaction or a new session, trust the ledger and `git log` over
-  your own recollection.
-- `.condux/` is gitignored working state (see `/workflow` → Artifacts). If
-  it's ever deleted, recover progress from `git log` against the plan's task
-  list — and note the plan itself lived there too, so re-derive scope from
-  the spec in `specs/` if the plan is gone as well.
+The ledger contract — path, header, line format, wrap-up lines — is owned by
+`/workflow` → **Progress Ledger**, because inline execution keeps the same file;
+this section only adds what is specific to dispatching agents.
+
+- At skill start, check for a ledger: `.condux/progress/<feature-slug>.md`.
+  Tasks listed there as complete are DONE — do not re-dispatch them; resume at
+  the first task not marked complete.
+- If no ledger exists, create it with the header `/workflow` defines (naming the
+  plan file and the BASE commit).
+- When a task's review comes back clean, append one line in the same message as
+  other bookkeeping: `- [x] Task N: <name> — commits <base7>..<head7>, review
+  clean`.
+- After compaction or a new session, trust the ledger and `git log` over your own
+  recollection. If `.condux/` is ever deleted, recover progress from `git log`
+  against the plan's task list — and note the plan itself lived there too, so
+  re-derive scope from the spec in `specs/` if the plan is gone as well.
 
 ## How It Works
 

package/skills/workflow/SKILL.md

@@ -42,6 +42,11 @@ Condux is **lean and proportional** — the opposite of "always run every gate."
 6. **House style rides along.** Before the first line of code in any tier, load
    the `coding-directive` skill if it is installed — skip silently when it
    isn't. Codebase mimicry and repo config still win over the directive.
+7. **Two tracks, one of them triggered.** Tactical is the task in front of you.
+   Strategic is the environment that produced it — would a narrower type, a
+   lint rule, or a written convention have made this task's bug impossible?
+   The strategic track is *not* a standing obligation; that would violate rule
+   1. It fires on a trigger, and the triggers are in Environment Hardening.
 
 ## Entry Contract
 
@@ -102,8 +107,8 @@ Every tier ends with `preflight` then `finalize` — no exceptions.
   Overview · Files · Interfaces · Sketch where non-obvious · Edge cases) → CP-1 →
   implement top-to-bottom → CP-2 → `/preflight` → `/finalize` → CP-3.
 - **LARGE:** load `discovery`, run fully to sign-off → load `draft-plan`, produce the
-  plan doc, sign-off → CP-1 → implement task by task (`subagent-execution` if the
-  user picks it) → CP-2 → `/preflight` → `/finalize` → CP-3.
+  plan doc, sign-off → CP-1 → implement task by task, keeping the Progress Ledger
+  (`subagent-execution` if the user picks it) → CP-2 → `/preflight` → `/finalize` → CP-3.
 
 ## Checkpoints
 
@@ -167,7 +172,7 @@ Load each only when its step is reached.
 | `blueprint` | discovery's propose step, or a standalone mockup/visualization ask | load only when a UI surface or data model is in play; structure, never styling |
 | `draft-plan` | LARGE, after discovery sign-off | needs a signed-off design; no design → apply the discovery soft gate first |
 | `test-first-development` | user asks, or picks it at CP-1 | one upfront consent; always ask before editing an existing test spec |
-| `subagent-execution` | LARGE plan where specialization/parallelism pays off | default is implement yourself |
+| `subagent-execution` | LARGE plan where specialization/parallelism pays off | default is implement yourself; keeps the Progress Ledger |
 | `subagent-deployment` | 2+ independent tasks, no shared files/deps | ad-hoc work, not ordered plans |
 | `preflight` | end of every tier, before finalize | automatic on SMALL; recommended CP-2 choice |
 | `finalize` | after all implementation | runs in order, once, stops on first failure; check AGENTS.md for the real commands |
@@ -224,6 +229,40 @@ without asking. Not a git repo → fall back to CWD and say so once.
 **Override.** A project can relocate either tier in `AGENTS.md`; an explicit
 override always wins over these defaults.
 
+## Progress Ledger
+
+Conversation memory does not survive compaction, and a plan file records intent,
+not progress. Whoever implements a plan saved in `.condux/plans/` — you inline,
+or `subagent-execution` — keeps one ledger beside it,
+`.condux/progress/<feature-slug>.md` (the plan's file name minus its date and
+extension):
+
+```
+# Progress: <feature-slug>
+
+Plan: .condux/plans/<plan-file>.md
+BASE: <sha7 of HEAD before Task 1>
+
+- [x] Task 1: <name> — commit <sha7>
+- [x] preflight clean
+- [x] committed <sha7>; PR #N open
+```
+
+- **Task lines** are appended after the task's commit, one per task, in the same
+  message as ticking the todo. A line names a real commit.
+- **Wrap-up lines** (no task number) are appended as each checkpoint step
+  finishes: `code-review`, `preflight`, `finalize`, live verification, then the
+  commit or PR line. A tool that reads the ledger — the `/condux` board — turns
+  them into the pipeline's done and still-to-come steps.
+- **Start of work:** if a ledger exists, tasks ticked there are DONE; resume at
+  the first one that is not.
+- **No saved plan file, no ledger.** A SMALL task and a MEDIUM inline plan have
+  nothing for a ledger to key on; do not invent a plan file to get one.
+- The ledger is a recovery aid, not the source of truth: the commits it names
+  exist in git even when context no longer remembers them. `.condux/` is
+  gitignored working state (see Artifacts), so never cite a ledger from a
+  committed file.
+
 ## Agents
 
 Five **named specialist agents** ship with condux — never invent a generic subagent
@@ -253,6 +292,38 @@ Scope turns out bigger than the confirmed tier? Stop immediately, report what yo
 found ("this touches auth middleware, not just the UI"), re-confirm the tier before
 continuing. Never silently expand scope.
 
+## Environment Hardening
+
+The strategic track, fired by a trigger rather than run on every task. Two
+triggers, both observed rather than imagined:
+
+- **Repeated friction.** The same obstacle cost time twice — twice in this
+  task, or once here and once earlier in the session.
+- **A workaround taken.** You bypassed a convention, widened a type, disabled a
+  rule, or special-cased around a design to make the change land. `preflight`'s
+  no-workarounds box catches the ones you stopped noticing.
+
+When one fires, spend a sentence on the cause rather than the symptom. Agents
+succeed in a **pit of success** — an environment where the wrong thing is hard
+to express:
+
+| Lever | Looks like |
+|---|---|
+| Constrained surface | a narrower type, a smaller public API, an argument that cannot be passed wrong |
+| Rules that force correctness | a lint rule, a stricter compiler flag, a test that fails on the shape and not just the value |
+| Written convention | a line in `AGENTS.md` / `CLAUDE.md` or the house-style skill, so a reviewer cites it instead of re-deriving it |
+| Data the agent lacks | dev-server or production logs, a test database, browser access to watch the thing actually render |
+
+**The output is a sentence to the user, or a backlog item — never a new
+artifact.** Name the hardening and let the user decide. If a backlog skill
+(`record`, or the repo's own convention) is installed and they want it kept,
+file it there. Do not create a file for it, do not add a `.condux/` directory
+for it, and do not implement it inside the current task — that is scope
+expansion, which Escalating Mid-Task already forbids.
+
+**Silence is the correct output when neither trigger fired.** A clean SMALL
+task gets no hardening commentary at all.
+
 ## Red Flags
 
 Stop if you catch yourself doing any of these:
@@ -271,6 +342,7 @@ Stop if you catch yourself doing any of these:
 | Auto-running code-review, commits, or agents | They're checkpoint choices; run only when picked |
 | Verifying live without loading `live-verification` | Load it — its `report.md` is the evidence (9 of 11 ad-hoc runs in a mobile eval left none) |
 | Auto-advancing past a checkpoint on MEDIUM/LARGE | The user owns every transition |
+| Absorbing a workaround silently so the change lands | Name it — that's a hardening trigger, and preflight asks for it anyway |
 | Expanding scope past the confirmed tier | Stop, report, re-confirm |
 
 ## Tips

package/skills/workflow/hooks/hooks.json

@@ -11,5 +11,8 @@
         ]
       }
     ]
-  }
+  },
+  "modules": [
+    "./mod/register.tsx"
+  ]
 }