thachvd-kit 1.0.36 → 1.0.38

package/skills/subagent-driven-development/task-reviewer-prompt.md

@@ -0,0 +1,207 @@
+# Task Reviewer Prompt Template
+
+Use this template when dispatching a task reviewer subagent. The reviewer
+reads the task's diff once and returns two verdicts: spec compliance and
+code quality.
+
+**Purpose:** Verify one task's implementation matches its requirements (nothing
+more, nothing less) and is well-built (clean, tested, maintainable)
+
+```
+Subagent (general-purpose):
+  description: "Review Task N (spec + quality)"
+  model: [MODEL — REQUIRED: choose per SKILL.md Model Selection; an omitted
+         model silently inherits the session's most expensive one]
+  prompt: |
+    You are reviewing one task's implementation: first whether it matches its
+    requirements, then whether it is well-built. This is a task-scoped gate,
+    not a merge review — a broad whole-branch review happens separately after
+    all tasks are complete.
+
+    ## What Was Requested
+
+    Read the task brief: [BRIEF_FILE]
+
+    Global constraints from the spec/design that bind this task:
+    [GLOBAL_CONSTRAINTS]
+
+    ## What the Implementer Claims They Built
+
+    Read the implementer's report: [REPORT_FILE]
+
+    ## Diff Under Review
+
+    **Base:** [BASE_SHA]
+    **Head:** [HEAD_SHA]
+    **Diff file:** [DIFF_FILE]
+
+    Read the diff file once — it contains the commit list, a stat summary,
+    and the full diff with surrounding context, and it is your view of the
+    change. The diff's context lines ARE the changed files: do not Read a
+    changed file separately unless a hunk you must judge is cut off
+    mid-function — and say so in your report. Do not re-run git commands.
+    If the diff file is missing, fetch the diff yourself:
+    `git diff --stat [BASE_SHA]..[HEAD_SHA]` and `git diff [BASE_SHA]..[HEAD_SHA]`.
+    Do not crawl the broader codebase. Inspect code outside the diff only
+    to evaluate a concrete risk you can name — one focused check per named
+    risk, and name both the risk and what you checked in your report.
+    Cross-cutting changes are legitimate named risks: if the diff changes
+    lock ordering, a function or API contract, or shared mutable state,
+    checking the call sites is the right method.
+
+    Your review is read-only on this checkout. Do not mutate the working
+    tree, the index, HEAD, or branch state in any way.
+
+    ## You Do Not Dispatch Subagents
+
+    Do all of this review yourself. Never spawn a subagent to review part
+    of the diff, and never spawn another reviewer for a second opinion.
+    This process already provides every review seat the work gets; a
+    reviewer you spawn duplicates one of them at full cost, and its
+    verdict counts for nothing. If the diff feels too large for one
+    pass, review it in passes yourself and say so in your report.
+
+    ## Do Not Trust the Report
+
+    Treat the implementer's report as unverified claims about the code. It
+    may be incomplete, inaccurate, or optimistic. Verify the claims against
+    the diff. Design rationales in the report are claims too: "left it per
+    YAGNI," "kept it simple deliberately," or any other justification is the
+    implementer grading their own work. Judge the code on its merits — a
+    stated rationale never downgrades a finding's severity.
+
+    ## Tests
+
+    The implementer already ran the tests and reported results with TDD
+    evidence for exactly this code. Do not re-run the suite to confirm their
+    report. Run a test only when reading the code raises a specific doubt
+    that no existing run answers — and then a focused test, never a
+    package-wide suite, race detector run, or repeated/high-count loop. If
+    heavy validation seems warranted, recommend it in your report instead of
+    running it. If you cannot run commands in this environment, name the
+    test you would run.
+
+    Warnings or other noise in the implementer's reported test output are
+    findings — test output should be pristine.
+
+    Evidence you cannot see is not evidence that doesn't exist. If the
+    report or its test evidence looks truncated, or you cannot locate the
+    results it claims, re-read the file at its stated path — and if it is
+    genuinely missing or garbled, report that as a gap for the controller.
+    Re-running the suite to regenerate what you failed to read is not
+    verification; illegibility of the evidence is not invalidation of it.
+
+    ## Part 1: Spec Compliance
+
+    Compare the diff against What Was Requested:
+
+    - **Missing:** requirements they skipped, missed, or claimed without
+      implementing
+    - **Extra:** features that weren't requested, over-engineering, unneeded
+      "nice to haves"
+    - **Misunderstood:** right feature built the wrong way, wrong problem
+      solved
+
+    If the brief lists several files each with its own change (a batched
+    dispatch), check the diff against that list file by file: every listed
+    file must have its corresponding hunk. A listed file the diff never
+    touches is a Missing finding, no matter how clean the rest of the
+    batch looks.
+
+    If a requirement cannot be verified from this diff alone (it lives in
+    unchanged code or spans tasks), report it as a ⚠️ item instead of
+    broadening your search.
+
+    ## Part 2: Code Quality
+
+    **Code quality:**
+    - Clean separation of concerns?
+    - Proper error handling?
+    - DRY without premature abstraction?
+    - Edge cases handled?
+
+    **Tests:**
+    - Do the new and changed tests verify real behavior, not mocks?
+    - Are the task's edge cases covered?
+
+    **Structure:**
+    - Does each file have one clear responsibility with a well-defined interface?
+    - Are units decomposed so they can be understood and tested independently?
+    - Is the implementation following the file structure from the plan?
+    - Did this change create new files that are already large, or
+      significantly grow existing files? (Don't flag pre-existing file
+      sizes — focus on what this change contributed.)
+
+    Your report should point at evidence: file:line references for every
+    finding and for any check you would otherwise answer with a bare
+    "yes." A tight report that cites lines gives the controller everything
+    it needs.
+
+    Your final message is the report itself: begin directly with the
+    spec-compliance verdict. Every line is a verdict, a finding with
+    file:line, or a check you ran — no preamble, no process narration,
+    no closing summary.
+
+    ## Calibration
+
+    Categorize issues by actual severity. Not everything is Critical.
+    Important means this task cannot be trusted until it is fixed: incorrect
+    or fragile behavior, a missed requirement, or maintainability damage you
+    would block a merge over — verbatim duplication of a logic block,
+    swallowed errors, tests that assert nothing. "Coverage could be broader"
+    and polish suggestions are Minor.
+    If the plan or brief explicitly mandates something this rubric calls a
+    defect (a test that asserts nothing, verbatim duplication of a logic
+    block), that IS a finding — report it as Important, labeled
+    plan-mandated. The plan's authorship does not grade its own work; the
+    human decides.
+    Acknowledge what was done well before listing issues — accurate praise
+    helps the implementer trust the rest of the feedback.
+
+    ## Output Format
+
+    ### Spec Compliance
+
+    - ✅ Spec compliant | ❌ Issues found: [what's missing/extra/misunderstood,
+      with file:line references]
+    - ⚠️ Cannot verify from diff: [requirements you could not verify from the
+      diff alone, and what the controller should check — report alongside the
+      ✅/❌ verdict for everything you could verify]
+
+    ### Strengths
+    [What's well done? Be specific.]
+
+    ### Issues
+
+    #### Critical (Must Fix)
+    #### Important (Should Fix)
+    #### Minor (Nice to Have)
+
+    For each issue: file:line, what's wrong, why it matters, how to fix
+    (if not obvious).
+
+    ### Assessment
+
+    **Task quality:** [Approved | Needs fixes]
+
+    **Reasoning:** [1-2 sentence technical assessment]
+```
+
+**Placeholders:**
+- `[MODEL]` — REQUIRED: reviewer model per SKILL.md Model Selection
+- `[BRIEF_FILE]` — REQUIRED: the task brief file (`node scripts/task-brief.js PLAN N`
+  prints the path; same file the implementer worked from)
+- `[GLOBAL_CONSTRAINTS]` — the binding requirements copied verbatim from
+  the plan's Global Constraints section or the spec: exact values, formats,
+  and stated relationships between components (not process rules — those
+  are already in this template)
+- `[REPORT_FILE]` — REQUIRED: the file the implementer wrote its detailed
+  report to
+- `[BASE_SHA]` — commit before this task
+- `[HEAD_SHA]` — current commit
+- `[DIFF_FILE]` — REQUIRED: the path the controller wrote the review
+  package to (`node scripts/review-package.js PLAN_FILE BASE HEAD` prints the unique
+  path it wrote; the package never enters the controller's context)
+
+**Reviewer returns:** Spec Compliance verdict (✅/❌/⚠️), Strengths, Issues
+(Critical/Important/Minor), Task quality verdict

package/skills/system-discovery/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: system-discovery
+description: Build or refresh the AS-IS system map for a brownfield multi-repository workspace using Codebase Memory MCP as the primary structural source.
+---
+
+# System Discovery
+
+Use this skill only for documentation/discovery. Do not modify product code.
+
+## Preconditions
+
+- `.thachvd/system.json` exists.
+- Repositories in that manifest have been indexed with Codebase Memory MCP.
+- If the index is stale or missing, stop and tell the user to run `thachvd-kit spec index`.
+
+## Goal
+
+Create a reviewed AS-IS map of what the current system does before detailed reverse-engineered specs are generated.
+
+## Analysis profile
+
+Read `profile` from `.thachvd/system.json`.
+
+- `auto`: infer a practical profile for each repository from code/config evidence. A multi-repo system may mix backend, frontend, mobile, and infra repos. Record inferred profiles with evidence.
+- `backend`: emphasize routes/RPC, middleware, auth/policies, services/domain logic, persistence/migrations/transactions, cache, queues/events/jobs/schedulers, external clients, feature flags, retry/idempotency/concurrency and rollback/failure paths.
+- `frontend`: emphasize routes/navigation, page/component composition, state management, API/data clients, forms/validation, auth/session, feature flags, analytics, accessibility, loading/error/empty states, browser storage and build/runtime config.
+- `fullstack`: apply both backend and frontend emphasis and trace client/server boundaries, shared schemas/types, auth/session propagation, BFF/SSR/server actions, and end-to-end failures.
+- `mobile`: emphasize navigation, lifecycle/background work, local storage/cache, offline/sync, permissions, push, deep links, auth refresh, platform-specific code, device integrations and release config.
+- `infra`: emphasize IaC modules/stacks, environments/workspaces, CI/CD, secrets, IAM, networking, state backends, observability, capacity/autoscaling, deployment ordering, rollback/recovery and destructive-change safeguards.
+
+Profile guidance is a checklist, not a source of truth. Never omit real behavior merely because it falls outside the selected profile.
+
+## Documentation language
+
+Read `language` from `.thachvd/system.json`.
+
+- `vi`: write prose, headings, explanations, and summaries in natural Vietnamese.
+- `en`: write prose, headings, explanations, and summaries in English.
+- Always preserve code identifiers, class/function names, API routes, event/queue names, database/schema names, file paths, commands, and source anchors exactly as they appear in source.
+- When writing Vietnamese, retain the original English technical term in parentheses if translating it would reduce precision.
+
+The implementation and tests are the source of truth. Never invent business intent.
+
+## Read first
+
+1. `.thachvd/system.json`
+2. Existing files under the configured `spec_root`
+3. Relevant `AGENTS.md` / `.agent/docs/*` files when present
+
+## Discovery method
+
+Use Codebase Memory MCP first for structural questions: repository inventory, symbols, entry points, callers/callees, data flow, cross-service links, routes, jobs, events, schedulers, queues, clients, and shared persistence. Use direct file reads only to verify or fill gaps.
+
+Inspect all configured repositories. Pay special attention to framework side paths that are often missed by direct call graphs: middleware, observers/hooks, event listeners, background jobs, schedulers, policies/guards, migrations, CLI commands, configuration, and tests.
+
+Do not document dead code as active behavior unless evidence shows it is reachable or intentionally retained.
+
+## Outputs
+
+Write or update these files under `spec_root`:
+
+- `architecture/system-overview.md`
+- `architecture/repo-map.md`
+- `architecture/capability-map.md`
+- `architecture/integrations.md`
+- `glossary.md`
+
+### system-overview.md
+
+Describe:
+- system purpose as observable from code
+- major actors/interfaces
+- major runtime/deployment components
+- major data stores
+- major external systems
+- top-level business capabilities
+- uncertainty / missing evidence
+
+### repo-map.md
+
+For every repository:
+- responsibility
+- primary entry points
+- owned data or services
+- inbound dependencies
+- outbound dependencies
+- events/queues/jobs
+- important source anchors
+
+### capability-map.md
+
+Group by business capability, not repository boundary.
+
+For every capability:
+- short observable purpose
+- participating repositories
+- primary entry points
+- important data/entities
+- integrations/events
+- candidate scope for later reverse engineering
+
+Add a matrix showing capability × repository participation.
+
+### integrations.md
+
+Document cross-repository and external contracts:
+- HTTP/RPC
+- events/messages/queues
+- scheduled/batch interactions
+- shared database/storage access
+- third-party systems
+
+Include direction, producer/caller, consumer/callee, contract location, and evidence.
+
+### glossary.md
+
+Capture domain terms found in code/tests/docs. Mark ambiguous terms instead of guessing.
+
+## Evidence rules
+
+For every important claim, include the strongest available source anchor: repository + file + symbol/function/class; add line ranges when available.
+
+Classify uncertain statements as one of:
+- Confirmed by implementation
+- Confirmed by tests
+- Inferred
+- Unknown / owner confirmation required
+
+Never turn an inference into a requirement or business rationale.
+
+## Human review gate
+
+End by summarizing:
+- proposed capability boundaries
+- ambiguous ownership
+- suspicious cross-repo coupling
+- missing/uncertain business terminology
+- areas that should be split/merged before detailed specs
+
+Do not proceed to detailed PRD/Design reverse engineering until the user/team approves the capability map.

package/skills/system-reverse-engineer/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: system-reverse-engineer
+description: Reverse-engineer an approved brownfield system map into durable AS-IS PRD, design, flow, and contract specifications across one or many repositories.
+---
+
+# System Reverse Engineer
+
+Use this skill after `/system-discovery` has produced a human-reviewed capability map.
+
+This is a documentation workflow. Do not modify product code.
+
+## Goal
+
+Turn the current implementation of the whole system into a durable AS-IS specification set that helps members understand the system and gives future coding agents reliable context.
+
+One invocation should cover the whole approved system. Work capability-by-capability internally so each area can be verified and checkpointed. A named capability in the handoff is only a targeted refresh.
+
+## Analysis profile
+
+Read `profile` from `.thachvd/system.json` and apply the same profile-specific emphasis defined by `/system-discovery`. In `auto` mode, use the repo profiles inferred during discovery. Re-check the evidence if the implementation has changed.
+
+Profile guidance must never suppress behavior outside the selected profile. Source code/tests remain authoritative.
+
+## Documentation language
+
+Read `language` from `.thachvd/system.json`.
+
+- `vi`: write prose, headings, explanations, summaries, PRDs, design docs, flows, and contract explanations in natural Vietnamese.
+- `en`: write those documents in English.
+- Always preserve code identifiers, class/function names, API routes, event/queue names, database/schema names, file paths, commands, and source anchors exactly as they appear in source.
+- When writing Vietnamese, retain the original English technical term in parentheses if translating it would reduce precision.
+
+## Preconditions
+
+Read:
+
+1. `.thachvd/system.json`
+2. the configured `spec_root/architecture/system-overview.md`
+3. `spec_root/architecture/repo-map.md`
+4. `spec_root/architecture/capability-map.md`
+5. `spec_root/architecture/integrations.md`
+6. `spec_root/glossary.md`
+7. `spec_root/_meta/reverse-progress.json`
+
+The capability map must have been reviewed by a human. If it is obviously still draft or ambiguous, stop rather than manufacturing detailed specs.
+
+## Durable checkpoint and resume
+
+`thachvd-kit spec reverse` creates a durable checkpoint. Full-system runs use `spec_root/_meta/reverse-progress.json`; targeted refreshes use `spec_root/_meta/reverse-progress-<capability>.json`. Use the exact checkpoint path declared by the handoff prompt.
+
+Expected shape:
+
+```json
+{
+  "schema_version": 1,
+  "system": "example",
+  "mode": "full",
+  "target": null,
+  "started_at": "<ISO-8601>",
+  "updated_at": "<ISO-8601>",
+  "status": "in_progress",
+  "capabilities": {
+    "booking": {
+      "title": "Booking",
+      "status": "pending",
+      "updated_at": "<ISO-8601>",
+      "source_paths": {}
+    }
+  }
+}
+```
+
+Rules:
+
+1. If `capabilities` is empty, derive the approved capability list from `capability-map.md` and populate it before deep work.
+2. In targeted mode, include/work only the requested capability.
+3. Before working on a capability, set it to `in_progress` and persist the file.
+4. After both PRD/design exist and the capability-level quality checks below pass, set it to `completed`, save its relevant `source_paths` by repo, and persist.
+5. If blocked, set `blocked` with a concise reason and continue with other capabilities when possible.
+6. On a later invocation, resume `pending`, `in_progress`, or retryable `blocked` capabilities. Do not redo `completed` capabilities unless the handoff is a targeted refresh or the user explicitly reset progress.
+7. Mark top-level `status` `completed` only when every intended capability is completed or explicitly blocked.
+8. Update `updated_at` after every state change.
+9. A targeted refresh must never overwrite the full-system checkpoint.
+
+Do not keep progress only in chat memory.
+
+## Sources of truth
+
+Use, in order of evidentiary strength:
+
+- production implementation
+- tests
+- configuration
+- schemas/migrations
+- existing reviewed system docs
+
+Use Codebase Memory MCP as the primary source for structural discovery, cross-repository tracing, callers/callees, routes, jobs, events, queues, schedulers, and data flow. Read source files directly to verify important behavior and fill gaps.
+
+Do not infer undocumented business rationale from implementation.
+
+## Processing model
+
+For each approved capability:
+
+1. Identify every participating repository and coherent implementation scope.
+2. Trace entry points through services, persistence, async work, integrations, and outputs.
+3. Inspect tests that lock down observable behavior.
+4. Explicitly inspect framework side paths that call graphs may miss: middleware, policies/guards, observers/hooks, event listeners, jobs, schedulers, migrations, CLI commands, config and feature flags.
+5. Extract current requirements, invariants, error/failure behavior, state transitions, retries/idempotency, and contracts.
+6. Verify important claims against code/tests.
+7. Write the capability PRD and design doc using the fixed templates below.
+8. Record uncertainty explicitly.
+9. Save stable repository-relative source paths into the progress entry for later drift checking.
+10. Continue to the next incomplete capability.
+
+If Shinpr's `/recipe-reverse-engineer` workflow is installed, it may be used as a high-assurance helper for coherent implementation scopes. It is optional.
+
+## Fixed PRD template
+
+Every `spec_root/capabilities/<capability>/prd.md` must contain these sections in this order:
+
+1. **Purpose**
+2. **Actors**
+3. **Current Behaviors / Use Cases**
+4. **Requirements**
+5. **Business Rules and Invariants**
+6. **Error and Edge Cases**
+7. **Current Limitations**
+8. **Unknown Business Rationale / Owner Confirmation**
+9. **Evidence Summary**
+
+Requirements describe what the current system demonstrably does, not what it should ideally do.
+
+## Fixed design template
+
+Every `spec_root/capabilities/<capability>/design.md` must contain these sections in this order:
+
+1. **Participating Repositories**
+2. **Entry Points**
+3. **Components / Modules**
+4. **End-to-End Execution Flow**
+5. **Data Model and Ownership**
+6. **Persistence**
+7. **State Transitions**
+8. **Events / Queues / Jobs / Schedulers**
+9. **External Integrations**
+10. **Configuration / Feature Flags**
+11. **Failure / Retry / Rollback / Idempotency**
+12. **Tests**
+13. **Source Map**
+14. **Known Ambiguities**
+
+Do not omit a section silently. Use "None observed" or "Unknown / requires confirmation" when evidence does not establish content.
+
+## System-level outputs
+
+Update only when real evidence warrants them:
+
+- `spec_root/flows/*.md` for important end-to-end or cross-repository flows
+- `spec_root/contracts/*.md` for HTTP/RPC, events/messages, queues, shared storage, or other cross-boundary contracts
+
+For cross-repository contracts, verify both producer/caller and consumer/callee when both codebases are available.
+
+Do not create files merely to fill directories.
+
+## Evidence and uncertainty
+
+Attach repository + file + symbol/function/class anchors to important behavior. Add line ranges when reliably available.
+
+Distinguish:
+
+- Confirmed by implementation
+- Confirmed by tests
+- Inferred
+- Unknown / owner confirmation required
+
+Never promote an inference to a requirement without evidence.
+
+## Capability quality gate
+
+Before marking one capability `completed` in progress:
+
+- PRD and design templates are complete
+- PRD and design agree
+- primary entry points were traced
+- relevant tests were inspected
+- async/framework side paths were considered
+- important failure/state-transition behavior is represented
+- material cross-repo contracts are represented
+- major claims have source anchors
+- relevant `source_paths` were recorded in progress
+- no undocumented business rationale was invented
+- dead/unreachable code is not presented as active without evidence
+
+This is an author-side gate only. A later independent `/system-spec-review` decides whether the result is actually verified.
+
+## Final output
+
+Return a concise coverage summary:
+
+- capabilities completed
+- capabilities blocked
+- unresolved ambiguities
+- specs needing owner review
+- cross-repository flows/contracts produced
+- current checkpoint status
+
+Do not claim the specs are independently verified. That happens only after `thachvd-kit spec verify` + `/system-spec-review`.