novahiz 0.9.8 → 0.10.0

package/CHANGELOG.md

@@ -5,6 +5,103 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-10-22
+
+### Fixed
+
+- **The gate and the injected block now agree on the pipeline** - `R6-Novahiz`
+  required plan/clarify/analyse/implement/converge on every workflow prompt,
+  while the roadmap loop only enforced `kind: "skill"`. A lite or Flutter task
+  could therefore announce nothing (or five skills) and be blocked for seven.
+  `R6` is removed and every non-optional roadmap step that carries
+  `requireSkills` is enforced, whatever its kind (`skill`, `edit`, `verify`,
+  `advisory`). `R10-security` is removed too: the audit roadmap already names
+  `novahiz-security`. `R11-accessibility` is narrowed to `design-ui`. The
+  catalogue now holds 13 rules instead of 15.
+- **A trivial follow-up no longer disarms the gate** - the plugin kept the
+  classification in memory only. `continue` / `ok`, or a plugin restart, fell
+  back to `general/trivial` and the gate allowed every edit with `missing: []`.
+  The last non-trivial classification is now persisted in the `sessions` table
+  (schema v3 adds the `prompt` and `tier` columns), `classify --session`
+  returns the effective classification, and the gate CLI reads that state from
+  the database when categories and prompt are empty.
+- **`doctor` reports a schema mismatch** - the schema check hardcoded
+  `ok: true`; it now compares `PRAGMA user_version` with `SCHEMA_VERSION`.
+- **The gate no longer blocks provably read-only shell commands** -
+  `git status`, `git log`, `git diff`, `ls`, `Get-Content` and their
+  equivalents are exempt (`src/readonly.ts`). The gate used to ask for the
+  design skills before it would let an agent read a file.
+- **French UI prompts are no longer fail-open** - `ajoute` / `ajouter` now
+  score as lite and `implémente` as full, so a French additive request reaches
+  the pipeline instead of falling through to trivial. `design-ui` recognises
+  `bouton`, `écran`, `connexion`, `formulaire`, `menu`, `champ`, `icône`,
+  `carte`, `modal`, `header`, `sidebar` and their English forms. Numeric
+  micro-changes (`ajoute 8px de marge`) stay trivial, and debug words
+  (`bug`, `error`, `crash`, ...) subtract from `design-ui` so
+  `fix the login bug` stays in `debug` instead of dragging the design pipeline
+  into a fix.
+
+### Changed
+
+- The gate CLI falls back to the persisted session state when the caller
+  passes no categories and no prompt, instead of letting the decision rest on
+  an empty classification.
+- The plugin asks `classify --session` and, for a trivial continuation,
+  inherits the previous task's prompt so the tier does not drop back to
+  trivial mid-task.
+
+### Added
+
+- **Session state persistence** - `src/session.ts` stores the categories, tier
+  and prompt of the last non-trivial task, with a TTL that keeps a stale
+  session from being mistaken for a continuation.
+- **A read-only allowlist for the gate** - `src/readonly.ts` lists the shell
+  commands the gate can prove do not write.
+- **The `novahiz-capture` skill** - reliable screenshot capture for the
+  physical Playwright browser, when a plain capture comes back stale, blank
+  or cropped.
+- **Three test files** - `tests/session-state.test.ts`, `tests/readonly.test.ts`
+  and `tests/gate-alignment.test.ts` pin the session state, the read-only
+  exemption and the alignment between the classifier and the gate.
+
+## [0.9.9] - 2026-10-16
+
+### Changed
+
+- **`novahiz upgrade --apply` now finishes the job it started** - it stopped at
+  `npm install -g novahiz@latest`, which refreshes the global package and
+  nothing else: `~/.config/novahiz`, the plugin copy and the MCP entrypoints
+  stayed on the previous version. It now resyncs the whole installation from
+  the fresh package (`install.mjs --yes --clean`) on both channels, so
+  `novahiz update` behaves exactly the same. If the update or the resync
+  fails, the command stops and reports the error instead of announcing a
+  completed upgrade.
+
+### Added
+
+- **A cleanup of the previous installation, opt-in** - an update used to leave
+  behind whatever it no longer shipped: a renamed skill stayed loadable, a
+  removed plugin stayed registered. `install.mjs --clean` now removes the files
+  a previous install wrote whose source has disappeared. The only proof of
+  ownership is the install manifest (`.novahiz-install.json`, field `created`):
+  a skill or a command placed by a pack is not in it, so it cannot be removed.
+  The rule "absent from the source" was the tempting one and it is wrong here —
+  it would have deleted `impeccable`, which the pack keeps in
+  `~/.agents/skills`. Three guards hold: only files under the four installed
+  roots, never after a failed step, never without `--clean`. A `.novahiz-bak`
+  goes with the file it backed up and never alone. `novahiz.config.json`,
+  `project-memory/` and `novahiz.sqlite` sit outside those roots, untouched by
+  construction.
+
+### Fixed
+
+- **`pruneEmptyDirs` never removed anything** - it called
+  `rmSync(dir, { recursive: false })`, which throws `ERR_FS_EISDIR` on a
+  directory, and the surrounding `catch` swallowed the error. The function
+  looked like it worked and silently left every emptied directory behind, for
+  `novahiz uninstall` as well. It now uses `recursive: true`, which is safe
+  because the directory is already known to be empty.
+
 ## [0.9.8] - 2026-10-15
 
 ### Removed

package/README.md

@@ -125,12 +125,10 @@ flowchart TD
     C --> D[R13 : prompt design-ui ou fichier style ?<br/>exiger humanizer + ui-slop + ui-craft]
     C --> F[R3 : le prompt était Supabase ?<br/>exiger novahiz-supabase + postgres]
     C --> G[R4 : le prompt était navigateur ?<br/>exiger novahiz-browser]
-    C --> H[R6 : prompt de workflow ?<br/>exiger plan/clarify/analyse/implement/converge]
     
-    D --> I{Application de la roadmap}
+    D --> I{Application de la roadmap<br/>étapes non optionnelles}
     F --> I
     G --> I
-    H --> I
     
     I --> J{Détection de placeholder<br/>tokens TODO / FIXME / placeholder}
     
@@ -160,18 +158,20 @@ flowchart TD
 |-------|------------------|-------|
 | R3-supabase | Un chemin Supabase ou un prompt Supabase | novahiz-supabase, novahiz-postgres |
 | R4-playwright | Une catégorie prompt navigateur, ou un chemin de test navigateur (`**/*.spec.ts`, `**/e2e/**`, `**/playwright/**`, …) | novahiz-browser |
-| R6-Novahiz | Un prompt dans une catégorie de workflow | novahiz-plan, -clarify, -analyse, -implement, -converge |
 | R7-assessment | Un prompt d'assessment | novahiz-assess-intake, -research, -define, -shape, -decide |
 | R8-docs | Une édition sous `novahiz-docs/**/*.md` | novahiz-docs |
 | R9-code-review | Un prompt de review ou un fichier de code en review | novahiz-code-review |
-| R10-security | Un prompt d'audit ou de sécurité | novahiz-security |
-| R11-accessibility | Un prompt design-ui ou audit | novahiz-wcag-audit |
+| R11-accessibility | Un prompt design-ui | novahiz-wcag-audit |
 | R12-web-extract | Un prompt de recherche | novahiz-web-extract |
 | R13-design-craft | Un prompt design-ui ou un fichier style (css/scss/less/html) | novahiz-humanizer, ui-slop-remover, ui-craft-rules |
 | R14-impeccable | Un prompt design-ui ou un fichier style (css/scss/less/html) | impeccable |
 
 `novahiz-humanizer` et `ui-slop-remover` ne sont exigées que sur les tâches de design frontend (R13) ; `impeccable` se charge de la même façon (R14) pour garder les playbooks shape, critique, audit, harden et polish accessibles, et la roadmap design-ui porte une étape de vérification `impeccable detect` déterministe avant ship. `novahiz init` et `novahiz doctor` affichent les fichiers de contexte `PRODUCT.md` / `DESIGN.md` d'impeccable en lignes advisory.
 
+Le pipeline (plan, clarify, analyse, implement, converge) n'est plus une règle : il vient des étapes non optionnelles de la roadmap de la catégorie principale, quel que soit leur `kind` (`skill`, `edit`, `verify`, `advisory`). Une seule source de vérité, donc le bloc affiché et le gate ne peuvent plus diverger sur ce point.
+
+Les commandes shell prouvées en lecture seule (`git status`, `git log`, `git diff`, `ls`, `Get-ChildItem`, `Get-Content`, `rg`, `Select-String`, …) sont exemptées avant toute règle ou roadmap. Dès qu'une commande chaîne, redirige, substitue ou porte un flag d'écriture, l'exemption tombe et le gate s'applique normalement.
+
 ### Gate reload
 
 Un blocage n'est jamais une impasse. Le refus embarque une recette GATE RELOAD : charger chaque skill nommée via le loader, puis rejouer l'appel exact une fois — aucun outil alternatif, aucune écriture shell, aucun contournement d'édition. Si les mêmes skills sont de nouveau signalées manquantes, le chargement n'a pas été enregistré : exécuter `novahiz doctor`, signaler honnêtement, et s'arrêter. La seule dérogation sanctionnée est `NOVAHIZ_GATE=off` (voir Configuration), déclarée à voix haute.

package/adapters/opencode/agent/novahiz.md

@@ -2,6 +2,7 @@
 description: Novahiz primary agent. Classifies the request, loads the required skills, then works under the Novahiz gate.
 mode: primary
 temperature: 0.2
+color: "#22c55e"
 # opencode denies `question` by default. The built-in build and plan agents
 # re-allow it; a custom agent inherits the denial unless it asks. Without this
 # block the pipeline cannot ask a clarifying question or validate a plan.

package/adapters/opencode/commands/novahiz-upgrade.md

@@ -8,6 +8,6 @@ description: Check for a new Novahiz version and update it via npm. Arguments: $
 
 3. If an update is available, report the installed -> latest versions, then ask the user for explicit approval. Never run the update without that approval (skip this confirmation only when `$ARGUMENTS` contains `--yes`).
 
-4. After approval, run `novahiz upgrade --apply` (same CLI used in step 1). This runs `npm install -g novahiz@latest` for npm installs, or `git pull --ff-only` plus a catalog rebuild for source checkouts. Report the exact result, including any npm/git error verbatim — never claim success you did not observe.
+4. After approval, run `novahiz upgrade --apply` (same CLI used in step 1). It installs `novahiz@latest` globally for npm installs, or pulls with `--ff-only` for source checkouts, then resyncs the Novahiz home and the opencode config from the fresh package and cleans what the previous version left behind. The cleanup only removes files the previous install manifest proves Novahiz wrote and whose source no longer exists: pack skills, `novahiz.config.json`, `project-memory/` and the vault are never touched. If the update or the resync fails, the command stops before the cleanup. Report the exact result, including any npm/git error verbatim — never claim success you did not observe.
 
 5. Finish by telling the user to restart OpenCode completely so the new version loads. Offer `novahiz doctor` as the follow-up check.

package/adapters/opencode/novahiz-plugin.ts

@@ -1633,7 +1633,7 @@ async function setup(ctx: Context): Promise<Cleanup> {
       // P0-B: the prompt travels on stdin. On argv it allowed option
       // injection (--home), broke past the Windows 32k limit, and was
       // readable in the process list.
-      const result = await run(["classify", "--stdin"], classifyText);
+      const result = await run(["classify", "--stdin", "--session", sessionID], classifyText);
       if (result.status !== 0) {
         classifyFailedBySession.set(sessionID, `classify exit ${result.status}`);
         await log("warn", `Classify failed (exit ${result.status}), gate tool calls refused for this session: ${result.stderr.trim().slice(0, 200)}`);
@@ -1645,6 +1645,7 @@ async function setup(ctx: Context): Promise<Cleanup> {
         requiredSkills?: string[];
         enforcedSkills?: string[];
         providers?: string[];
+        continuedFrom?: string;
         roadmaps?: { id: string; steps: { label: string; kind: string; requireSkills?: string[] }[] }[];
       };
       try {
@@ -1666,7 +1667,11 @@ async function setup(ctx: Context): Promise<Cleanup> {
       categoriesBySession.set(sessionID, categories);
       // P1-4: the gate takes the last prompt as its tier seed via --prompt even
       // when memory auto is off — set unconditionally, not inside MEMORY_AUTO.
-      lastPromptBySession.set(sessionID, text.slice(0, 300));
+      // A trivial follow-up ("continue") inherits the previous task's prompt:
+      // using the literal "continue" here would retier the session as trivial
+      // and skip the roadmap the classify call just restored.
+      const effectivePrompt = parsed.continuedFrom ?? text;
+      lastPromptBySession.set(sessionID, effectivePrompt.slice(0, 300));
       const primary = parsed.primary ?? categories[0] ?? null;
       const enforced = parsed.enforcedSkills ?? [];
       const required = parsed.requiredSkills ?? [];
@@ -1677,6 +1682,9 @@ async function setup(ctx: Context): Promise<Cleanup> {
         "[Novahiz enforcement]",
         `Categories detected: ${categories.join(", ") || "none"}${primary ? ` (primary: ${primary})` : ""}`
       ];
+      if (parsed.continuedFrom) {
+        lines.push(`Continuing the previous task: ${parsed.continuedFrom.slice(0, 160)}`);
+      }
       if (rewrite.sourceLanguage !== "en") {
         lines.push(`User language: ${rewrite.sourceLanguage} — respond in this language, not English.`);
       }
@@ -1699,7 +1707,7 @@ async function setup(ctx: Context): Promise<Cleanup> {
           await log("warn", "Ledger state is invalid JSON, enforcement injected without the task summary");
         }
       }
-      lines.push("The gate blocks edit/write/patch/apply_patch/bash/shell until the required skills are loaded via skill({id:\"...\"}).");
+      lines.push("The gate blocks edit/write/patch/apply_patch/bash/shell until the required skills are loaded via skill({id:\"...\"}). Read-only shell commands (status/log/diff/ls/Get-Content/...) are exempt.");
       lines.push("The gate is content-aware: novahiz-humanizer, ui-slop-remover and ui-craft-rules are required only on frontend design tasks (R13), and impeccable on the same design selectors (R14).");
       lines.push("Config edited = opencode restart required (config read at import).");
       lines.push("Memory lives in project-memory/ under the project root (cwd): index.json + fixed-size slots (8000 chars / 200 lines) with compact → archive → new-slot rotation. Use the MCP memory_* tools: memory_search to find relevant slots first, then memory_get to read, memory_write to append, memory_update to correct, memory_archive to retire.");

package/catalog/categories.json

@@ -756,7 +756,206 @@
       "accessibility",
       "a11y",
       "dashboard",
-      "form",
+      {
+        "term": "form",
+        "weight": 2
+      },
+      {
+        "term": "forms",
+        "weight": 2
+      },
+      {
+        "term": "formulaire",
+        "weight": 2
+      },
+      {
+        "term": "formulaires",
+        "weight": 2
+      },
+      {
+        "term": "bouton",
+        "weight": 2
+      },
+      {
+        "term": "boutons",
+        "weight": 2
+      },
+      {
+        "term": "button",
+        "weight": 2
+      },
+      {
+        "term": "buttons",
+        "weight": 2
+      },
+      {
+        "term": "écran",
+        "weight": 2
+      },
+      {
+        "term": "screen",
+        "weight": 2
+      },
+      {
+        "term": "screens",
+        "weight": 2
+      },
+      {
+        "term": "connexion",
+        "weight": 1
+      },
+      {
+        "term": "login",
+        "weight": 1
+      },
+      {
+        "term": "sign in",
+        "weight": 1
+      },
+      {
+        "term": "signin",
+        "weight": 1
+      },
+      {
+        "term": "sign up",
+        "weight": 1
+      },
+      {
+        "term": "signup",
+        "weight": 1
+      },
+      {
+        "term": "inscription",
+        "weight": 1
+      },
+      {
+        "term": "mot de passe",
+        "weight": 1
+      },
+      {
+        "term": "password",
+        "weight": 1
+      },
+      {
+        "term": "champ",
+        "weight": 1
+      },
+      {
+        "term": "field",
+        "weight": 1
+      },
+      {
+        "term": "input",
+        "weight": 1
+      },
+      {
+        "term": "menu",
+        "weight": 1
+      },
+      {
+        "term": "icône",
+        "weight": 1
+      },
+      {
+        "term": "icon",
+        "weight": 1
+      },
+      {
+        "term": "carte",
+        "weight": 1
+      },
+      {
+        "term": "card",
+        "weight": 1
+      },
+      {
+        "term": "modal",
+        "weight": 1
+      },
+      {
+        "term": "dialog",
+        "weight": 1
+      },
+      {
+        "term": "dialogue",
+        "weight": 1
+      },
+      {
+        "term": "header",
+        "weight": 1
+      },
+      {
+        "term": "footer",
+        "weight": 1
+      },
+      {
+        "term": "sidebar",
+        "weight": 1
+      },
+      {
+        "term": "composant",
+        "weight": 1
+      },
+      {
+        "term": "component",
+        "weight": 1
+      },
+      {
+        "term": "onglet",
+        "weight": 1
+      },
+      {
+        "term": "tab",
+        "weight": 1
+      },
+      {
+        "term": "avatar",
+        "weight": 1
+      },
+      {
+        "term": "badge",
+        "weight": 1
+      },
+      {
+        "term": "tooltip",
+        "weight": 1
+      },
+      {
+        "term": "toast",
+        "weight": 1
+      },
+      {
+        "term": "snackbar",
+        "weight": 1
+      },
+      {
+        "term": "drawer",
+        "weight": 1
+      },
+      {
+        "term": "panneau",
+        "weight": 1
+      },
+      {
+        "term": "panel",
+        "weight": 1
+      },
+      {
+        "term": "accueil",
+        "weight": 1
+      },
+      {
+        "term": "welcome",
+        "weight": 1
+      },
+      {
+        "term": "home",
+        "weight": 1
+      },
+      {
+        "term": "homepage",
+        "weight": 1
+      },
       "onboarding",
       "frontend design",
       "ui component",
@@ -773,7 +972,15 @@
     "negativeKeywords": [
       "migration",
       "rls",
-      "edge function"
+      "edge function",
+      "bug",
+      "error",
+      "crash",
+      "exception",
+      "regression",
+      "stacktrace",
+      "panic",
+      "broken"
     ],
     "defaultSkills": [
       "novahiz-humanizer",

package/catalog/rules.json

@@ -26,30 +26,6 @@
     },
     "require": ["novahiz-browser"]
   },
-  {
-    "id": "R6-Novahiz",
-    "description": "Load Novahiz pipeline skills for any task triggering the workflow.",
-    "when": {
-      "promptCategories": [
-        "code",
-        "debug",
-        "review",
-        "audit",
-        "browser",
-        "design-ui",
-        "database-supabase",
-        "docs-writing",
-        "planning",
-        "devops",
-        "data",
-        "general",
-        "flutter",
-        "expo",
-        "test"
-      ]
-    },
-    "require": ["novahiz-plan", "novahiz-clarify", "novahiz-analyse", "novahiz-implement", "novahiz-converge"]
-  },
   {
     "id": "R7-assessment",
     "description": "Load Idea Assessment pipeline skills.",
@@ -80,21 +56,12 @@
     },
     "require": ["novahiz-code-review"]
   },
-  {
-    "id": "R10-security",
-    "description": "Load novahiz-security on any security audit or hardening task.",
-    "when": {
-      "match": "any",
-      "promptCategories": ["audit"]
-    },
-    "require": ["novahiz-security"]
-  },
   {
     "id": "R11-accessibility",
-    "description": "Load novahiz-wcag-audit on design-ui work and on audit prompts, where accessibility is in scope.",
+    "description": "Load novahiz-wcag-audit on design-ui work, where accessibility is in scope.",
     "when": {
       "match": "any",
-      "promptCategories": ["design-ui", "audit"],
+      "promptCategories": ["design-ui"],
       "pathExcludes": ["**/tests/**", "**/__tests__/**", "**/*.test.*", "**/*.spec.*"]
     },
     "require": ["novahiz-wcag-audit"]

package/dist/classify.js

@@ -58,7 +58,11 @@ function skillsOfCategory(category) {
 function enforcedOfCategory(category) {
     const skills = [];
     for (const step of category.roadmap?.steps ?? []) {
-        if (step.kind !== "skill" || step.optional)
+        // Every non-optional step counts, whatever its kind: `edit:implement` and
+        // `verify:converge` carry skills too. Restricting to kind "skill" made
+        // lite/debug roadmaps advertise nothing while the gate demanded R6's
+        // implement/converge — the block and the gate disagreed.
+        if (step.optional)
             continue;
         for (const skill of step.requireSkills ?? []) {
             if (!skills.includes(skill))

package/dist/commands/doctor.js

@@ -691,17 +691,19 @@ export async function commandDoctor(parsed) {
     // matches by the time this reads it. The value is read so a future migration
     // has something to branch on, and so a database from an older build shows up.
     let schemaDetail = "database unreadable";
+    let schemaOk = false;
     try {
         const db = openDb(dbFile);
         const row = db.prepare("PRAGMA user_version").get();
         const version = Number(row?.user_version ?? 0);
         db.close();
         schemaDetail = `version ${version} (expected ${SCHEMA_VERSION})`;
+        schemaOk = version === SCHEMA_VERSION;
     }
     catch (error) {
         schemaDetail = `unreadable: ${error.message}`;
     }
-    checks.push({ id: "schema", label: "Schema version", ok: true, detail: schemaDetail, blocking: false });
+    checks.push({ id: "schema", label: "Schema version", ok: schemaOk, detail: schemaDetail, blocking: false });
     const adapterSource = join(root, "adapters", "opencode", "novahiz-plugin.ts");
     const opencodeDir = process.env.OPENCODE_CONFIG_DIR && process.env.OPENCODE_CONFIG_DIR.length > 0
         ? process.env.OPENCODE_CONFIG_DIR

package/dist/commands/gate.js

@@ -10,6 +10,8 @@ import { changeText } from "../content.js";
 import { classify } from "../classify.js";
 import { enforceLedgerChecks, evaluateGate } from "../gate.js";
 import { extractTargetPaths } from "../targets.js";
+import { isReadOnlyCommand } from "../readonly.js";
+import { isValidSessionId, readSessionClassification } from "../session.js";
 export function commandGate(parsed) {
     const root = NovahizHome();
     let spec;
@@ -91,7 +93,7 @@ export function commandGate(parsed) {
     const single = asString(parsed.flags.file);
     let content = asString(parsed.flags.content);
     // C1: the prompt that triggered the edit drives the complexity tier.
-    const prompt = asString(parsed.flags.prompt);
+    let prompt = asString(parsed.flags.prompt);
     let paths;
     if (single.length > 0) {
         paths = [single];
@@ -109,6 +111,18 @@ export function commandGate(parsed) {
                 return;
             }
         }
+        // P0: a read-only shell command (status/log/diff/ls/...) is not an edit.
+        // It is exempted before any prompt rule, category or ledger check runs —
+        // the gate's job is to guard writes, not to make `git status` cost five
+        // skill loads. Unrecognised or chained commands fall through unchanged.
+        if ((tool === "bash" || tool === "shell") && args !== null && typeof args === "object") {
+            const record = args;
+            const command = typeof record.command === "string" ? record.command : typeof record.cmd === "string" ? record.cmd : "";
+            if (isReadOnlyCommand(command)) {
+                print({ allow: true, tool, readonly: true, reason: "read-only shell command" });
+                return;
+            }
+        }
         paths = extractTargetPaths(tool, args);
         if (content.length === 0)
             content = changeText(tool, args);
@@ -118,6 +132,27 @@ export function commandGate(parsed) {
         process.exitCode = 1;
         return;
     }
+    // P0: after a plugin restart the in-memory categories are gone and the
+    // caller sends neither categories nor prompt. Read the last non-trivial
+    // classification back from the session instead of classifying an empty seed
+    // into general/trivial — which allowed every edit with missing: [].
+    if (categories.length === 0 && prompt.length === 0 && session.length > 0 && isValidSessionId(session)) {
+        let stateDb = null;
+        try {
+            stateDb = openDb(dbPathFor(root, spec));
+            const state = readSessionClassification(stateDb, session);
+            if (state) {
+                categories = state.categories;
+                prompt = state.prompt;
+            }
+        }
+        catch (error) {
+            process.stderr.write(`novahiz: session state read skipped: ${String(error).slice(0, 200)}\n`);
+        }
+        finally {
+            stateDb?.close();
+        }
+    }
     // Audit 2026-09-25 (P1-3): empty categories no longer fall through to an
     // unscoped evaluation — the CLI classifies the seed itself (same contract as
     // the MCP gate) and fails closed only when classification itself is broken.

package/dist/commands/inspect.js

@@ -8,6 +8,7 @@ import { buildMcpEntries, enabledProviders, installCommands, pendingInstallComma
 import { spawnSync } from "node:child_process";
 import { bootstrapFor, coreBootstrap, dependencyReport, missingPrerequisites, reloadPathFromRegistry, toolchainStatus } from "../deps.js";
 import { classify } from "../classify.js";
+import { isContinuation, isValidSessionId, readSessionClassification, writeSessionClassification } from "../session.js";
 import { runScript } from "../exec.js";
 import { activeTask, buildWorkPackets, getTask } from "../ledger.js";
 export function commandCheck() {
@@ -60,6 +61,38 @@ export function commandClassify(parsed) {
         minScore: numberFlag(parsed, "min-score", { min: 0 }),
         maxCategories: numberFlag(parsed, "max-categories", { min: 1, integer: true })
     });
+    const session = asString(parsed.flags.session);
+    if (!isValidSessionId(session)) {
+        print({ prompt: text, ...result });
+        return;
+    }
+    const db = openDb(dbPathFor(root, spec));
+    try {
+        const stored = readSessionClassification(db, session);
+        // A trivial follow-up ("continue", "ok") inherits the last non-trivial
+        // task of this session. Without this the plugin overwrote its categories
+        // with general/trivial and the gate allowed every edit (missing: []).
+        if (result.tier === "trivial" && stored && isContinuation(stored)) {
+            const continued = classify(spec, stored.prompt, {
+                minScore: numberFlag(parsed, "min-score", { min: 0 }),
+                maxCategories: numberFlag(parsed, "max-categories", { min: 1, integer: true })
+            });
+            print({ prompt: text, ...continued, continuedFrom: stored.prompt });
+            return;
+        }
+        if (result.tier !== "trivial") {
+            writeSessionClassification(db, {
+                session,
+                categories: result.categories.map((entry) => entry.id),
+                requiredSkills: result.enforcedSkills,
+                tier: result.tier,
+                prompt: text
+            });
+        }
+    }
+    finally {
+        db.close();
+    }
     print({ prompt: text, ...result });
 }
 export function commandSkills(parsed) {
@@ -142,9 +175,17 @@ export function commandSessionState(parsed) {
     }
     const db = openDb(dbPathFor(root, spec));
     const loaded = db.prepare("SELECT skill FROM skill_invocations WHERE session_id = ?").all(session).map((row) => row.skill);
-    const state = db.prepare("SELECT categories, required_skills FROM sessions WHERE id = ?").get(session);
+    const state = db.prepare("SELECT categories, required_skills, prompt, tier, updated_at FROM sessions WHERE id = ?").get(session);
     db.close();
-    print({ session, loaded, categories: state ? safeJsonArray(state.categories) : [], requiredSkills: state ? safeJsonArray(state.required_skills) : [] });
+    print({
+        session,
+        loaded,
+        categories: state ? safeJsonArray(state.categories) : [],
+        requiredSkills: state ? safeJsonArray(state.required_skills) : [],
+        prompt: state?.prompt ?? "",
+        tier: state?.tier ?? null,
+        updatedAt: state?.updated_at ?? null
+    });
 }
 export function commandCatalog(parsed) {
     const spec = loadSpec();