governance: add planning/architecture rule (plan ahead, module map, avoid refactors); propagate to system prompts, AGENTS templates, proposal, and plan

collab/plan/01-codexhelper.llm.md

@@ -17,6 +17,8 @@
   - One-way workflow; minimal chat; read `.llm.md`, write both.
   - Governance/propagation: update prompts/global and seed/project AGENTS when norms change.
   - Safety: `--force` for overwrite; never `git push`; runs under `<project>/runs/<ts>/`.
+  - Zero Technical Debt: production-ready always; no deferring docs/tests/refactors.
+  - Planning/Architecture: plan ahead; maintain architecture/module map; implement module-by-module; avoid refactors unless plans/docs updated due to new info.
 
 - Deliverables:
   - `CodexHelper` bash script
@@ -25,6 +27,7 @@
   - `templates/project/<ModeName>/...` (optional mode-specific add-ons; start minimal)
   - `docs/wrapper.md` and README updates
   - Test harness (`bats`), `tests/` with coverage of all CLI paths
+  - `docs/architecture.md` and ADRs for key decisions
 
 - Implementation details:
   - Guard where running: inside repo → only `new-mode` allowed.
@@ -41,6 +44,8 @@
   - Precedence: CLI > env > project > mode > global.
   - `prompts/global/` used in composition.
   - Tests: all features covered by unit/integration tests (bats); TDD observed (tests committed alongside implementation); CI/local test script present.
+  - Zero Debt: docs updated; no pending TODOs/deferrals; production-ready criteria met.
+  - Planning/Architecture: architecture/module map exists and matches implemented modules; no unplanned refactors.
 
 - Open choices (defaulting now):
   - Include empty `prompts/style.md`: Yes.
@@ -59,4 +64,4 @@
    - H6–7: run: compose + invoke (tests first)
   - H7–8: config precedence (tests first) + minimal docs
  
- - Defer if needed: expand docs; polish templates.
+ - No deferral: docs must be completed; templates polished sufficiently for production.

collab/plan/01-codexhelper.md

@@ -7,6 +7,10 @@ Purpose: Deliver Phase 1 (Crawl) MVP of CodexHelper: subcommands, scaffolding, p
 - Add `tests/` directory and `scripts/test.sh` using bats-core (document installation/usage).
 - Write initial smoke tests that will fail until implementation exists.
 
+0a) Architecture & Module Map
+- Create `docs/architecture.md` summarizing global architecture, module boundaries, and responsibilities for Phase 1.
+- Add or update ADRs as needed for key decisions.
+
 1) CLI skeleton + guardrails (tests first)
 - Write tests for `--help`, subcommands, and location guardrails.
 - Implement `CodexHelper` with `new-project`, `run`, `new-mode` and enforce location rules.
@@ -31,9 +35,10 @@ Purpose: Deliver Phase 1 (Crawl) MVP of CodexHelper: subcommands, scaffolding, p
 - Write tests covering precedence: global < mode < project < env < CLI.
 - Implement merging with `yq` and apply overrides.
 
-7) Docs
+7) Docs (no deferral)
 - Add `docs/wrapper.md` with usage examples and config reference.
 - Update `README.md` quickstart: installation, basic flows.
+- Ensure docs updated in the same commit as features.
 
 ## Safety & Policies
 - Never overwrite without `--force`.
@@ -42,6 +47,8 @@ Purpose: Deliver Phase 1 (Crawl) MVP of CodexHelper: subcommands, scaffolding, p
 - Minimal chat; read `.llm.md`, write both `.md` and `.llm.md` for collab artifacts.
 - Governance/Propagation: reflect future non-project-specific norms into `prompts/global/` and AGENTS templates; log in DevLog.
 - TDD default: write failing tests before implementing features; require unit/integration tests for all new functionality in this repo and generated projects.
+- Zero Technical Debt: safety first; no technical debt; always production-ready; do not defer tests/docs/refactors; use sub-agents as needed to maintain quality and speed.
+ - Planning/Architecture: align via Questions→Proposal→Plan; maintain `docs/architecture.md` and ADRs; avoid refactors except when plans/docs are updated due to new information.
 
 ## Acceptance Criteria
 - Inside this repo: `CodexHelper new-mode --name Demo` creates `modes/Demo/{mode.md,defaults.yaml}` (and optional `system.md`) and refuses overwrites without `--force`.
@@ -60,13 +67,11 @@ Purpose: Deliver Phase 1 (Crawl) MVP of CodexHelper: subcommands, scaffolding, p
 ## Timeline (targeted)
 Accelerated (8 hours today):
 - Hour 0–1: Test harness setup; write failing smoke tests (CLI, guardrails)
+- Hour 0–1 (parallel): Draft `docs/architecture.md` (module map) and commit
 - Hour 1–2: Milestone 1 — CLI skeleton + guardrails (make tests pass)
 - Hour 2–3: Milestone 2 — Binary detection + pass-through (tests first)
 - Hour 3–4: Milestone 3 — new-mode scaffolder (tests first)
 - Hour 4–6: Milestone 4 — new-project scaffolder (tests first)
 - Hour 6–7: Milestone 5 — run: compose + invoke (tests first)
-- Hour 7–8: Milestone 6 — Config precedence (tests first); write quickstart docs
+- Hour 7–8: Milestone 6 — Config precedence (tests first); finalize quickstart docs
-
-Notes:
-- If behind schedule, defer non-essential docs to a follow-up commit and prioritize tested functionality.
  - Ongoing: Maintain/expand tests with each feature change (TDD).

collab/proposals/01-codexhelper.llm.md

@@ -15,6 +15,8 @@
 - Layout (project): `AGENTS.md`, `prompts/{project.md,style.md?}`, `prompts/_mode/`, `codex.yaml`, `codex.sh`, `runs/`.
 - Governance/Propagation: non-project-specific workflow changes get recorded in `prompts/global/` and seed AGENTS templates; proposal/plan updated so scaffolding includes them.
 - TDD Governance: adopt test-driven development with full unit/integration tests for all features in this repo and generated projects; tests written first and required for acceptance.
+- Zero Technical Debt: safety first; no technical debt; production-ready at all times; no deferring tests/docs/refactors; use sub-agents as needed.
+ - Planning/Architecture Governance: plan ahead via Questions→Proposal→Plan; maintain a global architecture/module map; implement module-by-module; avoid refactors except when assumptions change and plans/docs are updated.
 - Phase 1 acceptance:
   - new-mode creates mode skeleton
   - new-project scaffolds without overwrites
@@ -24,6 +26,8 @@
   - prompts/global present and used in prompt composition
   - governance rule: changes to global norms propagate to prompts/global and AGENTS templates; logged in DevLog
   - tests: unit/integration tests (bats) cover CLI flows and guardrails; TDD observed
+  - zero debt: docs/tests included with every feature; no pending TODOs/deferrals; production-ready criteria met
+  - planning: architecture/module map documented; module implementations follow approved plan with no unplanned refactors
 \n+## Approval — Tick All That Apply
 
 - Subcommands approved: `new-project`, `run`, `new-mode` [ ]

collab/proposals/01-codexhelper.md

@@ -40,6 +40,8 @@ Purpose: Implement a bash wrapper (CodexHelper) around codex-cli with “modes
 - `meta/{AGENTS.seed.md, AGENTS.seed.llm.md}` (seed AGENTS templates for bootstrap/reference)
 - Governance/Propagation: maintain global norms in `prompts/global/` and seed AGENTS templates; reflect such changes in proposal/plan for scaffolding.
 - TDD Governance: enforce test-driven development; require unit/integration tests for all features here and in generated projects.
+- Zero Technical Debt: safety first; always production-ready; no deferring tests/docs/refactors; leverage sub-agents when needed.
+ - Planning/Architecture Governance: plan ahead via Questions→Proposal→Plan; keep a global architecture/module map; implement module-by-module; avoid refactors except when assumptions change and plans/docs are updated.
 
 ## Project Layout (generated)
 - `AGENTS.md` (from `templates/project/_shared/AGENTS.md`)
@@ -64,6 +66,8 @@ Purpose: Implement a bash wrapper (CodexHelper) around codex-cli with “modes
   - Explicit: `prompts/global/` is present and used as the base of composition.
   - Governance/Propagation: non-project-specific rules are folded back into global/system and templates; changes logged.
   - TDD: tests are written first and required for acceptance.
+  - Zero Debt: no pending TODOs/deferrals; docs updated alongside code; production-ready gate on each change.
+  - Planning/Architecture: architecture/module map documented; implementations follow plan without unplanned refactors.
 
 ## Safety
 - Guardrails:
@@ -99,6 +103,7 @@ Purpose: Implement a bash wrapper (CodexHelper) around codex-cli with “modes
   - `prompts/global/{system.md, system.llm.md}` exist and are included in composition.
   - Governance/Propagation honored: when norms change, update `prompts/global/` and AGENTS templates; log in DevLog.
   - TDD honored: a test suite (bats) covers CLI flows and guardrails; tests pass.
+  - Zero Debt honored: code, tests, and docs complete; no debt items remain.
 
 ## Open Items for Confirmation
 - Template coverage: include `prompts/style.md` by default? (we’ll include as optional, empty file)

docs/devlog/DEVLOG_HUMAN.md

@@ -184,3 +184,17 @@ Details:
 
 Next Steps:
 - Execute the plan using TDD, starting with test harness setup and failing tests.
+
+---
+
+Date: 2025-09-17 16:24 (UTC)
+
+Summary:
+- Added governance: zero technical debt and production-ready at all times (safety first, speed second) for this and generated projects.
+
+Details:
+- Updated system prompts and AGENTS templates to mandate zero-debt and remove any doc/test deferrals.
+- Updated proposal and plan to include this rule and acceptance criteria.
+
+Next Steps:
+- Maintain zero-debt gate during implementation; no merges without tests and docs.

docs/devlog/DEVLOG_LLM.md

@@ -146,3 +146,19 @@ This log is concise and structured for quick machine parsing and summarization.
   - Updated plan with hour-by-hour accelerated timeline and deferral notes
 - next:
   - Begin implementation immediately upon plan approval
+
+## 2025-09-17T16:24Z
+- context: Governance update — zero technical debt, production-ready always (safety first)
+- actions:
+  - Updated global system prompt and seed/project AGENTS templates with zero-debt rule
+  - Amended proposal and plan to require docs/tests with every feature; removed any doc deferrals
+- next:
+  - Enforce zero-debt gate throughout implementation
+
+## 2025-09-17T16:30Z
+- context: Governance update — plan ahead and maintain global architecture; avoid refactors
+- actions:
+  - Updated system prompts and AGENTS templates to encode planning/architecture rule
+  - Updated proposal/plan to add architecture/module map deliverable and acceptance
+- next:
+  - Add `docs/architecture.md` early in implementation per plan

meta/AGENTS.seed.llm.md

@@ -9,3 +9,7 @@
 - Prompts/config (if applicable): YAML+yq; precedence CLI>ENV>project>mode>global; prompts order global→mode-system?→mode→project; outputs to `runs/<ts>/`; `--force` to overwrite; never `git push`.
 
 - Governance: For reusable rules, update system prompt and AGENTS templates; keep them aligned; log in DevLog.
+
+- Zero Technical Debt: Safety first; no technical debt; always production-ready; no deferring tests/docs/refactors; TDD by default; keep docs current.
+ 
+- Planning/Architecture: Plan via Questions→Proposal→Plan; maintain global architecture/module map; implement module-by-module; avoid refactors unless assumptions change and plans/docs are updated.

meta/AGENTS.seed.md

@@ -57,6 +57,17 @@ Note: This is a template copied into generated projects. Customize as needed for
 - When introducing non-project-specific collaboration or workflow rules, mirror them in your project’s system prompt and this AGENTS.md template so they persist across projects.
 - Keep AGENTS.md aligned with your system prompt; log such changes in `docs/devlog/`.
 
+## Zero Technical Debt, Production-Ready Always
+- Safety is top priority; speed is second. Never compromise quality.
+- No technical debt allowed. Every commit must be production-ready.
+- No deferring tests, documentation, or necessary refactors.
+- Adopt TDD (tests first); keep docs current with changes.
+
 ---
 
 Customize this AGENTS.md to fit your project specifics while preserving the one-way collaboration flow and file-first practices.
+ 
+## Planning and Architecture
+- Plan ahead: use Questions → Proposal → Plan to align before coding.
+- Maintain a project architecture/module map and document boundaries.
+- Implement module-by-module per plan; avoid refactors, except when new info requires plan/doc updates.

prompts/global/system.llm.md

@@ -15,3 +15,14 @@
 -- Governance/Propagation --
 - When given a reusable, non-project-specific rule, update: global system prompt (both files), seed AGENTS templates (`meta/AGENTS.seed.*`), and project AGENTS template (`templates/project/_shared/AGENTS.md`).
 - Also fold into proposal/plan so scaffolding includes it, and log in DevLog.
+
+-- Zero Technical Debt, Production-Ready --
+- Safety first, speed second. No technical debt ever; always production-ready.
+- No deferring tests/docs/refactors needed for clarity/maintainability.
+- TDD by default (tests first). Keep docs current.
+- Use sub-agents/parallelization to maintain quality and speed.
+-
+-- Planning/Architecture --
+- Plan before coding via Questions → Proposal → Plan.
+- Maintain a global architecture/module map; document boundaries.
+- Implement module-by-module; avoid refactors except when assumptions change and plans/docs are updated.

prompts/global/system.md

@@ -75,6 +75,21 @@ You are a coding agent running in the Codex CLI (terminal-based). Be precise, sa
   - Log the change in `docs/devlog/` with context and rationale.
 - Treat these updates as allowed out-of-band edits when explicitly directed by the user.
 
+## Planning and Architecture
+- Plan first, implement second. Use the Questions → Proposal → Plan cycle to reach alignment before coding.
+- Maintain a global architecture and module map; document boundaries and responsibilities up front.
+- Implement module-by-module using the cycle; avoid refactors by designing ahead. Refactors occur only when new information invalidates assumptions and must be reflected in updated proposals/plans and docs.
+- Keep ADRs or an architecture summary under `docs/` current.
+
+## Zero Technical Debt, Production-Ready Always
+- Safety first, speed second. Never compromise correctness, security, or data safety.
+- No technical debt allowed at any time. Every commit must be production-ready.
+- No deferring of tests, documentation, or refactors required for clarity/maintainability.
+- Follow TDD: write failing tests first; make them pass; refactor.
+- Keep documentation (README, docs/wrapper.md, DevLogs) current with changes.
+- Code must be clean, maintainable, and consistent with project style.
+- Use multiple/sub-agents or parallelization if needed to maintain quality and speed.
+
 ## Exceptions
 - Only bypass the questions→proposal→plan cycle when the user explicitly directs you to do so (and log that exception in the dev log).
 

templates/project/_shared/AGENTS.md

@@ -36,3 +36,13 @@ This file is copied by scaffolding into new projects. Edit to suit the project w
 
 ## Governance and Propagation
 - When you adopt a reusable, non-project-specific practice, reflect it in your project’s system prompt and AGENTS.md to keep them aligned. Log such changes in `docs/devlog/`.
+
+## Zero Technical Debt, Production-Ready Always
+- Safety first; speed second. No technical debt, ever.
+- Do not defer tests, docs, or clarity/maintainability refactors.
+- Practice TDD (tests first) and keep docs up to date with changes.
+
+## Planning and Architecture
+- Plan ahead via Questions → Proposal → Plan to align before coding.
+- Maintain an architecture/module map and clear module boundaries.
+- Implement module-by-module; refactor only when new information requires plan/doc updates.