@walwal-harness/cli 7.1.54 → 7.1.55

package/assets/templates/AGENTS.md.template

@@ -176,7 +176,7 @@ All Playwright usage by CEO, CXX, and hired workers must run with a visible real
 8. **No CXX self-execution** — CXX agents coordinate and manage only. A CXX that produces deliverables without matching worker records has violated its scope. CEO must reject such reports.
 9. **No verdict without worker evidence** — CQO cannot issue ACCEPTED/REJECTED without a Worker Evidence Manifest referencing at least one evaluator worker. Self-inspection by CQO is not valid evidence.
 10. **Hierarchical worker ownership** — Hired workers are installed under `.claude/skills/{owning-cxx}/{worker}/` and `.codex/skills/{owning-cxx}/{worker}/`; mission worker reports live under `.harness/documents/{goal-or-child-mission}/{owning-cxx}/workers/`. Flat `{mission}/workers/` reports are legacy and signal an ownership violation unless explicitly migrated.
-11. **Lazy convention/gotcha loading** — CXX roles read `.harness/conventions/shared.md`, `.harness/conventions/{cxx}.md`, `.harness/gotchas/shared.md`, and `.harness/gotchas/{cxx}.md`, then follow only the related topic links listed in those CXX files. Workers read only the related links supplied by their owning CXX.
+11. **Lazy convention/gotcha loading** — *What* to read. *When* to read it, and what to write about it, is Rule 20. CXX roles read `.harness/conventions/shared.md`, `.harness/conventions/{cxx}.md`, `.harness/gotchas/shared.md`, and `.harness/gotchas/{cxx}.md`, then follow only the related topic links listed in those CXX files. Workers read only the related links supplied by their owning CXX.
 12. **Implementation Notes required** — `ceo.md`, every `{cxx}.md`, and every worker report must end with one English `## Implementation Notes` section containing `Design Decisions`, `Deviations`, `Tradeoffs`, and `Open Questions`. Use `None` for empty subsections. Do not create a separate sidecar notes file; the notes belong at the bottom of the same role or worker report that produced the decision/evidence.
 13. **Structured runtime state** — If the harness must parse it, record it in JSON or JSONL. CXX todo queues, event history, heartbeat timestamps, preemption/resume state, and completion evidence belong in `.harness/todos/*.json*` or `.harness/events.jsonl`, not in free-form Markdown tables. Markdown remains for instructions, conventions, gotchas, skills, and human-readable mission narrative.
 14. **Mission lifecycle is explicit** — Every goal, submission, and hot-fix directory must contain `mission-state.json` with `lifecycle` and `active`. Only one child mission under a goal may be active. Starting a newer submission/hot-fix closes, cancels, or supersedes the previous active child unless CEO records a deliberate TODO/resume plan.
@@ -185,6 +185,9 @@ All Playwright usage by CEO, CXX, and hired workers must run with a visible real
 17. **Production incidents are company events** — After launch, user-impacting OPS signals route through CEO to CTO/CQO/OPS. CTO owns recovery, CQO owns regression confirmation, and OPS owns evidence plus close criteria.
 18. **Playwright is visible by default** — All Playwright/browser automation must use headed/visible mode (`headless: false` or equivalent). Headless Playwright requires explicit Owner approval recorded in the mission.
 19. **The loop ends only via a runtime transition** — There are exactly two legitimate stop conditions: COMPLETE and BLOCKED-on-external-authority. The autonomous Stop loop and the dashboard read `progress.json` runtime state, not mission documents. After the final Owner report and terminal `mission-state.json`, CEO's last action MUST be `scripts/harness-company-complete.sh` (complete) or `scripts/harness-company-block.sh "<missing authority>"` (blocked). Never end a turn in the `running` state with no queued action, and never fire a terminal transition while real CXX/worker/verification work remains. Between these two endpoints the company keeps progressing autonomously — the Owner is not the pump.
+20. **Lessons precede planning** — Before any source edit, any measurement, and before any brief is issued, every CXX and every hired worker reads `.harness/conventions/shared.md`, `.harness/conventions/{role}.md`, `.harness/gotchas/shared.md`, and `.harness/gotchas/{role}.md`, follows only the topic links those files name, and writes a `## Lessons Preflight` section stating which items apply and why. Any requirement placed on a CXX that its workers must also satisfy is inserted **verbatim** into the worker brief — *a rule stated one layer above the layer that executes it does not apply.* Every `ceo.md`, every `{cxx}.md`, and every worker report carries a one-line `## Lessons Tally` naming which of those items actually fired, placed immediately before `## Implementation Notes`. **Zero fired is a valid tally and must be stated, not omitted** — a tally that only ever reports hits trains agents to manufacture them. Do not distill the corpus into a second checklist file: a derived corpus must be re-synced whenever any source file changes, and it becomes one more thing nobody reads before planning.
+21. **Every worker spawn declares its model** — Never inherit the CLI default. The spawning CXX names the model in the brief, in the Worker Evidence Manifest, and in `progress.json` `company_state.workers[]`. A worker terminated by a usage limit is indistinguishable, from the outside, from a worker that finished — so **a silent loop is a rate limit until proven otherwise.** Check the limit and its reset time before re-briefing, re-hiring, or rewriting the task.
+22. **Readers do not filter by content** — Any reader that scans a role document, worker report, or mission record for sections matches `^>?\s*#{1,6}` and returns every hit: blockquoted or plain, at any depth, with no content filter of any kind. Do not select headings by what they appear to say. A document is free to put verdicts, retractions, standing rules, and continuation lines in a heading, so a reader anchored on `^#` can return superseded content as current — worse than returning nothing. **The reader that decides what is important before reading is the failure.**
 
 ---
 

package/assets/templates/config.json

@@ -168,7 +168,9 @@
   "behavior": {
     "comment": "하네스 동작 플래그. UserPromptSubmit 훅이 이 값을 읽어 v7 CEO/CXX 라우팅 안내를 결정한다.",
     "auto_route_ceo": true,
-    "auto_route_ceo_description": "true 이면 /goal 또는 /hot-fix 이후 Owner 입력을 v7 CEO/CXX mission flow 기준으로 안내한다. 사용자가 'harness skip' 등을 말하면 단일 메시지 한정으로 건너뛴다."
+    "auto_route_ceo_description": "true 이면 /goal 또는 /hot-fix 이후 Owner 입력을 v7 CEO/CXX mission flow 기준으로 안내한다. 사용자가 'harness skip' 등을 말하면 단일 메시지 한정으로 건너뛴다.",
+    "lessons_gate": true,
+    "lessons_gate_description": "true 이면 Stop 훅(scripts/harness-lessons-gate.sh)이 활성 미션의 role 문서에 '## Lessons Preflight'(적용 conventions/gotchas 항목과 이유)와 '## Lessons Tally'(실제 발동 항목, '0 fired' 도 유효)가 없으면 턴 종료를 막는다. AGENTS.md Hard Rule 20 — 교훈은 계획보다 먼저 읽는다. 아직 채택하지 않은 프로젝트는 false 로 opt-out."
   },
   "token_limit": {
     "comment": "모델 토큰 제한으로 작업이 중단됐을 때의 저비용 재개 정책. 별도 probe 호출 없이 시간 기반으로만 재개 알림을 계산한다.",
@@ -184,6 +186,8 @@
     "worker_concurrency": 3,
     "worker_spawn": "claude",
     "worker_spawn_description": "claude 이면 idle worker 배정 시 `claude -p` 백그라운드 프로세스를 띄운다. record 로 두면 prompt/log만 생성한다.",
+    "worker_model": "opus",
+    "worker_model_description": "worker spawn 이 명시적으로 선언하는 모델. AGENTS.md Hard Rule 21 — CLI 기본 모델 상속 금지. 사용량 한도로 종료된 worker 는 밖에서 보면 정상 완료와 구별되지 않으므로, 조용한 루프는 반증 전까지 rate limit 으로 취급한다. 비우면 CLI 기본값을 쓰지만 그 선택 자체를 기록해야 한다.",
     "hourly_wake_executor": "claude",
     "hourly_wake_executor_description": "claude 이면 `claude -p`, codex 이면 `codex exec` 로 매시간 autonomous tick 을 실행한다.",
     "hourly_wake_model": "",

package/assets/templates/worker-report.md.template

@@ -1,5 +1,13 @@
 # {{WORKER_TITLE}} — Worker Report
 
+<!--
+Seeding contract: the owning CXX creates this file WITH EVERY SECTION ALREADY
+PRESENT before the worker starts, and the worker fills it in incrementally as
+the work happens. Do not assemble the report at the end. A worker that dies
+mid-round (rate limit, crash, cancelled session) must leave a valid partial
+report, never a stub.
+-->
+
 ## Status
 IN_PROGRESS
 
@@ -23,6 +31,14 @@ The dashboard uses this line (not file timestamps) to show whether the worker is
 ## Result
 - Outcome and how it meets the acceptance criteria.
 
+## Lessons Tally
+- Corpus items that actually fired during this task: {{LESSONS_FIRED}}
+<!--
+One line. Name the convention/gotcha items from the brief that actually changed
+what you did. `0 fired` is a valid tally and must be stated, not omitted — a
+tally that only ever reports hits trains workers to manufacture them.
+-->
+
 ## Implementation Notes
 
 ### Design Decisions

package/bin/init.js

@@ -167,6 +167,50 @@ function writeClaudeSettings(settings) {
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
 }
 
+// Pre-accept the workspace-trust gate + MCP auto-approval in the user-level
+// ~/.claude.json so unattended Agent Teams teammates don't block on the trust
+// dialog ("this workspace has not been trusted" → settings.json ignored) or the
+// per-project MCP-server prompt. These two flags live ONLY here — no project
+// file can clear them, and --dangerously-skip-permissions does not touch them.
+// Writes are atomic (temp + rename) with a one-time backup so a malformed write
+// can never corrupt the user's global config; any failure is non-fatal to init.
+function acceptWorkspaceTrust() {
+  const claudeJsonPath = path.join(require('os').homedir(), '.claude.json');
+  if (!fileExists(claudeJsonPath)) {
+    log('Skipped workspace-trust pre-accept: ~/.claude.json not found (run Claude here once)');
+    return;
+  }
+  let raw, cfg;
+  try {
+    raw = fs.readFileSync(claudeJsonPath, 'utf8');
+    cfg = JSON.parse(raw);
+  } catch (e) {
+    log('Skipped workspace-trust pre-accept: ~/.claude.json did not parse (left untouched)');
+    return;
+  }
+  if (!cfg.projects || typeof cfg.projects !== 'object') cfg.projects = {};
+  if (!cfg.projects[PROJECT_ROOT] || typeof cfg.projects[PROJECT_ROOT] !== 'object') {
+    cfg.projects[PROJECT_ROOT] = {};
+  }
+  const p = cfg.projects[PROJECT_ROOT];
+  if (p.hasTrustDialogAccepted === true && p.enableAllProjectMcpServers === true) {
+    log('Workspace already trusted + project MCP servers auto-approved');
+    return;
+  }
+  try {
+    const bak = `${claudeJsonPath}.walwal-bak`;
+    if (!fileExists(bak)) fs.writeFileSync(bak, raw);
+    p.hasTrustDialogAccepted = true;
+    p.enableAllProjectMcpServers = true;
+    const tmp = `${claudeJsonPath}.walwal.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2) + '\n');
+    fs.renameSync(tmp, claudeJsonPath);
+    log('Workspace trust pre-accepted + project MCP auto-approved in ~/.claude.json');
+  } catch (e) {
+    log(`WARNING: could not update ~/.claude.json trust state: ${e.message}`);
+  }
+}
+
 function mergeClaudePermissionAllow(settings, entries) {
   if (!settings.permissions || typeof settings.permissions !== 'object') {
     settings.permissions = {};
@@ -812,6 +856,17 @@ function scaffoldHarness() {
     copyFile(harnessMdSrc, harnessMdDest);
   }
 
+  // Worker report skeleton — ALWAYS update. CXX agents seed a worker report
+  // from this file BEFORE the worker starts, so a worker killed mid-round
+  // leaves a valid partial report instead of a stub. (Hard Rule 20 tally +
+  // Hard Rule 12 notes are already present in the skeleton.)
+  const workerTplSrc = path.join(PKG_ROOT, 'assets', 'templates', 'worker-report.md.template');
+  const workerTplDest = path.join(HARNESS_DIR, 'shared', 'templates', 'worker-report.md');
+  if (fs.existsSync(workerTplSrc)) {
+    ensureDir(path.dirname(workerTplDest));
+    copyFile(workerTplSrc, workerTplDest);
+  }
+
   // Copy memory.md (shared learnings)
   const memorySrc = path.join(PKG_ROOT, 'assets', 'templates', 'memory.md');
   const memoryDest = path.join(HARNESS_DIR, 'memory.md');
@@ -1347,6 +1402,17 @@ function installAgentTeamsEnv() {
     log('Agent Teams already enabled');
   }
 
+  // Auto-approve project .mcp.json servers. Each Agent Teams teammate is a fresh
+  // `claude` process that otherwise blocks on the interactive "New MCP server
+  // found in this project" prompt (the launch command uses --permission-mode
+  // auto, which --dangerously-skip-permissions cannot influence). This is the
+  // persisted equivalent of choosing "Use this and all future MCP servers".
+  if (settings.enableAllProjectMcpServers !== true) {
+    settings.enableAllProjectMcpServers = true;
+    changed = true;
+    log('All project MCP servers auto-approved (enableAllProjectMcpServers=true)');
+  }
+
   // Add Claude Code permissions required for harness-driven edits, scripts,
   // and parallel worker isolation. Existing permissions are preserved.
   const harnessPerms = [
@@ -1366,6 +1432,10 @@ function installAgentTeamsEnv() {
     writeClaudeSettings(settings);
     log('Claude settings merged: harness permissions/env preserved with existing settings');
   }
+
+  // Clear the user-level gates that the above settings.json cannot satisfy on
+  // their own (workspace trust + per-project MCP approval).
+  acceptWorkspaceTrust();
 }
 
 const HARNESS_HEADER_MARKER = '<!-- walwal-harness:managed-header -->';
@@ -1646,6 +1716,7 @@ function detectMigrationNeeded() {
     configRuntimeVerificationMissing: false,
     configWakeModelMissing: false,
     configWriteOnSignalMissing: false,
+    configLessonsGateMissing: false,
     coreSkillsStale: false,
     hrResourcePoolStale: false,
     harnessMdStale: false,
@@ -1758,6 +1829,12 @@ function detectMigrationNeeded() {
       if (c.company_mode && c.company_mode.write_on_signal === undefined) {
         flags.configWriteOnSignalMissing = true;
       }
+      if (
+        (c.behavior && c.behavior.lessons_gate === undefined) ||
+        (c.company_mode && c.company_mode.worker_model === undefined)
+      ) {
+        flags.configLessonsGateMissing = true;
+      }
       if (
         c.behavior?.auto_route_dispatcher !== undefined ||
         c.behavior?.auto_route_dispatcher_description ||
@@ -2044,6 +2121,9 @@ function showMigrationProposal(flags) {
   }
   if (flags.configWriteOnSignalMissing) {
     console.log('  • config.json: company_mode.write_on_signal 추가 가능');
+  }
+  if (flags.configLessonsGateMissing) {
+    console.log('  • config.json: behavior.lessons_gate + company_mode.worker_model 추가 가능');
     console.log('    무신호(델타 부재) 틱은 meeting 문서 대신 heartbeat 만 남겨 문서 폭증을 막습니다.');
   }
   if (flags.configLegacyRouting) {
@@ -2130,6 +2210,7 @@ function runMigrate(opts = {}) {
     !flags.configRuntimeVerificationMissing &&
     !flags.configWakeModelMissing &&
     !flags.configWriteOnSignalMissing &&
+    !flags.configLessonsGateMissing &&
     !flags.coreSkillsStale &&
     !flags.hrResourcePoolStale &&
     !flags.harnessMdStale &&
@@ -2217,7 +2298,7 @@ function runMigrate(opts = {}) {
   // 2. config.json — inject company_mode/runtime verification from template if missing
   const configPath = path.join(HARNESS_DIR, 'config.json');
   const tplPath = path.join(PKG_ROOT, 'assets', 'templates', 'config.json');
-  if ((flags.configMissingCompanyMode || flags.configLegacyRouting || flags.configRuntimeVerificationMissing || flags.configWakeModelMissing || flags.configWriteOnSignalMissing) && fs.existsSync(configPath) && fs.existsSync(tplPath)) {
+  if ((flags.configMissingCompanyMode || flags.configLegacyRouting || flags.configRuntimeVerificationMissing || flags.configWakeModelMissing || flags.configWriteOnSignalMissing || flags.configLessonsGateMissing) && fs.existsSync(configPath) && fs.existsSync(tplPath)) {
     const original = fs.readFileSync(configPath, 'utf8');
     const c = JSON.parse(original);
     const tpl = JSON.parse(fs.readFileSync(tplPath, 'utf8'));
@@ -2255,6 +2336,22 @@ function runMigrate(opts = {}) {
         configChanged = true;
         log('  config.json: write_on_signal (무신호 틱 문서 억제) 섹션 동기화');
       }
+      if (flags.configLessonsGateMissing) {
+        // Hard Rule 20/21: the Stop-hook lessons gate and the explicit worker
+        // model. Both default on; a project can opt out of the gate later.
+        c.behavior = c.behavior || {};
+        if (c.behavior.lessons_gate === undefined) {
+          c.behavior.lessons_gate = tpl.behavior?.lessons_gate ?? true;
+          c.behavior.lessons_gate_description = tpl.behavior?.lessons_gate_description;
+        }
+        c.company_mode = c.company_mode || {};
+        if (c.company_mode.worker_model === undefined) {
+          c.company_mode.worker_model = tpl.company_mode?.worker_model ?? '';
+          c.company_mode.worker_model_description = tpl.company_mode?.worker_model_description;
+        }
+        configChanged = true;
+        log('  config.json: lessons_gate + worker_model (Hard Rule 20/21) 섹션 동기화');
+      }
       if (flags.configRuntimeVerificationMissing && tpl.runtime?.verification) {
         c.runtime = c.runtime || {};
         c.runtime.verification = deepMerge(tpl.runtime.verification, c.runtime.verification || {});

package/commands/goal.md

@@ -28,6 +28,8 @@ Required flow:
 11. Do not invoke internal roles through slash commands; commands are Owner entrypoints only.
 12. Do not ask the Owner whether to continue, hire workers, choose internal options, or start the next step. If CEO cannot decide alone, convene the relevant CXX agents and decide from their written recommendations. CEO may approve reversible routine operations such as local cron/launchd/wake automation, dashboard refresh, monitoring cadence, Telegram briefing format using existing credentials, and mission consolidation/supersede cleanup. Stop only for external authority such as new credentials/secrets, payment approval, legal/business acceptance, unavailable production access, destructive data action, or direct conflict with stated Owner direction.
 
+Lessons before plan (AGENTS.md Hard Rule 20): CEO and every CXX read `.harness/conventions/{shared,role}.md` and `.harness/gotchas/{shared,role}.md`, follow only the topic links those files name, and write `## Lessons Preflight` **before** the first edit, the first measurement, and the first worker brief. Every role document and worker report closes with a one-line `## Lessons Tally` immediately above `## Implementation Notes` — `0 fired` is a valid tally and must be stated, not omitted. Requirements a CXX must satisfy that its workers must also satisfy go into the worker brief **verbatim**. The Stop hook enforces this; it is not advisory.
+
 Note: A goal is the company's objective. Submissions and hot-fixes that happen while pursuing it should be recorded under that goal directory.
 
 Harness documents (ceo.md, cto.md, cqo.md, worker reports) are mission records, not derived output documents. A docmeta skip decision on these files does not authorize skipping any harness protocol step.

package/commands/hot-fix.md

@@ -28,6 +28,10 @@ Required flow:
 13. Do not invoke internal roles through slash commands; commands are Owner entrypoints only.
 14. Do not ask the Owner whether to continue, hire workers, choose internal options, or start the next step. If CEO cannot decide alone, convene the relevant CXX agents and decide from their written recommendations. CEO may approve reversible routine operations such as local cron/launchd/wake automation, dashboard refresh, monitoring cadence, Telegram briefing format using existing credentials, and mission consolidation/supersede cleanup. Stop only for external authority such as new credentials/secrets, payment approval, legal/business acceptance, unavailable production access, destructive data action, or direct conflict with stated Owner direction.
 
+Lessons before plan (AGENTS.md Hard Rule 20): CEO and every CXX read `.harness/conventions/{shared,role}.md` and `.harness/gotchas/{shared,role}.md`, follow only the topic links those files name, and write `## Lessons Preflight` **before** the first edit, the first measurement, and the first worker brief. Every role document and worker report closes with a one-line `## Lessons Tally` immediately above `## Implementation Notes` — `0 fired` is a valid tally and must be stated, not omitted. Requirements a CXX must satisfy that its workers must also satisfy go into the worker brief **verbatim**. The Stop hook enforces this; it is not advisory.
+
+Scale the read to the fix. A four-line patch pays the index files plus only the topic links that match the fix — not the whole corpus. The ordering constraint holds at every size; the depth does not.
+
 Note: `/hot-fix` is a problem-fix flow while pursuing the active goal. It belongs under that goal in history.
 
 Harness documents (ceo.md, cto.md, cqo.md, worker reports) are mission records, not derived output documents. A docmeta skip decision on these files does not authorize skipping any harness protocol step.

package/commands/submission.md

@@ -28,6 +28,8 @@ Required flow:
 13. Do not invoke internal roles through slash commands; commands are Owner entrypoints only.
 14. Do not ask the Owner whether to continue, hire workers, choose internal options, or start the next step. If CEO cannot decide alone, convene the relevant CXX agents and decide from their written recommendations. CEO may approve reversible routine operations such as local cron/launchd/wake automation, dashboard refresh, monitoring cadence, Telegram briefing format using existing credentials, and mission consolidation/supersede cleanup. Stop only for external authority such as new credentials/secrets, payment approval, legal/business acceptance, unavailable production access, destructive data action, or direct conflict with stated Owner direction.
 
+Lessons before plan (AGENTS.md Hard Rule 20): CEO and every CXX read `.harness/conventions/{shared,role}.md` and `.harness/gotchas/{shared,role}.md`, follow only the topic links those files name, and write `## Lessons Preflight` **before** the first edit, the first measurement, and the first worker brief. Every role document and worker report closes with a one-line `## Lessons Tally` immediately above `## Implementation Notes` — `0 fired` is a valid tally and must be stated, not omitted. Requirements a CXX must satisfy that its workers must also satisfy go into the worker brief **verbatim**. The Stop hook enforces this; it is not advisory.
+
 Note: `/submission` is not a new company goal and not an emergency fix. It is an additional requirement while pursuing the active goal. It belongs under that goal in history.
 
 Submission request:

package/conventions/cqo.md

@@ -5,3 +5,5 @@
 - CQO hires evaluators and reviewers before assigning specialist quality work.
 - No archive is accepted without evidence.
 - Verified recurring lessons are promoted to `.harness/conventions/`, `.harness/gotchas/`, `.harness/memories/`, or `.harness/shared/`.
+- Negative evidence is inadmissible without a positive control that fires in the same run and varies the exact variable under suspicion. A verdict resting on an unproven negative is BLOCKED, not PASS.
+- Where an instrument comes from a dependency rather than in-repo code, its filtering behaviour is read from source and quoted (package, version, file, line range), not inferred from observed output.

package/conventions/ops.md

@@ -7,3 +7,4 @@
 - OPS records operating decisions in `.harness/documents/{mission_name}/ops.md`.
 - OPS writes daily logs under `.harness/logs/YYYY-MM-DD/`.
 - OPS logs every non-good-case result and raises emergency events to CEO, CTO, and CQO.
+- OPS records the instrument behind every negative claim — tool, log level, filter, and the positive control that fired in the same run. An unrecorded instrument makes the run's negative results unusable.

package/conventions/shared.md

@@ -24,6 +24,21 @@
 - CXX decisions use `{cxx}.md`.
 - Worker reports use `{owning-cxx}/workers/{worker-name}.md`.
 
+## Section-Scoped Reading
+
+Any reader that scans a role document, worker report, or mission record for sections — a script, a hook, an agent following a protocol — matches:
+
+```
+^>?\s*#{1,6}
+```
+
+and returns **every** hit. Blockquoted or plain, at any depth, with **no content filter of any kind**.
+
+- **Do not filter headings by what they appear to say.** A filter encodes the reader's guess about which headings matter, and a document is free to put anything in a heading: verdicts, in-place retractions, standing rules, continuation lines.
+- A verdict-token filter and a retraction-marker filter, measured against real CXX documents, caught 3/11 and 4/11 blockquoted headings; their union still missed 4 — including the second line of a verdict, whose first line was caught. **A filter that catches half a verdict is worse than one that catches none, because it reports success.**
+- A reader anchored on `^#` reads a claim and never reaches the in-place retraction posted below it as `> ## …`. That is worse than missing a section: it returns superseded content as current.
+- **The reader that decides what is important before reading is the failure.**
+
 ## DDD
 
 - Keep domain, application, interface, and infrastructure decisions distinct.

package/gotchas/cqo.md

@@ -7,3 +7,15 @@ Do not approve archive based on narrative confidence. Require concrete quality e
 ## Unpromoted Recurrence
 
 Do not leave repeated failures only in chat or mission notes. Promote verified recurrence prevention to conventions, gotchas, memories, or shared state.
+
+## Negative Evidence Without A Positive Control
+
+"No error was logged", "no stubbed 2xx was served", "no leak was detected" are claims about the instrument, not about the system, until a positive control fires in the same run and varies the exact variable under suspicion. Do not accept a clean negative result whose instrument was never shown to be able to see the failure.
+
+## Null Instrument Supplied By A Dependency
+
+An instrument's filtering behaviour is read from source and quoted — package, version, file, line range — never inferred from observed output. A log filter that lives in a dependency is invisible to every in-repo search, so its absence from the project's own code proves nothing. When an instrument turns out to have been structurally null, re-open the affected claims **by their shape** — every claim of that form, not only the one that happened to be noticed.
+
+## Audit Questions That Offer Alternatives
+
+An audit question that offers alternatives asserts that the alternatives are exhaustive. "Is it a skip rule **or** a status-conditional format?" cannot return "neither, it is upstream" — both branches locate the rule inside our own code, so the true answer is unreachable from the question's grammar. When an audit stalls, re-ask the question without the menu.

package/gotchas/cto.md

@@ -7,3 +7,7 @@ Do not assign architecture, backend, frontend, DevOps, and evaluation to one gen
 ## Missing Boundary
 
 Do not start implementation before domain, API, platform, account, and integration boundaries are explicit enough for workers.
+
+## Stub Report From A Worker Killed Mid-Round
+
+A report assembled at the end of a round becomes a stub when the round is cut short, and a stub halts the company. Create the worker report with every required section present **before** the worker starts, and require it to be filled in incrementally. Same failure, opposite outcome: an unseeded worker killed mid-round leaves a stub and costs a re-run; a seeded worker killed by the same limit leaves an intact partial report and costs nothing. The variable is a decision taken before the round.

package/gotchas/ops.md

@@ -15,3 +15,7 @@ Do not monitor a production/service endpoint as live until the Owner-provided se
 ## Port Drift
 
 Do not let CXX agents choose arbitrary ports. CEO must set `HARNESS_BASE_PORT` as a `{xx}000` value in `.env`, and services must derive their ports above that base.
+
+## Clean Log From An Unproven Instrument
+
+"Nothing bad appeared in the log" is worth nothing until a positive control proves the log could have shown it. Dev servers, log middleware, proxies, and test runners routinely drop successful or sub-threshold requests at a log level nobody chose deliberately, and that rule appears nowhere in the project's own code. Record the instrument — tool, log level, filter, control — in Environment Evidence, or report the observation as unverified rather than clean.

package/gotchas/shared.md

@@ -11,3 +11,21 @@ Do not add internal slash commands for CXX or workers. Commands are Owner entryp
 ## Runtime State In Package Repo
 
 Do not create or commit project runtime `.harness/` state in this package repository.
+
+## Written, Indexed, And Still Too Late
+
+A lesson that is written, indexed, and reachable still costs a mission if it is read *after* the mistake. The corpus is rarely the problem; the ordering is. Read `conventions/` and `gotchas/` **before** the first edit, the first measurement, and the first brief — then write the plan.
+
+Do not answer this with a distilled checklist file. A derived corpus must be re-synced whenever any source file changes, goes stale silently, and becomes a second thing nobody reads before planning.
+
+## Silent Worker Is A Rate Limit
+
+A worker terminated by a usage limit is indistinguishable, from the outside, from a worker that finished. A silent or truncated round is a rate limit until proven otherwise — check the limit and its reset time before re-briefing, re-hiring, or rewriting the task. This is why every spawn must declare its model: without a declared model there is nothing to check the limit against.
+
+## Heading Readers That Filter By Content
+
+A reader anchored on `^#` misses the same heading written as `> ## …`, which is exactly how in-place retractions, verdict continuations, and standing rules get posted. Match `^>?\s*#{1,6}` and return every hit with no content filter. A filter that catches half a verdict is worse than one that catches none, because it reports success.
+
+## Rules Stated One Layer Above The Executing Layer
+
+A requirement placed on a CXX that its workers must also satisfy does not reach the workers unless it is inserted **verbatim** into the worker brief. A rule stated one layer above the layer that executes it does not apply, and the layer below cannot infer a rule it was never given.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walwal-harness/cli",
-  "version": "7.1.54",
+  "version": "7.1.55",
   "description": "Company-style AI agent harness for Claude and Codex. Installs commands, CXX agents, skills, HR-Resource hiring pool, and project-local .harness runtime state.",
   "bin": {
     "walwal-harness": "bin/init.js"

package/scripts/harness-hourly-review.sh

@@ -309,7 +309,7 @@ fi
 # that needs execution, or a change in verdict since the last recorded review.
 # Control flow (conductor-tick.sh) routes off progress.json state, not this file,
 # so suppressing the markdown on quiet ticks is safe.
-write_on_signal="$(jq -r '.company_mode.write_on_signal // true' "$CONFIG" 2>/dev/null || echo true)"
+write_on_signal="$(jq -r 'if .company_mode.write_on_signal == null then true else .company_mode.write_on_signal end' "$CONFIG" 2>/dev/null || echo true)"
 last_verdict="$(jq -r '.meetings.last_reason // ""' "$PROGRESS" 2>/dev/null || echo "")"
 has_signal=true
 if [ "$write_on_signal" = "true" ]; then

package/scripts/harness-lessons-gate.sh

@@ -0,0 +1,130 @@
+#!/bin/bash
+# harness-lessons-gate.sh — enforce "lessons precede planning" where the Stop
+# hook already stops the turn (AGENTS.md Hard Rule 20).
+#
+# A role document that was written without reading the corpus is invisible; a
+# role document that names which corpus items it applied, and then tallies which
+# of them actually fired, is not. Rules that live only in prose are followed
+# when convenient — this one gets the mechanism that already works.
+#
+# Checks every role document of the in-scope mission for:
+#   ## Lessons Preflight   — which convention/gotcha items apply, and why
+#   ## Lessons Tally       — one line: which of them actually fired ("0 fired" is valid)
+#
+# Usage: harness-lessons-gate.sh <project-root> [text|json] [all|latest-active]
+set -euo pipefail
+
+PROJECT_ROOT="${1:-.}"
+DOC_ROOT="$PROJECT_ROOT/.harness/documents"
+CONFIG="$PROJECT_ROOT/.harness/config.json"
+
+[ -d "$DOC_ROOT" ] || exit 0
+
+mode="${2:-text}"
+scope="${3:-all}"
+
+# Opt-out for projects that have not adopted the sections yet.
+if command -v jq >/dev/null 2>&1 && [ -f "$CONFIG" ]; then
+  # jq's `//` treats `false` as empty, so `.x // true` can never return false.
+  # Test for null explicitly or the opt-out silently does nothing.
+  enabled=$(jq -r 'if .behavior.lessons_gate == null then true else .behavior.lessons_gate end' "$CONFIG" 2>/dev/null || echo true)
+  if [ "$enabled" != "true" ]; then
+    [ "$mode" = "json" ] && jq -nc '{ok:true, violations:[], skipped:"lessons_gate disabled"}'
+    exit 0
+  fi
+fi
+
+violations=()
+
+# Section-scoped reading (conventions/shared.md): match `^>?\s*#{1,6}` and take
+# every hit — blockquoted or plain, at any depth, with no content filter.
+HEADING2='^[[:space:]]*>?[[:space:]]*##[[:space:]]+'
+
+has_section() {
+  local file="$1" title="$2"
+  [ -s "$file" ] || return 1
+  grep -Eq "${HEADING2}${title}[[:space:]]*$" "$file"
+}
+
+is_terminal_lifecycle() {
+  case "$1" in
+    closed|cancelled|superseded|complete|completed|blocked) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+mission_mtime() {
+  stat -f '%m' "$1" 2>/dev/null || stat -c '%Y' "$1" 2>/dev/null || echo 0
+}
+
+mission_dirs=$(find "$DOC_ROOT" -type f \( -name 'ceo.md' -o -name 'coo.md' -o -name 'cdo.md' -o -name 'cto.md' -o -name 'cqo.md' -o -name 'ops.md' \) -exec dirname {} \; 2>/dev/null | sort -u)
+
+if [ "$scope" = "latest-active" ]; then
+  latest_active_mission=""
+  latest_active_mtime=0
+  while IFS= read -r mission_dir; do
+    [ -n "$mission_dir" ] || continue
+    state_path="$mission_dir/mission-state.json"
+    [ -f "$state_path" ] || continue
+    command -v jq >/dev/null 2>&1 || continue
+    active=$(jq -r '.active // false' "$state_path" 2>/dev/null || echo false)
+    lifecycle=$(jq -r '.lifecycle // .status // "unknown"' "$state_path" 2>/dev/null || echo unknown)
+    if [ "$active" != "true" ] || is_terminal_lifecycle "$lifecycle"; then
+      continue
+    fi
+    mtime=$(mission_mtime "$mission_dir")
+    if [ "${mtime:-0}" -ge "${latest_active_mtime:-0}" ]; then
+      latest_active_mtime="$mtime"
+      latest_active_mission="$mission_dir"
+    fi
+  done <<EOF
+$mission_dirs
+EOF
+  mission_dirs="$latest_active_mission"
+fi
+
+while IFS= read -r mission_dir; do
+  [ -n "$mission_dir" ] || continue
+  [ -d "$mission_dir" ] || continue
+  mission_name="${mission_dir#"$DOC_ROOT"/}"
+
+  for role in ceo coo cdo cto cqo ops; do
+    role_path="$mission_dir/$role.md"
+    [ -s "$role_path" ] || continue
+    if ! has_section "$role_path" "Lessons Preflight"; then
+      violations+=("$mission_name:$role.md-missing-lessons-preflight")
+    fi
+    if ! has_section "$role_path" "Lessons Tally"; then
+      violations+=("$mission_name:$role.md-missing-lessons-tally")
+    fi
+  done
+done <<EOF
+$mission_dirs
+EOF
+
+if [ "${#violations[@]}" -eq 0 ]; then
+  if [ "$mode" = "json" ]; then
+    jq -nc '{ok:true, violations:[]}' 2>/dev/null || echo '{"ok":true,"violations":[]}'
+  fi
+  exit 0
+fi
+
+if [ "$mode" = "json" ]; then
+  printf '%s\n' "${violations[@]}" | jq -Rcs '
+    split("\n")[:-1]
+    | map(capture("(?<mission>[^:]+):(?<docs>.*)") | .docs = (.docs | split(" ")))
+    | {ok:false, violations:.}
+  '
+else
+  echo "Lessons-before-plan violation (AGENTS.md Hard Rule 20):"
+  for violation in "${violations[@]}"; do
+    mission="${violation%%:*}"
+    docs="${violation#*:}"
+    echo "- mission: $mission"
+    echo "  issue: $docs"
+    echo "  required: '## Lessons Preflight' (which convention/gotcha items apply, and why)"
+    echo "            '## Lessons Tally' (one line: which fired; '0 fired' is valid and must be stated)"
+  done
+fi
+
+exit 1

package/scripts/harness-stop.sh

@@ -25,7 +25,9 @@ CONFIG="$CWD/.harness/config.json"
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 
 # Opt-out
-AUTO_CHAIN=$(jq -r '.behavior.auto_chain_on_stop // true' "$CONFIG" 2>/dev/null || echo "true")
+# `.x // true` would collapse an explicit `false` back to `true` (jq treats
+# false as empty), which silently disabled this documented opt-out.
+AUTO_CHAIN=$(jq -r 'if .behavior.auto_chain_on_stop == null then true else .behavior.auto_chain_on_stop end' "$CONFIG" 2>/dev/null || echo "true")
 if [ "$AUTO_CHAIN" != "true" ]; then exit 0; fi
 
 # 무한루프 방지: 한 sprint 안에서 stop_chain_count 가 상한을 넘으면 중단
@@ -167,6 +169,28 @@ if [ -x "$SCRIPT_DIR/harness-worker-evidence-validate.sh" ]; then
   fi
 fi
 
+# Lessons-before-plan gate (AGENTS.md Hard Rule 20):
+# 코퍼스를 읽고 계획을 세운 흔적이 role 문서에 없으면 턴을 끝내지 못하게 막는다.
+# 산문으로만 존재하는 규칙은 편할 때만 지켜진다 — 이미 동작하는 정지 메커니즘에
+# 검사를 붙인다. 활성 미션 1개로 스코프를 좁혀 legacy/archive 문서가 영구히
+# Stop 을 막지 않게 한다. .harness/config.json 의 behavior.lessons_gate=false 로
+# 아직 채택하지 않은 프로젝트는 opt-out 할 수 있다.
+if [ -x "$SCRIPT_DIR/harness-lessons-gate.sh" ]; then
+  LESSONS_JSON=$("$SCRIPT_DIR/harness-lessons-gate.sh" "$CWD" json latest-active 2>/dev/null || true)
+  LESSONS_OK=$(echo "$LESSONS_JSON" | jq -r 'if has("ok") then .ok else true end' 2>/dev/null || echo true)
+  if [ "$LESSONS_OK" != "true" ]; then
+    REASON=$(echo "$LESSONS_JSON" | jq -r '
+      "교훈 선행 게이트(Hard Rule 20): " +
+      ([.violations[] | "\(.mission) → \(.docs | join(","))"] | join("; ")) +
+      ". 각 role 문서에 `## Lessons Preflight`(이 미션에 적용되는 conventions/gotchas 항목과 이유)와 " +
+      "그 아래 `## Implementation Notes` 바로 앞에 한 줄짜리 `## Lessons Tally`(실제로 발동한 항목; `0 fired` 도 유효하며 생략은 불가)를 " +
+      "추가한 뒤 계속하라. 코퍼스를 다시 요약한 별도 체크리스트 파일을 만들지 말 것 — 읽는 순서를 고치는 규칙이다."
+    ' 2>/dev/null || echo "교훈 선행 게이트(Hard Rule 20): active mission 의 role 문서에 ## Lessons Preflight / ## Lessons Tally 가 없습니다. 먼저 추가하세요.")
+    jq -nc --arg reason "$REASON" '{decision:"block", reason:$reason}'
+    exit 0
+  fi
+fi
+
 # stop_chain_count 증가 (느슨한 카운터 — race 허용)
 NEW_COUNT=$((STOP_CHAIN_COUNT + 1))
 TMP=$(mktemp)

package/scripts/harness-user-prompt-submit.sh

@@ -16,7 +16,7 @@ STRUCTURED_LIB="$SCRIPT_DIR/lib/harness-structured-log.sh"
 # 조건 2: opt-out 플래그 확인
 AUTO_ROUTE="true"
 if command -v jq >/dev/null 2>&1; then
-  AUTO_ROUTE=$(jq -r '.behavior.auto_route_ceo // .behavior.auto_route_dispatcher // true' "$CWD/.harness/config.json" 2>/dev/null || echo "true")
+  AUTO_ROUTE=$(jq -r 'if .behavior.auto_route_ceo != null then .behavior.auto_route_ceo elif .behavior.auto_route_dispatcher != null then .behavior.auto_route_dispatcher else true end' "$CWD/.harness/config.json" 2>/dev/null || echo "true")
 fi
 if [ "$AUTO_ROUTE" != "true" ]; then exit 0; fi