novahiz 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE.md

@@ -0,0 +1,46 @@
+# Notices
+
+Novahiz is licensed under Apache-2.0. See [LICENSE](LICENSE).
+
+## Bundled skills
+
+The `skills/` directory ships a curated set of agent skills so the system works right after installation. Each skill is its own folder, and that folder's license governs it when one is recorded, in this order:
+
+1. A `LICENSE`, `LICENSE.txt`, or `NOTICE` file inside the folder.
+2. A `license:` field in the skill's frontmatter.
+3. Otherwise the skill belongs to Novahiz and ships under Apache-2.0.
+
+The `novahiz-*` pipeline skills, plus the `gate` and `memory` aliases, are Novahiz's own and always Apache-2.0.
+
+### Third-party skills with a recorded upstream
+
+| Skill | Upstream | License |
+|---|---|---|
+| `skill-creator` | Anthropic | see `skills/skill-creator/LICENSE.txt` |
+| `humanizer` | pattern catalogue from Wikipedia's "Signs of AI writing" (WikiProject AI Cleanup), attributed in the skill body | MIT as declared in its frontmatter; the source page is CC BY-SA 4.0 |
+| `security-guidance` | ported by Alireza Rezvani from David Dworken's implementation | MIT |
+| `supabase-postgres-best-practices` | Supabase | MIT, declared in its frontmatter |
+| `supabase` | Supabase | not recorded |
+| `write-a-skill` | Matt Pocock (`mattpocock/skills`) | not recorded |
+| `clean-code` | `jackjin1997/ClawForge` | not recorded |
+| `zero-hallucination-coder` | draws on Ralph (`@snarktank`) and GSD Core (`@open-gsd`) | not recorded |
+| `adversarial-reviewer` | ekreloff | not recorded |
+| `apple-hig-expert` | Alireza Rezvani | not recorded |
+| `design-taste-frontend` | Leonxlnx | not recorded |
+| `typescript-expert`, `postgresql-optimization` | community contributions, authors not recorded | not recorded |
+
+### Third-party skills with no recorded upstream
+
+These folders carry no license file, no `license:` field, and no author. Their upstream and license could not be verified from the bundle:
+
+`a11y-audit`, `ai-security`, `anti-AI-design`, `anti-pattern-detector`, `api-design-reviewer`, `code-reviewer`, `code-understand`, `database-designer`, `defuddle`, `dependency-auditor`, `engineering-standards`, `env-secrets-manager`, `fix`, `mcp-server-builder`, `migrate`, `review-changes`, `senior-architect`, `senior-backend`, `senior-secops`, `spec-driven-workflow`, `ui-design-system`.
+
+They are redistributed as they were found, and this project asserts no license over them. Each one is a candidate for either recording its license or removing it from the bundle. If you hold the rights and want a different attribution or a removal, open an issue on the repository.
+
+## Providers
+
+Providers are referenced by install command, never vendored. Each lists its upstream license in `catalog/providers.json`. `impeccable` is installed by its provider and is not bundled.
+
+## Dependencies
+
+The core and the MCP server use Node.js built-ins only. The opencode adapter imports only Node.js built-ins and the `@opencode-ai/plugin` types, which the harness provides.

package/README.md

@@ -0,0 +1,123 @@
+# Novahiz
+
+[![ci](https://github.com/novahiz/novahiz/actions/workflows/ci.yml/badge.svg)](https://github.com/novahiz/novahiz/actions/workflows/ci.yml)
+[![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![node](https://img.shields.io/badge/node-%3E%3D22.18-brightgreen.svg)](https://nodejs.org)
+
+A deterministic layer for AI coding harnesses. It catalogs your skills, classifies a prompt into categories, attaches an execution roadmap, and blocks file edits until the required skills are loaded.
+
+The decisions run in code. The same prompt and the same rule set always produce the same result. No model vote, no random sampling, no hidden state.
+
+## What it does
+
+- **Catalog** scans `SKILL.md` files, reads their frontmatter, stores them in SQLite with a curated score, and ranks them by deterministic lexical relevance.
+- **Classifier** maps a prompt to categories (code, debug, review, audit, research, browser, design, Supabase, and more) with weighted keyword rules. It returns the primary category, the required skills, and the execution roadmaps.
+- **Gate** inspects `edit`, `write`, `patch`, `apply_patch`, and shell writes. It is content-aware, so `humanizer` is required only for prose changes and `impeccable` only for style changes. The primary roadmap `skill` steps are enforced. When a required skill is not loaded, the call is blocked with an explanation.
+- **Roadmaps** attach an ordered task list to each category. The primary category drives the roadmap the agent follows.
+- **Enforcer** injects the detected categories, the roadmap checklist, and the expected skills into the system prompt.
+- **Ledger** keeps a long task in SQLite: atomic todos with an acceptance criterion and a proof, a per-todo iteration budget, work packets with exclusive file ownership, and a living plan the gate forces you to revise every few edits. The current plan is injected into the system prompt each turn, so it survives context compaction.
+
+## Pipeline
+
+Non-trivial work follows six stages, in order, each with its own skill:
+
+| # | Stage | Skill | Produces |
+|---|-------|-------|----------|
+| 1 | Plan | `novahiz-plan` | direction, boundaries, dependency order, slicing strategy, risks |
+| 2 | Clarify | `novahiz-clarify` | ambiguity families, question rounds, settled decisions |
+| 3 | Tasks | `novahiz-task` | atomic tasks with acceptance criteria and a proof |
+| 4 | Analyse | `novahiz-analyse` | the files, symbols, and unknowns that matter for the task |
+| 5 | Implement | `novahiz-implement` | increments that keep the system working |
+| 6 | Converge | `novahiz-converge` | the gap between intent and code, closed or left explicit |
+
+`novahiz-planner` orchestrates them and carries the entry rule: no non-trivial edit before a written plan. Stages 1 to 4 write nothing to the application.
+
+The clarification and planning stages ask their questions through the harness question interface, so the agent presents choices and waits for an answer instead of listing questions in prose.
+
+## Status
+
+Phase 1. The core (catalog, classifier, gate, CLI), the bundled skills, the installer, the MCP server, and the opencode adapter work and are covered by tests. Other harness adapters are next. The public interface may change before 1.0.
+
+The package exposes no programmatic import surface. It ships a CLI and an MCP server, so `package.json` declares no `main` and no `exports`.
+
+## Requirements
+
+- Node.js 22.18 or later. Node runs the TypeScript sources directly through type stripping.
+- No runtime dependencies. SQLite comes from `node:sqlite`.
+- `defuddle`, for the web extraction in the `research` roadmap step. `novahiz doctor` reports whether it is present.
+
+## Install
+
+Clone into the Novahiz home and run the installer:
+
+```
+git clone https://github.com/novahiz/novahiz ~/.config/novahiz
+node ~/.config/novahiz/install/install.mjs
+```
+
+The installer copies the bundled skills, drops the opencode plugin, writes `novahiz.config.json` if missing, and builds the catalog. It never deletes your files. Restart opencode afterward. The plugin registers the MCP server on its own.
+
+Full options and the uninstall steps are in [docs/INSTALL.md](docs/INSTALL.md).
+
+## Configuration
+
+Generic behavior lives in `catalog/` and is versioned:
+
+- `catalog/categories.json` defines each category, its keywords, the skills it requires, and its execution roadmap.
+- `catalog/rules.json` defines the pre-edit rules (file classes, path globs, prompt categories, content matches, required skills).
+- `catalog/overrides.json` holds manual curation for skills (power, stars, tags, categories).
+
+Machine-specific settings live in `novahiz.config.json`, which is gitignored: the database path, the skill roots, and gate behavior. Copy the example file to create it.
+
+## CLI
+
+```
+node src/cli.ts sync
+node src/cli.ts check
+node src/cli.ts classify "ajoute une migration supabase avec une policy rls"
+node src/cli.ts gate --file src/hero.css --tool edit
+node src/cli.ts gate --file src/hero.css --tool edit --loaded humanizer,impeccable
+node src/cli.ts skills --category design-ui
+node src/cli.ts catalog "design frontend landing" --limit 5
+node src/cli.ts roadmap --category code
+node src/cli.ts step --session my-session --done plan
+node src/cli.ts report --format markdown
+node src/cli.ts task new --title "Add the CSV export"
+node src/cli.ts task plan --task <id> --json '[{"label":"read the parser","kind":"read"},{"label":"write the exporter","kind":"edit","acceptance":"csv round-trips","owner":"src/export.ts"}]'
+node src/cli.ts task start --id <todo>
+node src/cli.ts task done --id <todo> --proof "node --test tests/export.test.ts -> 4 pass"
+node src/cli.ts task status --session <id>
+node src/cli.ts dispatch --task <id>
+node src/cli.ts tokens --calibrate --format text
+node src/cli.ts clean --days 30 --dry-run
+node src/cli.ts clean --days 30 --apply --vacuum
+node src/cli.ts doctor
+```
+
+`gate` prints a JSON verdict and exits `0` when the edit is allowed, `2` when it is blocked. Adapters rely on that exit code.
+
+Output follows the terminal by default, and `--pretty` or `--json` forces a mode. `clean` prunes old enforcement logs, roadmap progress, sessions, and closed tasks; without `--apply` it shows the plan and, on an interactive terminal, asks for confirmation. `doctor` runs the preflight checks and exits non-zero on a blocking finding.
+
+Run `node src/cli.ts` with no arguments for the full command list, including `categories`, `rules`, `session-load`, `session-state`, `hook`, `providers`, `deps`, and every `task` subcommand.
+
+The adapter also trims tool output and deduplicates stale reads to keep long sessions cheap.
+
+## opencode adapter
+
+Copy `adapters/opencode/novahiz.ts` into `~/.config/opencode/plugins/`, or run the installer, which copies it. It loads automatically at startup. The adapter classifies each user message, injects the roadmap checklist and expected skills, tracks loaded skills, and calls the CLI gate on `edit`, `write`, `patch`, `apply_patch`, `bash`, and `shell`.
+
+The installer also drops four slash commands into the opencode command directory: `/novahiz-plan`, `/novahiz-clean`, `/novahiz-doctor`, and `/novahiz-status`. `/novahiz-plan` runs the pipeline read-only and produces the plan without writing a file.
+
+Set `NOVAHIZ_GATE=off` to disable gating for a session. Set `NOVAHIZ_HOME` when the repo is not at `~/.config/novahiz`. Set `NOVAHIZ_DB` to override the database path, which keeps tests and scratch runs off your real ledger.
+
+## Execution ledger
+
+For work that spans more than a few steps, `novahiz task` keeps the plan in SQLite instead of in the conversation. A todo carries its own acceptance criterion, an iteration budget, and, for a `verify` step, a proof that must be present before it can close. `novahiz dispatch` turns the open todos into work packets with exclusive file ownership, so parallel sub-agents do not edit the same file. The gate forces a review every three edits or two finished todos, and the enriched summary is injected on every turn. See [docs/EXECUTION.md](docs/EXECUTION.md).
+
+## Harnesses
+
+The adapter is thin on purpose: the gate logic lives in the CLI. opencode is the supported harness, through the plugin in `adapters/opencode/`. Any harness with a stdio MCP client can use `novahiz_classify`, `novahiz_catalog`, `novahiz_roadmap`, `novahiz_providers`, `novahiz_deps`, `novahiz_step`, `novahiz_list_skills`, `novahiz_gate`, `novahiz_task`, and `novahiz_dispatch`, but the gate only blocks inside opencode. Novahiz also catalogues external components as providers: MCP servers (playwright, security, narsil, context7, sequential-thinking, cron), and skill packs (impeccable), and can run their official install commands. See [docs/HARNESSES.md](docs/HARNESSES.md), [adapters/README.md](adapters/README.md), and [docs/PROVIDERS.md](docs/PROVIDERS.md).
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).

package/adapters/README.md

@@ -0,0 +1,13 @@
+# Adapters
+
+Novahiz keeps every decision in the CLI. An adapter only translates a harness event into a `novahiz` call.
+
+## opencode
+
+`adapters/opencode/novahiz.ts` is a plugin. It classifies each user message, injects the roadmap checklist and expected skills, tracks loaded skills per session, and calls `novahiz gate` on `edit`, `write`, `patch`, `apply_patch`, `bash`, and `shell`. The gate is content-aware, so `humanizer` and `impeccable` are required only when the change contains prose or style. It registers the MCP server through the plugin `config` hook, and persists every skill launch with `novahiz session-load`.
+
+`adapters/opencode/agent/novahiz-agent.md` is the primary agent. It carries `permission: { question: allow, plan_enter: allow }`, because opencode denies `question` to every agent by default and only its built-in `build` and `plan` agents re-allow it.
+
+## Other clients
+
+Any harness with a stdio MCP client can use `mcp/novahiz-tools/index.mjs` for `classify`, `catalog`, `roadmap`, `step`, `list_skills`, and `gate`. Register it with that client's own MCP command; Novahiz writes no other harness's configuration. There is no gate outside opencode, so those clients get the catalog and the ledger without enforcement.

package/adapters/opencode/agent/novahiz-agent.md

@@ -0,0 +1,31 @@
+---
+description: Novahiz primary agent. Classifies the request, loads the required skills, then works under the Novahiz gate.
+mode: primary
+temperature: 0.2
+# 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.
+permission:
+  question: allow
+  plan_enter: allow
+---
+
+You are Novahiz-Agent, the primary agent for the Novahiz deterministic workflow. You run inside opencode with the Novahiz plugin and MCP server active.
+
+Work in this order for every request:
+
+1. Classify. Call the `novahiz_classify` MCP tool with the user request, or run `node <novahiz-home>/src/cli.ts classify "<request>"`. Read the returned categories and required skills.
+2. Load skills. Load every required skill with `skill({ name: "<skill>" })` before touching any file. The gate enforces this: `edit`, `write`, `patch`, `apply_patch`, and shell writes are blocked until the required skills are loaded.
+3. Plan. For anything beyond a trivial change, write a short todo list with acceptance criteria.
+4. Execute. Make the change. Prefer small, reversible edits. Keep architecture modular, scalable, and maintainable.
+5. Verify. Run the relevant tests or commands. Report what you ran and what it returned. Never claim a result you did not observe.
+6. Report. At the end, state what changed, what is proven, what is uncertain, and the honest next step.
+
+Rules:
+
+- Humanizer is required for any text meant for a reader; never for raw navigation or research.
+- impeccable is required for any design or interface change.
+- Load the Supabase skills for any Supabase work.
+- Be honest. Avoid false good ideas. Keep a critical stance. Zero simulation: never pretend to have run, tested, or verified something you did not.
+- Criticize the request when it is inconsistent, ambiguous, risky, or suboptimal, and propose an alternative.
+- If the gate blocks you, load the missing skills it names, then retry. Do not try to route around the gate with a shell write.

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

@@ -0,0 +1,15 @@
+---
+description: Clean up old Novahiz database data. Arguments: $ARGUMENTS
+---
+
+1. Locate the Novahiz home: `NOVAHIZ_HOME` if set, otherwise `~/.config/novahiz`. The CLI is `<home>/src/cli.ts`.
+
+2. Default to `--dry-run` if no arguments are provided.
+
+3. Present a table: target, age, rows per table, total to remove.
+
+4. Ask the user for explicit confirmation before proceeding.
+
+5. If confirmed, re-run the same command with `--apply` instead of `--dry-run`, then report the rows actually removed and the size before and after.
+
+Targets: `logs` (default), `roadmap`, `sessions`, `tasks`, `all`. Flags: `--days N` (default 30), `--vacuum`, `--target <target>`.

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

@@ -0,0 +1,9 @@
+---
+description: Run Novahiz diagnostics. Arguments: $ARGUMENTS
+---
+
+1. Locate the Novahiz home: `NOVAHIZ_HOME` if set, otherwise `~/.config/novahiz`. The CLI is `<home>/src/cli.ts`.
+
+2. Run `node src/cli.ts doctor` from the Novahiz home.
+
+3. For each failing check, provide the exact fix to run based on the returned details. For example `npm install -g defuddle` when an external CLI is missing, or `node src/cli.ts sync` when the index is stale.

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

@@ -0,0 +1,24 @@
+---
+description: Launch Novahiz planning mode (read-only). Arguments: $ARGUMENTS
+---
+
+You are in read-only mode. No file writes, no state-changing commands, no commits. The harness already refuses edits in this agent; do not attempt to bypass it.
+
+1. Classify the request using `novahiz_classify`. Read the categories and required skills.
+
+2. Load the required skills using the `skill` tool, even if the harness refuses. The plan does not depend on their loading.
+
+3. Produce a plan with these sections:
+
+   - Direction: what "done" means, scope, chosen approach, rejected options and why.
+   - Clarification: ambiguous families. Ask questions using the `question` tool, one batch at a time, two to five mutually exclusive options per question, with the recommended option first. No prose questions in chat.
+   - Tasks: for each, objective, testable acceptance criteria, proof, dependencies, files involved, size XS to XL.
+   - Analysis: files and symbols that carry the logic, data paths, and remaining unknowns.
+
+4. Trace the plan in the ledger with `novahiz_task`: `action: "new"` to create the task, then `action: "plan"` to deposit the steps. Do not open any step.
+
+5. Present the summary, then stop.
+
+Forbidden in this pass: modify a file, run a state-changing command, commit, claim as done what was not executed.
+
+End with the honest next step: re-run the same request without the `/novahiz-plan` prefix to execute the plan.

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

@@ -0,0 +1,11 @@
+---
+description: Report Novahiz status. Arguments: $ARGUMENTS
+---
+
+1. Locate the Novahiz home: `NOVAHIZ_HOME` if set, otherwise `~/.config/novahiz`. The CLI is `<home>/src/cli.ts`.
+
+2. Run `node src/cli.ts doctor` from the Novahiz home. If it fails, report the error and stop.
+
+3. Measure the size of `novahiz.sqlite` and the last write date of `build/installed-skills.json`.
+
+4. Present a short summary: blocking anomalies first, then key numbers (journal rows, invocations, database size, indexed skills).

package/adapters/opencode/instructions.md

@@ -0,0 +1,69 @@
+# System Instructions
+
+## Obsidian Memory
+
+Obsidian (`C:\Users\hiz\Documents\novahiz`) is the user's second memory.
+
+### Rules
+1. When the user asks to **save / memorize / update obsidian memory**, load the `memory-save` skill and follow its procedure without exception.
+2. Determine the target folder **only** from the `novahiz\_meta\routing.md` table (source of truth). Never guess. When ambiguous, ask the user.
+3. Display the chosen path before writing.
+4. Never write to `index.md`, `log.md`, `hot.md`, `.manifest.json`, `_meta/`, or `.obsidian/` **except through a dedicated maintenance skill** (wiki-ingest/wiki-lint/wiki-status for index/log/hot/manifest; graph-colorize for `.obsidian/graph.json`, with mandatory backup). The `memory-save` skill writes only to the targeted content page.
+5. Never create a root folder on your own. Every new category requires user agreement and an update to `routing.md`.
+6. Include mandatory frontmatter: `title, category, tags, sources, created, updated, summary`. Use tags from `_meta/taxonomy.md`.
+7. Link pages with `[[wikilinks]]`. Merge rather than duplicate.
+
+## Playwright Browser — Persistent Profile
+
+Playwright uses a **persistent profile** that preserves data across sessions (cookies, localStorage, sessionStorage, history, logged-in sessions).
+
+**Profile folder:** `C:\Users\hiz\.opencode\playwright-profile`
+
+### Rules
+1. **NEVER use Chrome or Chromium** — Use only Microsoft Edge via the Playwright MCP server (`--browser=msedge`). Never launch `chrome.exe`, `chromium`, or any Chromium-based process manually or programmatically. All browser automation goes through the MCP tools (`playwright_browser_*`). If Edge is not installed, fall back to another non-Chromium browser (Firefox, WebKit) via the Playwright MCP server.
+2. Never disable `--user-data-dir` in the Playwright MCP config. The profile must always point to `C:/Users/hiz/.opencode/playwright-profile`.
+3. Never purge this folder without explicit user consent.
+4. Never launch Playwright with an ephemeral context (without user-data-dir) for tasks requiring persistence.
+5. If the profile is corrupted or causes issues, inform the user and propose a backup before any reset.
+
+## Behavioral & Quality Rules
+
+1. **Mandatory humanizer on text and code** — On every code or text modification, load the `humanizer` skill and apply its rules (remove AI writing tics: not-X-but-Y contrasts, forced triads, excessive dashes, empty phrases, marketing jargon). **Exception:** `humanizer` applies only to frontend text (titles, paragraphs, interface copy) or AI pattern audits — never to browser navigation/research tasks. Browser tasks (navigation, search, extraction) proceed as direct actions without a roadmap.
+2. **Mandatory impeccable on design** — On every design modification (UI, page, component, style, layout, motion, interface copy), load the `impeccable` skill and follow its workflow (setup then the appropriate command: `polish`, `audit`, `critique`, `animate`, etc.).
+3. **Impeccable / /impeccable live — NEVER use sub-agents** — The `impeccable` skill, the `/impeccable live` command, and any use of impeccable skills must **never** start in sub-agent mode, **ever**, even if the task seems suitable (distributed analysis, multiple variants, multi-surface audit). **Single exception:** only when the user explicitly requests launching a sub-agent ("launch a sub-agent", "use a sub-agent", etc.). The main agent always retains the interactive session and browser context.
+4. **Supabase** — On any Supabase task (database, auth, RLS, Edge Functions, migrations, Storage, Realtime, CLI/MCP), load the `supabase` and `supabase-postgres-best-practices` skills before acting.
+5. **Honesty and critical thinking** — Always be honest. Avoid false good ideas. Maintain critical thinking. **Zero simulation objective:** never claim to have executed, tested, or verified what was not. Explicitly report uncertainties and assumptions.
+6. **Propose next steps** — After completing a task, always honestly propose the relevant next step. Do not invent unnecessary work or mask failures.
+7. **Challenge the request** — Take the initiative to question the user's request when it is inconsistent, ambiguous, risky, or suboptimal. Explain why and propose an alternative.
+8. **Architecture quality** — Always adopt a modular, scalable, and maintainable approach. Never sacrifice quality for speed.
+9. **Todo list in real time** — Keep the todo list updated throughout the task: move a step to `in_progress` before starting it, mark it `completed` once verified, and add steps discovered along the way. No frozen lists or batch completion at the end.
+
+## Design Rules — Impeccable
+
+### Workflow per operation type
+
+| Operation | Mandatory command | When |
+|-----------|------------------|------|
+| **Create** a design | `/impeccable shape` | At the start, to establish the initial shape |
+| **Fix / Repair** a design | `impeccable audit` + `/impeccable critique` | Before and after the fix |
+| **Improve** a design | `/impeccable polish` | To refine and elevate |
+| **Verify** after a major task | `/impeccable critique` (+ `impeccable audit` if needed) | At the end of any significant design task |
+
+### Absolute rule — AI patterns
+
+When an **AI writing pattern** is detected (in text, code, or design), fix it **immediately** before continuing the current task. Detectable patterns:
+- Not-X-but-Y contrasts
+- Forced triads (3 systematic items)
+- Excessive dashes (—)
+- Empty phrases / marketing jargon
+- Excessive vocabulary / superlatives
+- Too "clean" / soulless formatting
+
+## Todo — Detailed Rules
+
+1. **One active step only** — `in_progress` on exactly one step at a time.
+2. **Real-time updates** — Update the list as soon as a step changes state. Do not wait for the task to finish.
+3. **No premature completion** — Mark `completed` only after the work is done and verified. Never based on intention.
+4. **New tasks integrated** — Any step discovered during execution is added to the list at the moment it appears.
+5. **Blocked visibility** — If a step is blocked, keep it `in_progress` and add a follow-up step describing the blockage.
+6. **Preserve vocabulary** — Reuse commands provided by the user exactly as given (flags, arguments, order).