qualia-framework 5.4.0 → 5.5.0

package/README.md

@@ -53,7 +53,7 @@ Open Claude Code in any project directory.
 /qualia-polish      # Design pass — flexible scope: component, route, app, redesign, critique, quick
 /qualia-ship        # Deploy to production
 /qualia-handoff     # Enforce the 4 mandatory handoff deliverables
-/qualia-report      # Mandatory end-of-session report + ERP upload
+/qualia-report      # Mandatory shift report + ERP upload before clock-out
 ```
 
 ### The Road — auto mode
@@ -127,8 +127,8 @@ Every project has a `.planning/JOURNEY.md` — the North Star document that maps
 Project
 └─ Journey (all milestones defined upfront)
    └─ Milestone (a release — 2-5 total, Handoff is always last)
-      └─ Phase (a feature-sized deliverable, 2-5 tasks)
-         └─ Task (atomic unit, one commit, one verification contract)
+      └─ Phase (a feature-sized deliverable, 2-5 internal tasks)
+         └─ Task (framework-internal unit, one commit, one verification contract)
 ```
 
 **Hard rules:**
@@ -137,7 +137,7 @@ Project
 - Every non-Handoff milestone needs **≥ 2 phases** (enforced by `state.js close-milestone`).
 - Milestone numbering is contiguous.
 
-**Why it matters:** non-technical team members can follow the ladder from any entry point. `/qualia` and `/qualia-milestone` render JOURNEY.md as a visual ladder with current position highlighted.
+**Why it matters:** non-technical team members can follow the ladder from any entry point. `/qualia` and `/qualia-milestone` render JOURNEY.md as a visual ladder with current position highlighted. In the ERP, the primary operational dates are project deadline, milestone deadline, and employee shift submission date; framework tasks stay internal to agent execution.
 
 ## What's Inside (v5.3.0)
 

package/agents/builder.md

@@ -93,18 +93,26 @@ which is fine and means there is nothing to apply yet.
 - If the plan says "use library X" — use library X
 - If something in the plan seems wrong, flag it but still follow the plan
 
-### 4. Self-Verify Your Work
+### 4. Self-Verify Your Work (Auto-Heal Loop)
 
-Before committing:
+Before committing, run the checks below. If any fail, **fix and retry up to 2 times** before giving up. This is a tight self-heal loop — moving correctness checks here saves a verifier round.
 
-1. Run every command in **Validation:** — they must pass
+1. Run every command in **Validation:** — they must pass.
 2. Mentally walk through each **Acceptance Criterion** — does the code actually produce that observable behavior?
-3. Run `npx tsc --noEmit` if you touched TypeScript files
-4. **If you touched any `.tsx/.jsx/.css/.scss/.html` file: run `node bin/slop-detect.mjs {touched paths}`. Exit 1 (critical findings) BLOCKS the commit.** Fix the findings (apply the rewrite recipe in the script's output), re-run, repeat until exit 0.
-5. No `// TODO`, no placeholder text, no stub functions
-6. Imports are wired — not just declared but actually used
+3. Run `npx tsc --noEmit` if you touched TypeScript files. On failure, capture the first 50 lines of error output, fix the offending file(s), re-run. Cap at 2 retries.
+4. **If you touched any `.tsx/.jsx/.css/.scss/.html` file: run `node bin/slop-detect.mjs {touched paths}`. Exit 1 (critical findings) BLOCKS the commit.** Fix the findings (apply the rewrite recipe in the script's output), re-run, repeat until exit 0 (also capped at 2 retries before BLOCKED).
+5. No `// TODO`, no placeholder text, no stub functions.
+6. Imports are wired — not just declared but actually used.
 
-If any Validation command fails, slop-detect returns 1, or any AC is not met, fix before committing. Do not commit and hope the verifier catches it.
+**Auto-heal protocol:**
+
+```
+attempt 1:  run validation → fix what failed → run again
+attempt 2:  run validation → fix what failed → run again
+attempt 3:  if still failing, return BLOCKED — do not commit broken code
+```
+
+If any Validation command fails after 2 retries, slop-detect returns 1 after 2 retries, or any AC is not met after a fix attempt, return `BLOCKED — {validation failure}: {first 20 lines of last error output}`. Do not commit and hope the verifier catches it.
 
 ### 5. Commit
 One atomic commit per task:
@@ -115,6 +123,15 @@ git commit -m "{concise description of what was built}"
 
 Stage specific files — never `git add .` or `git add -A`.
 
+## Scope Reduction Prohibition
+
+The plan was written with the full spec in mind. Don't simplify it. If a task says "validate with Zod schema X covering 6 fields" don't ship 3 fields. If it says "redirect on success" don't ship a console.log placeholder.
+
+**Banned phrases in code, comments, and commit messages:**
+`v1`, `// for now`, `// TODO: wire this up later`, `// hardcoded for now`, `// stub`, `// placeholder`, `// minimal version`, `// will improve later`, `mock for now` (in production code paths).
+
+If you cannot deliver the full spec because a dependency is genuinely missing, return `BLOCKED — dependency missing: {what}` per the deviation table. Do NOT ship a watered-down version with a TODO note.
+
 ## Scope Discipline
 
 Before writing or editing any file, check: Is this file listed in the task's **Files** section?

package/agents/plan-checker.md

@@ -132,6 +132,54 @@ Every frontend task MUST include a `**Design:**` field with:
 
 Non-frontend tasks (backend, migrations, API routes without UI) MUST NOT have a `**Design:**` field. Warn but don't fail if one is mistakenly added.
 
+### Rule 11: Requirement Coverage (when ROADMAP.md lists REQ-IDs)
+
+If `.planning/ROADMAP.md` exists and the current phase's section lists `Requirements covered:` with `REQ-ID`s (format `[A-Z]+-\d+`, e.g. `AUTH-01`, `BILLING-03`), every REQ-ID must be covered by at least one task. Coverage = the task's `**Why:**`, `**Acceptance Criteria:**`, or `**Action:**` field references the REQ-ID, OR the task's content directly implements that requirement (read the requirement description from `.planning/REQUIREMENTS.md` and confirm).
+
+**FAIL if:**
+- A REQ-ID listed for the current phase appears nowhere in the plan.
+- A task claims a REQ-ID but its Action/AC obviously doesn't implement it.
+
+**How to detect:**
+```bash
+# Extract REQ-IDs for this phase from ROADMAP.md
+awk '/^### Phase {N}:/,/^---|^### Phase/' .planning/ROADMAP.md | grep -oE '[A-Z]+-[0-9]+' | sort -u
+# Check each appears in the plan
+grep -oE '[A-Z]+-[0-9]+' .planning/phase-{N}-plan.md | sort -u
+```
+
+The set difference (REQ-IDs in roadmap minus REQ-IDs in plan) must be empty.
+
+If a REQ-ID is missing from the plan, REVISE: "REQ AUTH-03 is in scope for this phase per ROADMAP.md but no task implements it." Plan-wide, not task-specific.
+
+### Rule 9: Decision Coverage (when phase-context.md exists)
+
+If `.planning/phase-{N}-context.md` exists with a `## Locked Decisions` section, every `D-NN` row must be covered by at least one task. Coverage = the task references the ID in its `**Why:**` or `**Action:**` field, OR the task's Action implements the decision content directly (read the task and confirm).
+
+**FAIL if:**
+- A `D-NN` row exists in phase-context.md but no task in the plan references it or implements it.
+- A row from `## Deferred Ideas` is being implemented by a task (deferred = explicitly out-of-scope).
+
+**How to detect:**
+```bash
+grep -E '^\| D-[0-9]+' .planning/phase-{N}-context.md     # extract decision IDs
+grep -E 'D-[0-9]+' .planning/phase-{N}-plan.md            # check IDs appear in plan
+```
+
+If a decision ID appears in phase-context.md but not the plan, REVISE: "D-03 is locked but no task implements it." Plus the deferred check: if a task's Action matches a Deferred-Ideas row, REVISE.
+
+### Rule 10: Scope Reduction Detection
+
+LLMs systematically simplify specs. Scan the plan for banned phrases that signal scope reduction:
+
+```bash
+grep -niE '\b(v1|v2|simplified version|static for now|hardcoded for now|placeholder|basic version|minimal implementation|will be wired later|dynamic in future phase|skip for now|stub|mock for now|we can improve this later|quick win for now)\b' .planning/phase-{N}-plan.md
+```
+
+**FAIL if:** any match. Quote the offending line in the issue. The planner must rewrite the task to deliver the actual thing, OR explicitly justify the split using one of the three legitimate reasons (context cost > 50%, missing info, dependency conflict).
+
+Exception: `v1` / `v2` is fine when referring to the project's actual versioning (e.g., `migrate to API v2`). Distinguish by context.
+
 ### Rule 8: Validation commands test behavior, not just existence
 
 Each task's `**Validation:**` list must contain at least one `grep-match` or `command-exit` check — a command that proves the code DOES something. A task whose ONLY validation is `test -f {file}` will pass even if the file contains only `// TODO`.
@@ -152,7 +200,7 @@ Each task's `**Validation:**` list must contain at least one `grep-match` or `co
 
 ## Tool Budget
 
-Read the plan file once. Grep the codebase only to validate Rule 7 (locked decisions). Do NOT speculatively check whether files listed in the plan already exist — that's the builder's job. Max 10 tool calls per invocation.
+Read the plan file once. Read `.planning/phase-{N}-context.md` once if it exists (Rules 7 + 9). Read `.planning/ROADMAP.md` once if it exists (Rules 4 + 11). Grep the plan for scope-reduction phrases (Rule 10), decision IDs (Rule 9), and REQ-IDs (Rule 11). Do NOT speculatively check whether files listed in the plan already exist — that's the builder's job. Max 14 tool calls per invocation.
 
 ## Output Format
 
@@ -215,6 +263,6 @@ Before returning, self-check:
 - [ ] Every issue has a specific task reference
 - [ ] Every issue has a concrete fix instruction
 - [ ] No issue is "make it better" or "be more specific" without saying how
-- [ ] If plan passes, you actually verified all 7 rules (not just 1-2)
+- [ ] If plan passes, you actually verified all 11 rules (not just 1-2)
 
 Don't pass a plan you didn't fully check. Don't fail a plan for style preferences.

package/agents/planner.md

@@ -212,12 +212,36 @@ When a phase involves frontend work (pages, components, layouts, UI):
    - Include responsive: "works on 375px mobile and 1440px desktop"
 4. **Reference `@.planning/DESIGN.md`** in the Context field of every frontend task so builders read it before coding
 
+## Scope Reduction Prohibition
+
+LLMs systematically simplify specs. You will not. If a locked decision or success criterion says X, the plan delivers X — not a watered-down version that "we can extend later."
+
+**Banned phrases in task Action / Acceptance Criteria / Why fields:**
+`v1`, `v2`, `simplified version`, `static for now`, `hardcoded for now`, `placeholder`, `basic version`, `minimal implementation`, `will be wired later`, `dynamic in future phase`, `skip for now`, `stub`, `mock for now`, `we can improve this later`, `quick win for now`.
+
+**The only legitimate reasons to split scope across phases:**
+1. Implementing it would force a single task above ~50% builder context.
+2. Required information genuinely does not exist (data shape unknown, external API not yet specified).
+3. A dependency is owned by a future phase and the wave-graph cannot resolve it.
+
+If none of these apply, deliver the full spec. A self-check before returning the plan: grep your draft for the banned phrases. If you find one, rewrite the task to deliver the actual thing.
+
+## Decision Coverage Audit
+
+If `.planning/phase-{N}-context.md` exists with a `## Locked Decisions` section, every decision row carries an ID (e.g., `D-01`, `D-02`). Before returning the plan, confirm:
+
+- Every `D-XX` is covered by at least one task whose Action implements it. Reference the ID in that task's Why or Action (e.g., `Why: D-03 requires session tokens stored database-side, not in JWT`).
+- No `Deferred Ideas` row appears in any task. Deferred = out-of-scope for this phase.
+- `Discretion` items are the planner's call — no audit needed.
+
+If a locked decision has no covering task, add one. If you genuinely cannot, the phase scope is wrong and the plan-checker will block — STOP and surface the gap to the user.
+
 ## Rules
 
 1. **Plans complete within ~50% context.** More plans with smaller scope = consistent quality. 2-3 tasks per plan is ideal.
 2. **Tasks are atomic.** Each task = one commit. If a task touches 10+ files, split it.
 3. **"Done when" must be testable.** Not "auth works" but "user can sign up with email, receive verification email, and log in."
-4. **Honor locked decisions.** If PROJECT.md says "use library X" — the plan uses library X.
+4. **Honor locked decisions.** If PROJECT.md or phase-context.md says "use library X" — the plan uses library X.
 5. **No enterprise patterns.** No RACI, no stakeholder management, no sprint ceremonies. One person + Claude.
 6. **Context references are explicit.** Use `@filepath` so the builder knows exactly what to read.
 

package/bin/install.js

@@ -894,7 +894,7 @@ Client-specific preferences, design choices, and requirements. Loaded by \`/qual
     tips: [
       "⬢ Lost? Type /qualia for the next step",
       "⬢ Small fix? Use /qualia-quick to skip planning",
-      "⬢ End of day? /qualia-report before you clock out",
+      "⬢ End of day? /qualia-report submits your shift before clock-out",
       "⬢ Context isolation: every task gets a fresh AI brain",
       "⬢ The verifier doesn't trust claims — it greps the code",
       "⬢ Plans are prompts — the plan IS what the builder reads",
@@ -1105,7 +1105,7 @@ function printSummary({ member, target, claudeInstalled }) {
   console.log("");
   console.log(`  ${DIM}New project?${RESET}    ${TEAL}/qualia-new${RESET}`);
   console.log(`  ${DIM}Quick fix?${RESET}      ${TEAL}/qualia-quick${RESET}`);
-  console.log(`  ${DIM}End of day?${RESET}     ${TEAL}/qualia-report${RESET} ${DIM}(mandatory)${RESET}`);
+  console.log(`  ${DIM}End of day?${RESET}     ${TEAL}/qualia-report${RESET} ${DIM}(shift submission)${RESET}`);
   console.log(`  ${DIM}Stuck?${RESET}          ${TEAL}/qualia${RESET}`);
   console.log("");
   console.log(`  ${DIM2}${RULE}${RESET}`);

package/bin/plan-contract.js

@@ -21,6 +21,28 @@ const CHECK_TYPES = new Set([
   "file-exists", "grep-match", "command-exit", "behavioral",
 ]);
 
+// Scope-reduction detection — phrases that signal an LLM has watered down the
+// spec. The plan-checker agent does the same scan on the markdown plan; this
+// function does it on the JSON contract's free-text fields (action +
+// acceptance_criteria) so both paths catch the same failure mode.
+const SCOPE_REDUCTION_PHRASES = [
+  /\bv1\b/i, /\bv2\b/i, /simplified version/i, /static for now/i,
+  /hardcoded for now/i, /\bplaceholder\b/i, /basic version/i,
+  /minimal implementation/i, /will be wired later/i,
+  /dynamic in future phase/i, /skip for now/i, /\bstub\b/i,
+  /mock for now/i, /we can improve this later/i, /quick win for now/i,
+];
+
+function findScopeReductionPhrases(text) {
+  if (typeof text !== "string") return [];
+  const hits = [];
+  for (const re of SCOPE_REDUCTION_PHRASES) {
+    const m = text.match(re);
+    if (m) hits.push(m[0]);
+  }
+  return hits;
+}
+
 function isStringArray(v) {
   return Array.isArray(v) && v.every((x) => typeof x === "string");
 }
@@ -98,7 +120,15 @@ function validateTask(task, idx, allIds) {
     errs.push(`${where}.acceptance_criteria: must be a non-empty string[]`);
   }
   if (typeof task.action !== "string") errs.push(`${where}.action: required string`);
-  else if (task.action.length > 500) errs.push(`${where}.action: must be ≤ 500 characters (got ${task.action.length})`);
+  else {
+    if (task.action.length > 500) errs.push(`${where}.action: must be ≤ 500 characters (got ${task.action.length})`);
+    const actionHits = findScopeReductionPhrases(task.action);
+    if (actionHits.length) errs.push(`${where}.action: scope-reduction phrase(s) detected: ${actionHits.join(", ")} — rewrite to deliver the actual spec, or split via locked-decision channel`);
+  }
+  for (let i = 0; i < (task.acceptance_criteria || []).length; i++) {
+    const acHits = findScopeReductionPhrases(task.acceptance_criteria[i]);
+    if (acHits.length) errs.push(`${where}.acceptance_criteria[${i}]: scope-reduction phrase(s) detected: ${acHits.join(", ")}`);
+  }
   if (!isStringArray(task.context_files || [])) errs.push(`${where}.context_files: must be string[]`);
   if (!Array.isArray(task.verification) || task.verification.length === 0) {
     errs.push(`${where}.verification: must be a non-empty array`);
@@ -217,4 +247,5 @@ module.exports = {
   parseSafely,
   hashPlan,
   checkDrift,
+  findScopeReductionPhrases,
 };

package/docs/erp-contract.md

@@ -2,6 +2,17 @@
 
 The Qualia Framework optionally uploads session reports to the company ERP at `https://portal.qualiasolutions.net`. This document specifies the API shape.
 
+## Operating Model
+
+The ERP treats `/qualia-report` as an employee shift submission, not proof that an assigned task was finished. Employees clock out after their fixed daily hours and submit what happened during the shift: shipped work, partial progress, blockers, investigation, meetings, or no-code work.
+
+Primary ERP planning dates are:
+- Project deadline
+- Milestone deadline
+- Employee submission date from the uploaded report
+
+Phase and task counters remain framework telemetry. They help agents plan/build/verify, but they should not become the ERP's primary navigation, deadline model, or employee-performance label.
+
 ## Configuration
 
 Stored in `~/.claude/.qualia-config.json`:

package/guide.md

@@ -109,7 +109,7 @@ If neither helps, paste the error and ask Claude directly. If Claude can't fix i
 ## Session Start / End
 
 **Start:** Claude loads your project context automatically. The router banner shows your journey position ("M2 of 4 · P2 of 3").
-**End:** Run `/qualia-report` — this is mandatory before clock-out. The report is committed to git and (if ERP is enabled) uploaded to https://portal.qualiasolutions.net.
+**End:** Run `/qualia-report` — this is the mandatory clock-out submission. It reports what happened during the work shift, even if the work is unfinished. The report is committed to git and (if ERP is enabled) uploaded to https://portal.qualiasolutions.net.
 
 ## How It Works (you don't need to know this, but if curious)
 
@@ -120,7 +120,7 @@ If neither helps, paste the error and ask Claude directly. If Claude can't fix i
 - **Story-file plans:** Every task has Why / Acceptance Criteria / Depends on / Validation inline — the plan IS the brief.
 - **Wave execution:** Independent tasks run in parallel. Dependent tasks wait.
 - **Milestone-boundary pauses:** In `--auto` mode, the framework pauses only at real decision points. Everything else runs on rails.
-- **tracking.json:** Updated on every push. The ERP reads it automatically. Includes `milestone_name` + `milestones[]` so the ERP renders a proper tree instead of a flat list.
+- **tracking.json:** Updated on every push. The ERP reads it automatically. Includes `milestone_name` + `milestones[]` so the ERP can show project and milestone progress without exposing framework tasks as the main employee workflow.
 
 ## Quick Reference
 
@@ -134,4 +134,4 @@ If neither helps, paste the error and ask Claude directly. If Claude can't fix i
 | Finished the last phase of a milestone | `/qualia-milestone` |
 | About to ship | `/qualia-ship` |
 | Client is ready to take over | `/qualia-handoff` |
-| End of workday | `/qualia-report` (mandatory) |
+| End of workday / clock-out | `/qualia-report` (mandatory shift submission) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qualia-framework",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Claude Code workflow framework by Qualia Solutions. Plan, build, verify, ship.",
   "bin": {
     "qualia-framework": "./bin/cli.js"

package/skills/qualia-discuss/SKILL.md

@@ -67,10 +67,24 @@ Wait for response. Then:
 - Write an ADR in `.planning/decisions/ADR-{NNNN}-{slug}.md` ONLY when the decision is hard-to-reverse, surprising-without-context, AND involves real trade-offs (use the template — keep it scarce)
 - Drill deeper if the answer opens new branches
 
-### 4. Build the locked-decisions list
+### 4. Build the locked-decisions list (with IDs — machine-parseable downstream)
 
-For each resolved decision, capture: choice (what) / rationale (why) / source (who/when).
-Also track: **Discretion items** (planner decides) / **Deferred ideas** (NOT this phase) / **Risk flags** (watch during build) / **Open questions** (still unresolved).
+For each resolved decision, capture as a row with a stable ID `D-NN` (zero-padded, sequential within the phase). The planner's Decision Coverage Audit checks every `D-NN` is implemented; the plan-checker BLOCKS if any is missing.
+
+**Locked Decision row format:**
+
+| ID | Decision | Rationale | Source |
+|----|----------|-----------|--------|
+| D-01 | Use Supabase RLS for authorization, not middleware | Compliance requires database-level checks | discuss session 2026-05-09 |
+| D-02 | Store session tokens server-side, not in JWT | OWASP guidance + revocation requirement | ADR-0007 |
+
+Also track:
+- **Discretion items** — planner decides based on best practice (no IDs needed).
+- **Deferred ideas** — explicitly NOT this phase. The plan-checker will REVISE if any of these appears in a task.
+- **Risk flags** — watch during build (no IDs).
+- **Open questions** — still unresolved. Cannot lock until resolved.
+
+When you reference a decision later (in commit messages, task Why fields, ADRs), use its ID — `D-03` is shorter than the full decision text and cross-checkable.
 
 ### 5. Decision gate
 

package/skills/qualia-report/SKILL.md

@@ -9,9 +9,11 @@ allowed-tools:
   - AskUserQuestion
 ---
 
-# /qualia-report — Daily Clock-Out Report
+# /qualia-report — Daily Shift Report
 
-The end-of-day flow. Generates a report, commits it, pushes, uploads to the ERP, and tells the employee they can stop. Designed so Hasan and Moayad never get stuck on it.
+The end-of-day clock-out flow. Generates a shift report, commits it, pushes, uploads to the ERP, and tells the employee they can stop. Designed so Hasan and Moayad never get stuck on it.
+
+This is not a task-completion ceremony. The report records what happened during the employee's fixed work shift: shipped work, partial progress, blockers, investigation, meetings, or no-code work. A valid report can say "not finished yet" as long as it clearly explains the shift outcome and next step.
 
 ## Flags
 - `/qualia-report` — normal flow (generate, commit, push, upload to ERP)
@@ -60,18 +62,18 @@ None.   ← or list 1–N actual blockers (NOT "had to read docs" — that's nor
 2. ...
 ```
 
-**If `COUNT == 0`** — ask the employee gracefully (don't force a fake report):
+**If `COUNT == 0`** — ask the employee gracefully (don't force a fake report or fake completed task):
 
 Use `AskUserQuestion`:
 - header: "Empty day?"
-- question: "No commits in the last 8 hours. What did you do today?"
+- question: "No commits in the last 8 hours. What happened during your shift?"
 - options:
   - "Investigation / research only"
   - "Meetings / calls (no code)"
   - "Blocked — tell me on what"
   - "Time off / partial day"
 
-Capture the answer as the report body. Empty days are still valid clock-outs — the ERP needs to see them.
+Capture the answer as the report body. Empty days and unfinished work are still valid clock-outs — the ERP needs a truthful employee submission date and shift summary.
 
 ### Step 3 — Write report file
 
@@ -139,7 +141,7 @@ fi
 
 node ~/.claude/bin/qualia-ui.js divider
 node ~/.claude/bin/qualia-ui.js ok "Report $CLIENT_REPORT_ID complete."
-node ~/.claude/bin/qualia-ui.js info "You can clock out now. See you tomorrow."
+node ~/.claude/bin/qualia-ui.js info "Shift report submitted. You can clock out now."
 ```
 
 ## Common errors (read this when something goes wrong)

package/templates/CONTEXT.md

@@ -18,14 +18,15 @@ A unit of work inside a milestone. 2–5 tasks. Ends in a verification gate.
 **Avoid:** epic, story, ticket, sprint.
 
 ### Task
-A single commit-sized unit with one verification contract.
-**Avoid:** subtask, chore, todo.
+A framework-internal execution unit: one commit-sized work item with one verification contract.
+**Avoid:** using "task" as an ERP assignment or employee performance label unless the product domain explicitly needs it.
 
 ## Relationships
 - Project holds many Milestones
 - Milestone holds many Phases
 - Phase holds many Tasks
 - Task carries one Verification Contract
+- ERP tracks project deadlines, milestone deadlines, and employee shift submissions; framework tasks stay internal.
 - {{add domain-specific relationships, e.g. "Customer holds many Orders"}}
 
 ## Flagged ambiguities

package/templates/help.html

@@ -479,7 +479,7 @@
       <li><span class="rule-icon">1</span> Feature branches by default &mdash; OWNER overrides must be explicit</li>
       <li><span class="rule-icon">2</span> Read before write &mdash; understand files before editing</li>
       <li><span class="rule-icon">3</span> MVP first &mdash; build what's asked, nothing extra</li>
-      <li><span class="rule-icon">4</span> /qualia-report before clock-out &mdash; mandatory, enforced by ERP</li>
+      <li><span class="rule-icon">4</span> /qualia-report before clock-out &mdash; mandatory shift submission in ERP</li>
       <li><span class="rule-icon">5</span> Secrets through approved flows &mdash; use set-erp-key or ask Fawzi</li>
       <li><span class="rule-icon">6</span> Stuck 30+ minutes? Ask Fawzi</li>
     </ul>

package/templates/phase-context.md

@@ -13,11 +13,12 @@ Captured during `/qualia-discuss {N}` — decisions, trade-offs, and constraints
 
 ## Locked Decisions
 
-Non-negotiable choices. Planner must honor these exactly.
+Non-negotiable choices. Planner must honor these exactly. Every row has a stable ID (`D-NN`) — the planner's Decision Coverage Audit checks each is implemented; the plan-checker BLOCKS if any is missing.
 
-| Decision | Rationale | Source |
-|----------|-----------|--------|
-| {e.g., "Use Supabase RLS for authorization, not middleware"} | {e.g., "Client compliance requires database-level checks"} | {who/when} |
+| ID | Decision | Rationale | Source |
+|----|----------|-----------|--------|
+| D-01 | {e.g., "Use Supabase RLS for authorization, not middleware"} | {e.g., "Client compliance requires database-level checks"} | {who/when} |
+| D-02 | {next decision} | {rationale} | {source} |
 
 ## Discretion (Planner Chooses)
 

package/tests/bin.test.sh

@@ -1583,6 +1583,36 @@ else
   fail_case "package.json version not 5.x" "got=$PKG_V"
 fi
 
+echo ""
+echo "--- ERP shift-report contract ---"
+
+# 144. qualia-report describes clock-out as truthful shift submission, not task completion
+if grep -qi "daily shift report" "$TMP/.claude/skills/qualia-report/SKILL.md" \
+   && grep -qi "not a task-completion ceremony" "$TMP/.claude/skills/qualia-report/SKILL.md" \
+   && grep -qi "What happened during your shift" "$TMP/.claude/skills/qualia-report/SKILL.md"; then
+  pass "qualia-report frames clock-out as shift submission, not task completion"
+else
+  fail_case "qualia-report missing shift-submission contract"
+fi
+
+# 145. ERP contract documents the date model: project, milestone, employee submission
+if grep -q "Project deadline" "$FRAMEWORK_DIR/docs/erp-contract.md" \
+   && grep -q "Milestone deadline" "$FRAMEWORK_DIR/docs/erp-contract.md" \
+   && grep -q "Employee submission date" "$FRAMEWORK_DIR/docs/erp-contract.md" \
+   && grep -q "Phase and task counters remain framework telemetry" "$FRAMEWORK_DIR/docs/erp-contract.md"; then
+  pass "ERP contract documents project/milestone/submission date model"
+else
+  fail_case "ERP contract missing date-model clarification"
+fi
+
+# 146. Project glossary keeps framework tasks internal to agent execution
+if grep -q "framework-internal execution unit" "$FRAMEWORK_DIR/templates/CONTEXT.md" \
+   && grep -q "ERP tracks project deadlines, milestone deadlines, and employee shift submissions" "$FRAMEWORK_DIR/templates/CONTEXT.md"; then
+  pass "CONTEXT template distinguishes internal tasks from ERP workflow"
+else
+  fail_case "CONTEXT template missing framework-task vs ERP-workflow distinction"
+fi
+
 echo ""
 echo "=== Results: $PASS passed, $FAIL failed ==="
 [ "$FAIL" -eq 0 ] && exit 0 || exit 1

package/tests/lib.test.sh

@@ -57,6 +57,27 @@ console.log(errs.length > 0 ? "REJECTED" : "ACCEPTED");
 ')
 [ "$OUT" = "REJECTED" ] && ok "rejects malformed contract" || fail "malformed accepted"
 
+OUT=$($NODE -e '
+const pc = require("'"$PC"'");
+const slop = {
+  version: 1, phase: 1, goal: "x", why: "y",
+  generated_at: "t", generated_by: "planner", source_plan_hash: "h",
+  success_criteria: ["sc"],
+  tasks: [{
+    id: "T1", title: "t", wave: 1, depends_on: [],
+    files_modify: [], files_create: [], files_delete: [],
+    acceptance_criteria: ["minimal implementation of login"],
+    action: "Add hardcoded for now placeholder, will be wired later",
+    context_files: [],
+    verification: [{ type: "file-exists", path: "a.ts" }]
+  }]
+};
+const errs = pc.validate(slop);
+const hits = errs.filter(e => /scope-reduction/.test(e));
+console.log(hits.length >= 2 ? "DETECTED" : "MISSED:" + errs.join(";"));
+')
+[ "$OUT" = "DETECTED" ] && ok "detects scope-reduction phrases in action + acceptance_criteria" || fail "scope-reduction missed: $OUT"
+
 OUT=$($NODE -e '
 const pc = require("'"$PC"'");
 const c = {