this-is-enough 0.1.0

package/AGENTS.md

@@ -0,0 +1,546 @@
+# AGENTS.md - Project Agent Operating Rules
+
+## Purpose
+Operate this repository with a strict single-active-requirement workflow.
+Enforce one active lane at a time while still allowing controlled pause/switch/resume.
+Keep architecture, decisions, and validation evidence consistent.
+
+---
+
+## Single Source of Truth (SSOT)
+
+### 1) Active Requirement Lock (SSOT)
+- `reqs/ACTIVE.md` is the only lock + pointer for the active requirement.
+- If `reqs/ACTIVE.md` exists:
+  - One requirement is active (`DRAFT` or `ACTIVE`).
+  - Creating a new `reqs/REQ-*` directory is forbidden.
+- If `reqs/ACTIVE.md` does not exist:
+  - No requirement is active.
+  - Creating a new requirement is allowed.
+
+Note:
+- `reqs/ACTIVE.md` exists only while a requirement is active.
+- Inactive states (`PAUSED`, `BLOCKED`, `DONE`) are recorded in each requirement's `STATUS.md`.
+
+### 2) Current Architecture (SSOT for current design)
+- `ARCHITECTURE.md` represents the current system design and core logic.
+- Update `ARCHITECTURE.md` only when a validated phase introduces architecture-impacting changes.
+
+### 3) Decisions (SSOT for why)
+- ADRs live in `docs/adr/`.
+- Add or update an ADR only when a validated phase introduces architecture-impacting changes.
+
+### 4) Backlog Intake (SSOT for independent incoming requests)
+- `reqs/INBOX.md` is the global intake/backlog for independent requests.
+- While `reqs/ACTIVE.md` exists:
+  - independent new requests must be appended to `reqs/INBOX.md`
+  - they must not be converted into a new `REQ-*` until unlocked (or after explicit pause/switch)
+
+### 5) Interrupt Exception State (SSOT for urgent exception lane)
+- `reqs/INTERRUPT.md` is the only active record for an urgent interrupt.
+- At most one urgent interrupt may be active at a time.
+- After completion, move `reqs/INTERRUPT.md` to `reqs/interrupts/INT-*.md` and remove the active interrupt file.
+
+---
+
+## Repository Layout (Required)
+
+```text
+ARCHITECTURE.md
+AGENTS.md
+docs/
+  adr/
+reqs/
+  INBOX.md                   # global intake for independent requests
+  ACTIVE.md                  # present only while a requirement is active
+  INTERRUPT.md               # present only while an urgent interrupt is active
+  interrupts/                # archive of completed interrupts
+    INT-YYYYMMDD-HHMM-<slug>.md
+  REQ-0001-<slug>/
+    REQUEST.md               # requirement draft/spec
+    ROADMAP.md               # full roadmap (required unless Mini Roadmap criteria are fully met)
+    STATUS.md                # status + phase state + inactive-state record
+    DEFERRED.md              # req-local parking lot for derived non-mandatory ideas
+    phases/
+      PHASE-01/
+        PLAN.md
+        VALIDATION_LOG.md
+      PHASE-02/
+        PLAN.md
+        VALIDATION_LOG.md
+```
+
+---
+
+## Day-0 Bootstrap (MUST)
+
+Run once when adopting this workflow in a new repository.
+
+1) Create required directories
+- `docs/adr/`
+- `reqs/`
+- `reqs/interrupts/`
+
+2) Create required baseline files
+- `ARCHITECTURE.md` (initial architecture baseline; can start minimal)
+- `reqs/INBOX.md` (initialize with header and item schema)
+
+3) Initial lock/interrupt state must be clean
+- `reqs/ACTIVE.md` must not exist at bootstrap completion
+- `reqs/INTERRUPT.md` must not exist at bootstrap completion
+
+4) First requirement starts only after bootstrap
+- create `REQ-*` through lifecycle section `A) Create New Requirement`
+- confirm via section `B) Confirm Requirement` (`full` or `mini` mode)
+
+---
+
+## Status Model (Requirement-Level)
+
+Allowed statuses:
+- `DRAFT`: requirement exists and is being drafted (lock is active)
+- `ACTIVE`: confirmed and currently being executed (lock is active)
+- `PAUSED`: intentionally stopped to work on another requirement (lock not held)
+- `BLOCKED`: cannot progress due to external dependency (lock not held)
+- `DONE`: fully completed (lock not held)
+
+Rules:
+- Only one requirement may be in `DRAFT` or `ACTIVE` at a time.
+- `PAUSED`/`BLOCKED` requirements must include resume metadata in `STATUS.md`.
+
+Definitions:
+- `activate requirement`: set target requirement `STATUS.md` to `ACTIVE` and set `reqs/ACTIVE.md` to that target.
+- `switch execution`: perform switch steps atomically (one continuous operation) without per-step user confirmation; report the final switch result. Ask for user input only if target selection or priority is ambiguous.
+
+---
+
+## Hard Constraints (MUST)
+
+1) Single active requirement
+- Only one requirement lane may be active at a time (`DRAFT` or `ACTIVE`).
+- If `reqs/ACTIVE.md` exists, no new `REQ-*` directory may be created unless pause/switch flow is completed.
+
+2) Single urgent interrupt exception
+- While `reqs/ACTIVE.md` exists, one temporary interrupt lane may be opened through `reqs/INTERRUPT.md`.
+- Interrupt eligibility uses a strict 3-question gate (all `yes` required):
+  - Q1 (`impact_now`): Is there immediate production/customer/business impact that cannot wait? (`yes` for outage, data risk, active security issue, release-blocking incident)
+  - Q2 (`timebox_fit`): Can a safe minimal fix be completed within <= 8 hours?
+  - Q3 (`scope_safe`): Can it be fixed without architecture-impacting changes (no external contract change, no schema/migration, no boundary/topology/security model change)?
+- Priority requirement:
+  - only `P0` or `P1` may use interrupt flow
+- During an interrupt, do not create a new `REQ-*`; execute only the interrupt scope.
+- At most one `reqs/INTERRUPT.md` may exist at a time.
+- If any gate answer is `no`, do not open interrupt flow; route to normal pause/switch + `REQ-*` flow.
+
+3) No new requirement creation while locked
+- While `reqs/ACTIVE.md` exists:
+  - forbidden: creating a new `REQUEST.md` for another requirement
+  - forbidden: creating a new `REQ-*` folder
+- allowed alternatives:
+  - append req-derived/non-mandatory ideas to active requirement `DEFERRED.md`
+  - append independent new requests to `reqs/INBOX.md`
+  - use `reqs/INTERRUPT.md` flow for qualifying urgent interrupts
+
+4) Agent must announce lock/interrupt state
+- At session start and before new planning:
+  - check `reqs/INTERRUPT.md` and `reqs/ACTIVE.md`
+  - if `reqs/INTERRUPT.md` exists, announce interrupt `id`, `status`, `reason`, `related_active`
+  - else if `reqs/ACTIVE.md` exists, announce active requirement `id`, `path`, `status`, `current_phase`
+  - else announce no active requirement and that new creation is allowed
+
+5) Requirement confirmation rule
+- Requirement is confirmed by one of:
+  - Full mode: `ROADMAP.md` exists.
+  - Mini mode: `REQUEST.md` contains a `Mini Roadmap` section and all criteria below are `yes/no`-exactly satisfied:
+    - `single_phase: yes`
+    - `architecture_impact: no`
+    - `external_contract_change: no`
+    - `data_model_change: no`
+    - `security_or_topology_change: no`
+- If any Mini mode criterion becomes false during execution, create `ROADMAP.md` immediately and continue in Full mode.
+
+6) Architecture-impact gated updates
+- After each phase validation:
+  - `VALIDATION_LOG.md` must record:
+    - `architecture_impact: yes|no`
+    - `architecture_impact_reason: <one-line reason>`
+  - if `architecture_impact: yes`:
+    - write/update ADR in `docs/adr/`
+    - update `ARCHITECTURE.md`
+  - if `architecture_impact: no`:
+    - ADR/`ARCHITECTURE.md` updates are optional for that phase
+
+Architecture-impacting change criteria (MUST):
+- classify a phase as architecture-impacting when at least one is true:
+  1. external interface contract changed (API route/schema/status/event/topic/CLI contract)
+  2. data model or persistence changed (schema/index/migration/storage model)
+  3. system boundary/topology changed (service split/merge, sync<->async flow, queue/broker introduction)
+  4. security/trust model changed (auth/authz, secret handling, tenancy/isolation, compliance control)
+  5. reliability/performance design policy changed (caching strategy, consistency model, retry/idempotency policy, SLO-critical path)
+- non-architecture-impacting examples:
+  - bug fixes or refactors without external contract/data model/boundary changes
+  - test-only changes, docs-only changes, copy/style/UI-only changes
+- tie-breaker:
+  - if uncertain, classify as `architecture_impact: yes` and update ADR + `ARCHITECTURE.md`.
+
+7) Inactive-state record rule
+- When moving to `PAUSED` or `BLOCKED`, `STATUS.md` must record:
+  - `changed_at`
+  - `reason`
+  - `resume_condition`
+  - `next_action`
+
+8) Safe switch rule
+- Switching to a different requirement is allowed only by:
+  1. recording a checkpoint in current phase `VALIDATION_LOG.md`
+  2. setting current requirement `STATUS.md` to `PAUSED` or `BLOCKED`
+  3. removing/updating `reqs/ACTIVE.md`
+  4. activating the target requirement by rule:
+    - if target status is `DRAFT`, apply lifecycle section `B) Confirm Requirement`
+    - if target status is `PAUSED` or `BLOCKED`, apply lifecycle section `G) Resume Paused/Blocked Requirement`
+  5. execute switch atomically and report result summary
+
+9) Backlog separation rule
+- `DEFERRED.md` is only for ideas derived from the currently active requirement.
+- `reqs/INBOX.md` is for independent/external requests.
+- Do not mix them.
+
+---
+
+## Session Start Checklist (MUST)
+
+1) Check `reqs/INTERRUPT.md` and `reqs/ACTIVE.md`
+- If `reqs/INTERRUPT.md` exists:
+  - announce active interrupt context
+  - proceed only within interrupt scope until closed
+- Else if `reqs/ACTIVE.md` exists:
+  - announce active requirement context
+  - proceed within that requirement
+- Else:
+  - announce unlocked state and allow creating a new requirement
+
+2) If interrupt is active, read in this order
+1. `reqs/INTERRUPT.md`
+2. `reqs/ACTIVE.md`
+3. `<active_req_path>/STATUS.md`
+4. current phase `PLAN.md` + `VALIDATION_LOG.md` (if exists)
+5. conditionally read `ARCHITECTURE.md` only when at least one is true:
+   - current interrupt scope may hit any architecture-impacting criterion
+   - latest validation context indicates `architecture_impact: yes`
+   - this session just switched/resumed active requirement
+6. conditionally read related ADRs using `ADR selective read protocol` below
+
+3) If active requirement only (no interrupt), read in this order
+1. `reqs/ACTIVE.md`
+2. `<active_req_path>/STATUS.md`
+3. `<active_req_path>/REQUEST.md`
+4. `<active_req_path>/ROADMAP.md` (if exists)
+5. current phase `PLAN.md` + `VALIDATION_LOG.md` (if exists)
+6. conditionally read `ARCHITECTURE.md` only when at least one is true:
+   - current planned change may hit any architecture-impacting criterion
+   - latest validation context indicates `architecture_impact: yes`
+   - this session just switched/resumed active requirement
+7. conditionally read related ADRs using `ADR selective read protocol` below
+
+4) If unlocked and `reqs/INBOX.md` exists
+- review top `open` backlog items before creating a new requirement
+
+ADR selective read protocol (MUST):
+1. scan ADR filenames/titles in `docs/adr/` first (do not read all ADR bodies by default)
+2. for candidate ADRs, read top metadata first
+3. fully read only ADRs that match the current change scope
+4. if matched ADR has `supersedes`, read the superseded ADR one hop for context
+
+---
+
+## Requirement Lifecycle (MUST)
+
+### Intake Rule (Always)
+When a new item appears during work:
+1. if it is required to complete current requirement acceptance, include it in current requirement plan/scope
+2. if it is derived from current requirement but not required now, append to `<active_req>/DEFERRED.md`
+3. if it is an independent/external request, append to `reqs/INBOX.md`
+
+### A) Create New Requirement (Only when unlocked)
+Precondition:
+- `reqs/ACTIVE.md` does not exist
+
+Steps:
+1. create `reqs/REQ-XXXX-<slug>/`
+2. create `REQUEST.md`
+3. create `STATUS.md` with status `DRAFT`
+4. create `reqs/ACTIVE.md` pointing to this requirement with status `DRAFT`
+5. if sourced from `reqs/INBOX.md`, update that item status to `promoted`
+
+### B) Confirm Requirement (`DRAFT` -> `ACTIVE`)
+Trigger:
+- one of:
+  - Full mode: `ROADMAP.md` created in active requirement
+  - Mini mode: `REQUEST.md` includes `Mini Roadmap` and meets all Mini criteria
+
+Steps:
+1. choose confirmation mode (`full` or `mini`)
+2. if `full`: create `ROADMAP.md` (phases, goals, acceptance)
+3. if `mini`: add `Mini Roadmap` in `REQUEST.md` (tasks + acceptance + criteria flags)
+4. update `STATUS.md` to `ACTIVE` and record `roadmap_mode: full|mini`
+5. update `reqs/ACTIVE.md` to `ACTIVE`
+
+### C) Execute Phase (loop)
+For each `PHASE-XX`:
+1. write `phases/PHASE-XX/PLAN.md` with ordered tasks, validation checklist, exit criteria
+2. implement according to plan
+3. append evidence to `phases/PHASE-XX/VALIDATION_LOG.md`
+
+### D) Complete Phase (2 required + 2 conditional)
+A phase is `DONE` only when all required checks pass:
+1. `VALIDATION_LOG.md` has acceptance conclusion
+2. `STATUS.md` and `reqs/ACTIVE.md` are updated
+3. if architecture-impacting changes occurred, ADR is added/updated in `docs/adr/`
+4. if architecture-impacting changes occurred, `ARCHITECTURE.md` reflects the current design
+
+### E) Pause or Block Current Requirement
+Use when scope split or dependency wait occurs.
+
+Steps:
+1. write checkpoint summary in current `VALIDATION_LOG.md`
+2. update `STATUS.md` to `PAUSED` or `BLOCKED`
+3. fill inactive-state record fields (`changed_at`, `reason`, `resume_condition`, `next_action`)
+4. remove `reqs/ACTIVE.md` to unlock
+
+### F) Switch to Another Requirement
+Precondition:
+- previous requirement is set to `PAUSED` or `BLOCKED`
+- lock is removed
+
+Steps:
+1. execute switch as one atomic operation (no per-step user confirmation)
+2. activate target by its current status:
+  - target `DRAFT`: follow section `B) Confirm Requirement`
+  - target `PAUSED`/`BLOCKED`: follow section `G) Resume Paused/Blocked Requirement`
+3. continue work only on newly active requirement
+
+### G) Resume Paused/Blocked Requirement
+Precondition:
+- `reqs/ACTIVE.md` does not exist
+
+Steps:
+1. verify `resume_condition` is met
+2. create `reqs/ACTIVE.md` pointing to paused/blocked requirement
+3. update status to `ACTIVE`
+4. continue from recorded `next_action`
+
+### H) Finish Requirement (`DONE` + unlock)
+Precondition:
+- all phases are `DONE` and validated
+
+Steps:
+1. update `<active_req_path>/STATUS.md` to `DONE` with date
+2. remove `reqs/ACTIVE.md`
+3. optionally append completion summary
+
+### I) Open Urgent Interrupt (Exception Path)
+Precondition:
+- `reqs/ACTIVE.md` exists
+- `reqs/INTERRUPT.md` does not exist
+- interrupt eligibility is satisfied (see Hard Constraints rule 2)
+
+Steps:
+1. append a short checkpoint in current phase `VALIDATION_LOG.md`
+2. create `reqs/INTERRUPT.md` with interrupt metadata and narrow scope
+3. execute only interrupt scope and record validation evidence in `reqs/INTERRUPT.md`
+4. if scope exceeds timebox or becomes non-urgent, close interrupt and move work to normal pause/switch + `REQ-*` flow
+
+### J) Close Urgent Interrupt (Archive + Resume)
+Precondition:
+- `reqs/INTERRUPT.md` exists
+
+Steps:
+1. update `reqs/INTERRUPT.md` with resolution summary and validation outcome
+2. move `reqs/INTERRUPT.md` to `reqs/interrupts/INT-YYYYMMDD-HHMM-<slug>.md`
+3. append a single-line resume note in current phase `VALIDATION_LOG.md` with archived interrupt path only
+4. continue work on requirement referenced by `reqs/ACTIVE.md`
+
+Interrupt logging source-of-truth rule:
+- interrupt details (root cause, changes, validation evidence) must live in interrupt record (`reqs/INTERRUPT.md` while active, `reqs/interrupts/INT-*.md` after close)
+- requirement `VALIDATION_LOG.md` must keep only one-line interrupt close/resume note with pointer to archived interrupt record
+
+---
+
+## Backlog Rules (`reqs/INBOX.md` and `DEFERRED.md`)
+
+Purpose:
+- capture incoming work without breaking single-active workflow
+- separate independent requests from requirement-local deferred ideas
+
+While locked:
+- do not create new requirement docs for side requests
+- append independent/external requests to `reqs/INBOX.md`
+- append requirement-derived/non-mandatory ideas to active requirement `DEFERRED.md`
+- if a request is urgent and satisfies interrupt criteria, handle it via `reqs/INTERRUPT.md` flow
+- capture-time rule: fill all fields from the selected item schema at capture time; if unknown, use explicit placeholder (`unknown` or `-`) and update later
+
+`reqs/INBOX.md` item schema (recommended):
+
+```md
+- id: INB-0001
+  title: <short request>
+  captured_at: 2026-02-14
+  source: <who/where>
+  priority: P2           # P0 | P1 | P2 | P3
+  status: open           # open | promoted | dropped
+  promoted_to: -         # e.g., REQ-0008
+```
+
+Deferred item schema (recommended):
+
+```md
+- id: DEF-0001
+  title: <short idea>
+  captured_at: 2026-02-14
+  reason_deferred: <why not now>
+  target: same-req-later # same-req-later | next-req | unknown
+  status: open            # open | promoted | dropped
+  promoted_to: -          # e.g., REQ-0008
+```
+
+At requirement close:
+- review all deferred items
+- mark each as `promoted` or `dropped`
+- for `next-req` deferred items, create/update matching `reqs/INBOX.md` item(s)
+
+When to execute deferred items:
+1. at phase planning refresh (check if a deferred item should be pulled into current phase)
+2. before requirement `DONE` (resolve each deferred item to `promoted` or `dropped`)
+3. after unlock, when creating next requirement from promoted backlog
+
+---
+
+## File Formats (Machine-Readable)
+
+### `reqs/INBOX.md` (global independent backlog)
+
+```md
+# REQUIREMENT INBOX
+
+- id: INB-0001
+  title: Add 2FA to login
+  captured_at: 2026-02-14
+  source: product-review
+  priority: P2
+  status: open            # open | promoted | dropped
+  promoted_to: -
+```
+
+### `reqs/ACTIVE.md` (lock + pointer)
+
+```md
+# ACTIVE REQUIREMENT (LOCK)
+
+id: REQ-0007
+path: reqs/REQ-0007-some-feature
+status: ACTIVE        # DRAFT | ACTIVE
+current_phase: PHASE-01
+started_at: 2026-02-12
+
+links:
+- status: ./REQ-0007-some-feature/STATUS.md
+- request: ./REQ-0007-some-feature/REQUEST.md
+- roadmap: ./REQ-0007-some-feature/ROADMAP.md
+```
+
+### `reqs/INTERRUPT.md` (active urgent exception)
+
+```md
+# ACTIVE INTERRUPT (EXCEPTION)
+
+id: INT-20260214-2300-login-hotfix
+type: HOTFIX               # HOTFIX | BLOCKER
+priority: P0               # P0 | P1
+status: ACTIVE             # ACTIVE | DONE
+reason: login outage after deployment
+related_active: REQ-0007
+started_at: 2026-02-14T23:00:00Z
+timebox_hours: 4
+
+eligibility_check:
+- impact_now: yes
+- timebox_fit: yes
+- scope_safe: yes
+
+scope:
+- restore login path
+- add regression test for the failing case
+
+validation:
+- <what was checked>
+- <result>
+
+exit_rule:
+- on close, move to `reqs/interrupts/INT-*.md` and clear active `reqs/INTERRUPT.md`
+```
+
+### `STATUS.md` (requirement status)
+Must include:
+- requirement id
+- current status (`DRAFT|ACTIVE|PAUSED|BLOCKED|DONE`)
+- roadmap mode (`full|mini`)
+- phase list (`TODO|ACTIVE|DONE`)
+- pointers to roadmap/current phase plan/validation
+- inactive-state record when status is `PAUSED` or `BLOCKED`
+
+### `REQUEST.md` Mini Roadmap section (when `roadmap_mode: mini`)
+
+```md
+## Mini Roadmap
+single_phase: yes
+architecture_impact: no
+external_contract_change: no
+data_model_change: no
+security_or_topology_change: no
+
+tasks:
+- <ordered task 1>
+- <ordered task 2>
+
+acceptance:
+- <validation check 1>
+- <validation check 2>
+```
+
+### ADR naming
+Use one format:
+- `docs/adr/ADR-0001-<short-title>.md`
+- `docs/adr/ADR-YYYYMMDD-<short-title>.md`
+
+Each ADR must reference:
+- related requirement id
+- related phase
+- decision, alternatives, consequences
+
+ADR metadata for selective lookup (required for new ADRs):
+- components: `<component-a>, <component-b>, ...`
+- status: `active|superseded`
+- supersedes: `<ADR-id>` (optional)
+
+---
+
+## Prohibitions (MUST NOT)
+- do not create a new requirement while `reqs/ACTIVE.md` exists (except the explicit interrupt exception path)
+- do not treat requirement as confirmed without either:
+  - `ROADMAP.md` (full mode), or
+  - valid `REQUEST.md` Mini Roadmap that satisfies all Mini criteria (mini mode)
+- do not keep `roadmap_mode: mini` if any Mini criterion becomes false; switch to full mode immediately
+- do not store independent/external requests only in a requirement `DEFERRED.md`
+- do not promote `reqs/INBOX.md` item to a new `REQ-*` while locked, unless pause/switch procedure is completed
+- do not mark a phase `DONE` without:
+  - `VALIDATION_LOG` acceptance
+  - `STATUS.md` and `ACTIVE.md` update
+  - if architecture-impacting changes occurred: ADR update
+  - if architecture-impacting changes occurred: `ARCHITECTURE.md` update
+- do not record `architecture_impact: no` when any architecture-impacting criterion is met
+- do not open interrupt work as `reqs/INTERRUPT.md` unless all interrupt eligibility criteria are met
+- do not open interrupt work with any missing gate answers (`impact_now`, `timebox_fit`, `scope_safe`)
+- do not keep more than one active interrupt record
+- do not leave `reqs/INTERRUPT.md` after interrupt close; archive it to `reqs/interrupts/`
+- do not duplicate interrupt detail logs in requirement `VALIDATION_LOG.md`; store details only in interrupt record
+- do not switch requirements without writing pause/block checkpoint + inactive-state record

package/README.md

@@ -0,0 +1,126 @@
+# ThisIsEnough
+
+가볍지만 실행 가능한 에이전트 작업 규칙을 프로젝트에 설치하는 CLI입니다.
+
+핵심 목표:
+- 요청 수신
+- 로드맵/플랜 정리
+- 페이즈 실행
+- 검증/기록 유지
+
+기본 규칙 문서는 루트 `AGENTS.md`를 사용합니다.
+
+## Install
+
+빠른 시작:
+
+```bash
+npx this-is-enough@latest init --mode existing --dry-run
+npx this-is-enough@latest init --mode existing
+npx this-is-enough@latest doctor
+```
+
+도움말:
+
+```bash
+npx this-is-enough@latest --help
+```
+
+로컬 개발 실행:
+
+```bash
+node /path/to/this-is-enough/bin/cli.js --help
+```
+
+## Commands
+
+### `init`
+
+Day-0 구조를 생성/보강합니다.
+
+```bash
+npx this-is-enough@latest init --mode new --cwd /path/to/repo
+npx this-is-enough@latest init --mode existing --cwd /path/to/repo --dry-run
+```
+
+로컬 실행:
+
+```bash
+node /path/to/this-is-enough/bin/cli.js init --mode existing --cwd /path/to/repo
+```
+
+옵션:
+- `--mode new|existing`
+- `--cwd <path>` (기본값: 현재 디렉토리)
+- `--dry-run` (변경 예정만 출력)
+- `--force` (기존 파일 덮어쓰기)
+- `--yes` (호환용, 기본이 이미 non-interactive)
+
+### `doctor`
+
+규칙 준수 상태를 점검합니다.
+
+```bash
+npx this-is-enough@latest doctor --cwd /path/to/repo
+```
+
+로컬 실행:
+
+```bash
+node /path/to/this-is-enough/bin/cli.js doctor --cwd /path/to/repo
+```
+
+출력:
+- `OK`: 정상
+- `WARN`: 주의
+- `FAIL`: 필수 항목 누락/불일치 (exit code 1)
+
+### `upgrade`
+
+템플릿/구조를 안전하게 업데이트합니다.
+
+```bash
+npx this-is-enough@latest upgrade --cwd /path/to/repo --dry-run
+npx this-is-enough@latest upgrade --cwd /path/to/repo
+```
+
+로컬 실행:
+
+```bash
+node /path/to/this-is-enough/bin/cli.js upgrade --cwd /path/to/repo
+```
+
+동작:
+- 누락된 `docs/adr`, `reqs`, `reqs/interrupts` 생성
+- 누락된 `ARCHITECTURE.md`, `reqs/INBOX.md` 생성
+- `AGENTS.md`가 다르면 백업(`AGENTS.md.bak.<timestamp>`) 후 갱신
+
+## Installed Structure
+
+`init`/`upgrade`는 아래 구조를 기준으로 맞춥니다.
+
+```text
+ARCHITECTURE.md
+AGENTS.md
+docs/
+  adr/
+reqs/
+  INBOX.md
+  interrupts/
+```
+
+작업 진행 중에는 규칙에 따라 아래 파일이 생길 수 있습니다.
+- `reqs/ACTIVE.md`
+- `reqs/INTERRUPT.md`
+- `reqs/REQ-XXXX-*/...`
+
+## Workflow Modes
+
+- `new`: 빈 프로젝트/초기 프로젝트 설치
+  - clean state 전제 (`reqs/ACTIVE.md`, `reqs/INTERRUPT.md` 없음)
+- `existing`: 진행 중 프로젝트 중간 도입
+  - 기존 상태 보존 중심으로 설치
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,461 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+const HELP = `
+ThisIsEnough CLI
+
+Usage:
+  this-is-enough init --mode <new|existing> [--cwd <path>] [--dry-run] [--force] [--yes]
+  this-is-enough doctor [--cwd <path>]
+  this-is-enough upgrade [--cwd <path>] [--dry-run] [--yes]
+
+Notes:
+  - commands are non-interactive by default (no mid-run prompts).
+  - --yes is accepted for compatibility but not required.
+`;
+
+const ARCHITECTURE_TEMPLATE = `# ARCHITECTURE.md
+
+## Metadata
+- last_updated:
+- scope: as-is baseline
+
+## System Boundary
+- TODO
+`;
+
+const INBOX_TEMPLATE = `# REQUIREMENT INBOX
+
+- id: INB-0001
+  title: <short request>
+  captured_at: YYYY-MM-DD
+  source: <who/where>
+  priority: P2
+  status: open
+  promoted_to: -
+`;
+
+function resolveProjectPaths(cwd) {
+  return {
+    agentsPath: path.join(cwd, "AGENTS.md"),
+    architecturePath: path.join(cwd, "ARCHITECTURE.md"),
+    inboxPath: path.join(cwd, "reqs", "INBOX.md"),
+    activePath: path.join(cwd, "reqs", "ACTIVE.md"),
+    interruptPath: path.join(cwd, "reqs", "INTERRUPT.md"),
+    adrDir: path.join(cwd, "docs", "adr"),
+    reqsDir: path.join(cwd, "reqs"),
+    interruptsDir: path.join(cwd, "reqs", "interrupts")
+  };
+}
+
+function fail(message, code = 1) {
+  console.error(`ERROR: ${message}`);
+  process.exit(code);
+}
+
+function info(message) {
+  console.log(message);
+}
+
+function parseArgs(argv) {
+  const args = {
+    command: null,
+    mode: null,
+    cwd: process.cwd(),
+    dryRun: false,
+    force: false,
+    yes: false,
+    help: false
+  };
+
+  const tokens = argv.slice(2);
+  if (tokens.length === 0) {
+    args.help = true;
+    return args;
+  }
+
+  if (tokens[0] === "--help" || tokens[0] === "-h") {
+    args.help = true;
+    return args;
+  }
+
+  args.command = tokens[0];
+
+  for (let i = 1; i < tokens.length; i += 1) {
+    const t = tokens[i];
+    if (t === "--help" || t === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (t === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (t === "--force") {
+      args.force = true;
+      continue;
+    }
+    if (t === "--yes") {
+      args.yes = true;
+      continue;
+    }
+    if (t === "--mode") {
+      const value = tokens[i + 1];
+      if (!value) fail("--mode requires a value (new|existing)");
+      args.mode = value;
+      i += 1;
+      continue;
+    }
+    if (t === "--cwd") {
+      const value = tokens[i + 1];
+      if (!value) fail("--cwd requires a path");
+      args.cwd = path.resolve(value);
+      i += 1;
+      continue;
+    }
+    fail(`Unknown option: ${t}`);
+  }
+
+  return args;
+}
+
+function ensureDir(dirPath, options, actions) {
+  if (fs.existsSync(dirPath)) {
+    return;
+  }
+  actions.push(`mkdir -p ${dirPath}`);
+  if (!options.dryRun) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function writeFileIfNeeded(filePath, content, options, actions) {
+  if (fs.existsSync(filePath) && !options.force) {
+    actions.push(`skip existing ${filePath}`);
+    return;
+  }
+  if (fs.existsSync(filePath) && options.force) {
+    actions.push(`overwrite ${filePath}`);
+  } else {
+    actions.push(`create ${filePath}`);
+  }
+  if (!options.dryRun) {
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+}
+
+function createFileIfMissing(filePath, content, options, actions) {
+  if (fs.existsSync(filePath)) {
+    actions.push(`skip existing ${filePath}`);
+    return;
+  }
+  actions.push(`create ${filePath}`);
+  if (!options.dryRun) {
+    fs.writeFileSync(filePath, content, "utf8");
+  }
+}
+
+function timestampForBackup() {
+  const now = new Date();
+  const p = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+}
+
+function readTemplateAgents() {
+  const templatePath = path.resolve(__dirname, "..", "AGENTS.md");
+  if (!fs.existsSync(templatePath)) {
+    fail(`Template AGENTS.md not found at ${templatePath}`);
+  }
+  return fs.readFileSync(templatePath, "utf8");
+}
+
+function initProject(options) {
+  const mode = options.mode || "existing";
+  if (mode !== "new" && mode !== "existing") {
+    fail(`Invalid mode "${mode}". Use --mode new or --mode existing.`);
+  }
+
+  if (!fs.existsSync(options.cwd)) {
+    fail(`Target directory does not exist: ${options.cwd}`);
+  }
+
+  const actions = [];
+  const warnings = [];
+  const paths = resolveProjectPaths(options.cwd);
+
+  const dirs = [
+    paths.adrDir,
+    paths.reqsDir,
+    paths.interruptsDir
+  ];
+
+  for (const dirPath of dirs) {
+    ensureDir(dirPath, options, actions);
+  }
+
+  writeFileIfNeeded(paths.agentsPath, readTemplateAgents(), options, actions);
+  writeFileIfNeeded(paths.architecturePath, ARCHITECTURE_TEMPLATE, options, actions);
+  writeFileIfNeeded(paths.inboxPath, INBOX_TEMPLATE, options, actions);
+
+  if (mode === "new") {
+    if (fs.existsSync(paths.activePath)) {
+      fail(`Mode "new" expects clean state, but found ${paths.activePath}`);
+    }
+    if (fs.existsSync(paths.interruptPath)) {
+      fail(`Mode "new" expects clean state, but found ${paths.interruptPath}`);
+    }
+  } else {
+    if (fs.existsSync(paths.activePath)) {
+      warnings.push(`existing mode: found active lock ${paths.activePath} (kept as-is)`);
+    }
+    if (fs.existsSync(paths.interruptPath)) {
+      warnings.push(`existing mode: found interrupt lock ${paths.interruptPath} (kept as-is)`);
+    }
+  }
+
+  info(`Mode: ${mode}`);
+  info(`Target: ${options.cwd}`);
+  if (!options.mode) {
+    info(`Note: --mode not provided, defaulted to "existing".`);
+  }
+  if (options.dryRun) {
+    info(`Dry run: no files were modified.`);
+  }
+  if (options.yes) {
+    info(`Note: --yes provided (non-interactive mode already default).`);
+  }
+
+  if (actions.length === 0) {
+    info(`No changes needed.`);
+  } else {
+    info(`Planned actions:`);
+    for (const action of actions) {
+      info(`- ${action}`);
+    }
+  }
+
+  if (warnings.length > 0) {
+    info(`Warnings:`);
+    for (const warning of warnings) {
+      info(`- ${warning}`);
+    }
+  }
+
+  info(options.dryRun ? "Init check complete." : "Init complete.");
+}
+
+function doctorProject(options) {
+  if (!fs.existsSync(options.cwd)) {
+    fail(`Target directory does not exist: ${options.cwd}`);
+  }
+
+  const paths = resolveProjectPaths(options.cwd);
+  const results = [];
+
+  const addResult = (level, message) => {
+    results.push({ level, message });
+  };
+
+  const checkFile = (filePath, label) => {
+    if (!fs.existsSync(filePath)) {
+      addResult("FAIL", `${label} missing: ${filePath}`);
+      return false;
+    }
+    if (!fs.statSync(filePath).isFile()) {
+      addResult("FAIL", `${label} is not a file: ${filePath}`);
+      return false;
+    }
+    addResult("OK", `${label} exists`);
+    return true;
+  };
+
+  const checkDir = (dirPath, label) => {
+    if (!fs.existsSync(dirPath)) {
+      addResult("FAIL", `${label} missing: ${dirPath}`);
+      return false;
+    }
+    if (!fs.statSync(dirPath).isDirectory()) {
+      addResult("FAIL", `${label} is not a directory: ${dirPath}`);
+      return false;
+    }
+    addResult("OK", `${label} exists`);
+    return true;
+  };
+
+  const hasAgents = checkFile(paths.agentsPath, "AGENTS.md");
+  checkFile(paths.architecturePath, "ARCHITECTURE.md");
+  checkFile(paths.inboxPath, "reqs/INBOX.md");
+  checkDir(paths.adrDir, "docs/adr");
+  checkDir(paths.reqsDir, "reqs");
+  checkDir(paths.interruptsDir, "reqs/interrupts");
+
+  if (hasAgents) {
+    const agentsText = fs.readFileSync(paths.agentsPath, "utf8");
+    if (!agentsText.includes("## Day-0 Bootstrap (MUST)")) {
+      addResult("WARN", "AGENTS.md missing Day-0 Bootstrap section");
+    } else {
+      addResult("OK", "AGENTS.md includes Day-0 Bootstrap section");
+    }
+  }
+
+  if (fs.existsSync(paths.activePath)) {
+    const activeText = fs.readFileSync(paths.activePath, "utf8");
+    addResult("OK", "reqs/ACTIVE.md exists");
+
+    const statusMatch = activeText.match(/^status:\s*([A-Z]+)\s*$/m);
+    if (!statusMatch || (statusMatch[1] !== "DRAFT" && statusMatch[1] !== "ACTIVE")) {
+      addResult("FAIL", "reqs/ACTIVE.md status must be DRAFT or ACTIVE");
+    } else {
+      addResult("OK", `reqs/ACTIVE.md status is ${statusMatch[1]}`);
+    }
+
+    const reqPathMatch = activeText.match(/^path:\s*(.+)\s*$/m);
+    if (!reqPathMatch) {
+      addResult("FAIL", "reqs/ACTIVE.md missing path field");
+    } else {
+      const reqPath = path.resolve(options.cwd, reqPathMatch[1].trim());
+      if (!fs.existsSync(reqPath)) {
+        addResult("FAIL", `active requirement path not found: ${reqPath}`);
+      } else {
+        addResult("OK", "active requirement path exists");
+      }
+    }
+  } else {
+    addResult("OK", "reqs/ACTIVE.md not present (unlocked)");
+  }
+
+  if (fs.existsSync(paths.interruptPath)) {
+    const interruptText = fs.readFileSync(paths.interruptPath, "utf8");
+    addResult("OK", "reqs/INTERRUPT.md exists");
+
+    if (!fs.existsSync(paths.activePath)) {
+      addResult("FAIL", "reqs/INTERRUPT.md exists without reqs/ACTIVE.md");
+    }
+
+    const requiredGateKeys = ["impact_now", "timebox_fit", "scope_safe"];
+    for (const key of requiredGateKeys) {
+      const gateMatch = interruptText.match(new RegExp(`^-\\s*${key}:\\s*(yes|no)\\s*$`, "m"));
+      if (!gateMatch) {
+        addResult("FAIL", `reqs/INTERRUPT.md missing gate answer: ${key}`);
+      } else {
+        addResult("OK", `interrupt gate present: ${key}=${gateMatch[1]}`);
+      }
+    }
+  } else {
+    addResult("OK", "reqs/INTERRUPT.md not present");
+  }
+
+  info(`Target: ${options.cwd}`);
+  info("Doctor report:");
+  for (const result of results) {
+    info(`- ${result.level}: ${result.message}`);
+  }
+
+  const failCount = results.filter((r) => r.level === "FAIL").length;
+  const warnCount = results.filter((r) => r.level === "WARN").length;
+  const okCount = results.filter((r) => r.level === "OK").length;
+  info(`Summary: OK=${okCount} WARN=${warnCount} FAIL=${failCount}`);
+
+  return failCount === 0 ? 0 : 1;
+}
+
+function upgradeProject(options) {
+  if (!fs.existsSync(options.cwd)) {
+    fail(`Target directory does not exist: ${options.cwd}`);
+  }
+
+  const paths = resolveProjectPaths(options.cwd);
+  const actions = [];
+  const warnings = [];
+
+  ensureDir(paths.adrDir, options, actions);
+  ensureDir(paths.reqsDir, options, actions);
+  ensureDir(paths.interruptsDir, options, actions);
+
+  createFileIfMissing(paths.architecturePath, ARCHITECTURE_TEMPLATE, options, actions);
+  createFileIfMissing(paths.inboxPath, INBOX_TEMPLATE, options, actions);
+
+  const templateAgents = readTemplateAgents();
+  if (!fs.existsSync(paths.agentsPath)) {
+    actions.push(`create ${paths.agentsPath}`);
+    if (!options.dryRun) {
+      fs.writeFileSync(paths.agentsPath, templateAgents, "utf8");
+    }
+    warnings.push("AGENTS.md did not exist; created from template.");
+  } else {
+    const currentAgents = fs.readFileSync(paths.agentsPath, "utf8");
+    if (currentAgents === templateAgents) {
+      actions.push(`skip up-to-date ${paths.agentsPath}`);
+    } else {
+      const backupPath = `${paths.agentsPath}.bak.${timestampForBackup()}`;
+      actions.push(`backup ${paths.agentsPath} -> ${backupPath}`);
+      actions.push(`overwrite ${paths.agentsPath}`);
+      if (!options.dryRun) {
+        fs.copyFileSync(paths.agentsPath, backupPath);
+        fs.writeFileSync(paths.agentsPath, templateAgents, "utf8");
+      }
+    }
+  }
+
+  if (fs.existsSync(paths.activePath)) {
+    warnings.push(`active lock detected and kept as-is: ${paths.activePath}`);
+  }
+  if (fs.existsSync(paths.interruptPath)) {
+    warnings.push(`interrupt lock detected and kept as-is: ${paths.interruptPath}`);
+  }
+
+  info(`Target: ${options.cwd}`);
+  if (options.dryRun) {
+    info("Dry run: no files were modified.");
+  }
+  if (options.yes) {
+    info("Note: --yes provided (non-interactive mode already default).");
+  }
+
+  if (actions.length === 0) {
+    info("No changes needed.");
+  } else {
+    info("Planned actions:");
+    for (const action of actions) {
+      info(`- ${action}`);
+    }
+  }
+
+  if (warnings.length > 0) {
+    info("Warnings:");
+    for (const warning of warnings) {
+      info(`- ${warning}`);
+    }
+  }
+
+  info(options.dryRun ? "Upgrade check complete." : "Upgrade complete.");
+  return 0;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help || !args.command) {
+    console.log(HELP.trim());
+    process.exit(0);
+  }
+
+  if (args.command === "init") {
+    initProject(args);
+    return;
+  }
+
+  if (args.command === "doctor") {
+    process.exit(doctorProject(args));
+  }
+
+  if (args.command === "upgrade") {
+    process.exit(upgradeProject(args));
+  }
+
+  fail(`Unknown command "${args.command}". Supported commands: init, doctor, upgrade.`);
+}
+
+main();

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "this-is-enough",
+  "version": "0.1.0",
+  "description": "Install and bootstrap the ThisIsEnough AGENTS.md workflow.",
+  "license": "MIT",
+  "bin": {
+    "this-is-enough": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "AGENTS.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}