@ripla/godd-mcp 0.1.2-beta-20260312091403

package/templates/partials/cogito-root-devops.hbs

@@ -0,0 +1,71 @@
+{{! cogito-root-devops — DevOps / Cloud / Infrastructure / Observability roots ~80 entries }}
+
+{{! — containers & orchestration — }}
+铸цАш(甲) =Docker ⚙=multi-stage Dockerfile ◈=image layer
+铺пき뢴(乙) =container ⊛=volume ⎈=network bridge
+铼タ괛ра(丙) =Docker Compose ⚙=service ⊛=depends_on
+铿ミ뵊д(甲) =Kubernetes ⏣=Pod ⊛=Service
+锁フ쪵b(乙) ⏣=Deployment ⏣=StatefulSet ◈=ConfigMap
+锃ル놓ц(丙) ⏣=Ingress ⎈=namespace ⊛=service mesh
+锅キ됗ш(甲) ⚙=Helm ⚙=Kustomize ⏣=operator
+锇ш쩝e(乙) =Istio ⊛=sidecar ⎈=envoy proxy
+
+{{! — cloud providers & services — }}
+锉ц괟ら(甲) =AWS ⎈=EC2 ⊛=S3
+锋п뢴д(乙) =GCP ⎈=Cloud Run ⊛=GCS
+锍タ읏b(丙) =Azure ⎈=App Service ⊛=Blob
+锏ミ쭎ц(甲) =Railway ⎈=Vercel ⊛=Fly.io
+锑フ쫄ш(乙) ⎈=Lambda ⚡=serverless ◈=cold start
+锓ル괩e(丙) ⎈=VPC ⊛=subnet ⊕=security group
+锕キ훔ра(甲) ⊛=CDN ⎈=edge function ⊕=region
+锗ш벶д(乙) ⎈=managed DB ⊛=RDS ⊕=DB connection pool
+
+{{! — CI/CD & pipelines — }}
+锛ц꿸b(甲) =CI pipeline ⚡=CI job ⊛=pipeline stage
+锝п듾ц(乙) =CD ⚡=deploy trigger ◉=schedule
+锟タ쁩ш(丙) ⚡=GitHub Actions ⚙=workflow ⊛=step
+锡ミ릊e(甲) ⎈=GitLab CI ⎈=CircleCI ⎈=Jenkins
+锣フ쨍ра(乙) ⚡=artifact ⊟=registry ◈=tag
+锥ル괡д(丙) ⚡=rollback ⚡=canary ⚡=blue-green
+锧キ뭏b(甲) ◈=secret ⚙=env variable ▽=vault
+锩ш됗ц(乙) ⊕=build matrix ⊛=parallelism ◉=build timeout
+
+{{! — observability & monitoring — }}
+锫ц뵊ш(甲) ⎈=infra monitoring ◈=metric ⊕=SLA/SLO
+锭п쩔e(乙) ☰=logging ⊕=log level ⊛=structured log
+锯タ괛ра(丙) ⊛=tracing ◈=span ◉=trace ID
+锱ミ쪵д(甲) ⎈=Prometheus ⎈=Grafana ⊛=alert rule
+锳フ놓b(乙) ⎈=Datadog ⎈=New Relic ⊕=APM
+锵ル됗ц(丙) ⎈=ELK ⎈=Loki ☰=retention policy
+锷キ쩝ш(甲) ⊕=latency ⊕=throughput ⊜=percentile
+锹ш괟e(乙) ◈=liveness check ⚡=probe ⊗=incident
+
+{{! — networking & DNS — }}
+锻ц뢴ра(甲) ⎈=DNS ⊛=A record ⊛=CNAME
+锽п읏д(乙) ⎈=TLS ▽=certificate ◈=HTTPS
+锿タ쭎b(丙) ⎈=cloud load balancer ⏣=reverse proxy ⊛=upstream
+镁ミ쫄ц(甲) ⊛=gRPC ⏣=protocol buffer ◈=message
+镃フ괩ш(乙) ⎈=cloud API gateway ⊛=rate limit ⊕=throttle
+
+{{! — IaC & configuration — }}
+镅ц훔e(甲) =Terraform ⚙=HCL ⊛=state file
+镇п벶ら(乙) =Ansible ⚙=playbook ⊛=role
+镉タ꿸д(丙) =Pulumi ⚙=CDK ⊛=stack
+镋ミ듾b(甲) ⊛=drift detection ⚡=plan ⚡=apply
+镍フ쁩ц(乙) ⚙=config management ⊛=immutable infra ⊕=idempotent
+
+{{! — database ops — }}
+镏ц릊ш(甲) ⚡=replication ⊛=replica ⊕=consistency
+镑п쨍e(乙) ⚡=failover ⊛=cluster ⊗=split brain
+镓タ괡ら(丙) ⚡=point-in-time recovery ◈=WAL ◈=snapshot
+镕ミき뭏д(甲) ⚙=connection pooler ⊛=PgBouncer ⊕=max connections
+
+{{! — devops verbs — }}
+镗ц뢴(v) =provision/allocate
+镙п괛(v) =scale up/scale out
+镛タ쪵(v) =containerize/package
+镝ミ놓(v) =orchestrate/schedule
+镟フ됗(v) =monitor/observe
+镡ル쩝(v) =alert/page
+镣キ괟(v) =rotate/renew (secrets/certs)
+镥ш읏(v) =backup/restore

package/templates/partials/cogito-root-framework.hbs

@@ -0,0 +1,80 @@
+{{! cogito-root-framework — framework-specific roots ~80 entries }}
+{{! Covers: React, Next.js, Vue, Angular, Svelte, Django, Rails, FastAPI, Express, NestJS, etc. }}
+
+{{! — React / Next.js — }}
+钊цАд(甲) =React ⏣=JSX ⎆=React virtual DOM
+钌пき뢴(乙) ⌬=hook ⚡=useEffect ◈=useState
+钎タ괛b(丙) ⏣=Server Component ⏣=Client Component ⚡=Suspense
+钐ミ뵊ц(甲) ⎆=portal ⊛=context ◈=ref
+钒フ쪵ш(乙) =Next.js ⏣=App Router ⚡=Server Action
+钔ル놓e(丙) ⚡=SSR ⚡=SSG ⚡=ISR
+钖キ됗ら(甲) ⏣=Next.js middleware ⏣=route group ⊛=layout
+钘ш쩝д(乙) ⚡=RSC streaming ⊕=revalidation ◈=metadata
+
+{{! — Vue — }}
+钚ц괟b(甲) =Vue ⏣=Composition API ⎆=SFC
+钜п뢴ц(乙) ◈=ref() ◈=reactive() ⌬=computed()
+钞タ읏ш(丙) ⌬=composable ⚡=watchEffect ⊛=provide/inject
+钠ミ쭎e(甲) ⏣=Pinia ⊛=store ⚡=action
+
+{{! — Angular — }}
+钢フ쫄ら(甲) =Angular ⏣=standalone component ⊛=Angular DI
+钤ル괩д(乙) ⌬=signal ⚡=effect ◈=computed signal
+钦キ훔b(丙) ⎈=NgModule ⏣=lazy loading ⚡=@defer
+钨ш벶ц(甲) ⚡=RxJS ⌬=Observable ⊛=pipe
+
+{{! — Svelte — }}
+钪ц꿸ш(甲) =Svelte ⏣=SvelteKit ⚡=compiler
+钬п듾e(乙) ⌬=$state ⌬=$derived ⌬=$effect
+钮タ쁩ら(丙) ⌬=$props ⚡=rune ⊕=no virtual DOM
+
+{{! — Django — }}
+钰ц릊д(甲) =Django ⏣=MTV ⌖=Admin
+钲п쨍b(乙) ⌬=ORM ⏣=QuerySet ⊛=Manager
+钴タ괡ц(丙) ⚡=Django migration ⏣=Form ⊕=Django signal
+钶ミ뭏ш(甲) ⎈=Django middleware ⏣=template tag ⊞=context processor
+
+{{! — Rails — }}
+钸フき됗(甲) =Rails ⏣=MVC ⊕=convention over configuration
+钺ル뵊e(乙) ⌬=ActiveRecord ⏣=scope ⊛=association
+钼キ쩔ら(丙) ⚡=Turbo ⚡=Stimulus ⏣=Hotwire
+钾ш괛д(甲) ⎈=Sidekiq ⚡=ActiveJob ⊛=cable
+
+{{! — FastAPI / Flask — }}
+铀ц쪵b(甲) =FastAPI ⏣=Pydantic ⊛=Depends
+铂п놓ц(乙) ⌬=path operation ⊞=request body ⊟=response model
+铄タ됗ш(丙) =Flask ⏣=Blueprint ⌬=app factory
+铆ミ쩝e(甲) ⎈=WSGI ⎈=ASGI ⚡=uvicorn
+
+{{! — Express / Fastify / NestJS — }}
+铈フ괟ら(甲) =Express ⏣=middleware chain ⚡=next()
+铊ル뢴д(乙) =Fastify ⏣=JSON Schema ⊛=plugin
+铌キ읏b(丙) =NestJS ⏣=NestJS module ⊛=DI container
+铎ш쭎ц(甲) ⌬=guard ⌬=interceptor ⌬=pipe
+
+{{! — Go frameworks — }}
+铐ц쫄ш(甲) =Gin ⏣=RouterGroup ⊞=binding
+铒п괩e(乙) =Echo ⏣=validator ⊛=group
+铔タ훔ра(丙) =Fiber ⎈=fasthttp ⏣=middleware stack
+
+{{! — Laravel / Symfony / WordPress — }}
+铖ц벶д(甲) =Laravel ⏣=Eloquent ⊛=service container
+铘п꿸b(乙) ⌬=Form Request ⚡=queue ⊛=event/listener
+铚タ듾ц(丙) =Symfony ⏣=Bundle ⊛=Doctrine
+铜ミ쁩ш(甲) =WordPress ⏣=hook ⌬=action/filter
+铞フ릊e(乙) ⏣=theme hierarchy ⊛=shortcode ⎆=Gutenberg
+
+{{! — CSS frameworks — }}
+铠ц쨍ра(甲) =Tailwind ⏣=utility class ⚙=config
+铢п괡д(乙) =Sass ⌬=Sass mixin ⏣=@use module
+铤タ뭏b(丙) ⊕=design system ◈=design token ⎆=responsive breakpoint
+
+{{! — framework verbs — }}
+铦цき(v) =render/paint
+铨п뢴(v) =hydrate/rehydrate
+铪タ괛(v) =mount/unmount
+铬ミ뵊(v) =route/navigate
+铮フ쪵(v) =middleware/intercept
+铰ル놓(v) =inject/provide
+铳キ됗(v) =migrate/seed
+铵ш쩝(v) =scaffold/generate

package/templates/partials/cogito-root-lang.hbs

@@ -0,0 +1,74 @@
+{{! cogito-root-lang — programming language-specific roots ~80 entries }}
+{{! Covers: Python, TypeScript, Go, PHP, Ruby, C, JavaScript, HTML, CSS concepts }}
+
+{{! — Python — }}
+鍬цАш(甲) =Python ⏣=CPython ⎈=virtualenv
+鍛пき뢴(乙) ⌬=Python decorator ⏣=metaclass ◇=descriptor
+鍮タ괛ら(丙) ⚡=Python generator ⌬=comprehension ◈=lambda
+鍖ミ뵊д(甲) ⏣=PEP ⚙=pyproject.toml ⊕=Zen of Python
+鍼フ쪵b(乙) ⌬=dataclass ◈=namedtuple ⏣=Protocol
+鍾ル놓ц(丙) ⎈=pip ⚙=uv ⊛=wheel
+鍔키됗ш(甲) ⚡=asyncio ◈=Python coroutine ⊛=event loop
+鑓ш쩝e(乙) ⌬=context manager ⚡=with statement ◈=GIL
+
+{{! — TypeScript / JavaScript — }}
+鋲ц괟ら(甲) =TypeScript ⏣=type system ⊕=strict mode
+鋳п뢴д(乙) ⌬=generic ⏣=discriminated union ◈=template literal type
+鋸タ읏b(丙) ⌬=interface ⏣=type alias ◇=satisfies
+鋩ミ쭎ц(甲) ⊕=type guard ◈=type assertion ⊗=type error
+鋏フ쫄ш(乙) =JavaScript ⌬=prototype ◈=closure
+鋤ル괩e(丙) ⚡=Promise ⌬=async/await ◈=callback
+鋭キ훔ら(甲) ⏣=ESModule ⊟=CommonJS ⚙=bundler
+鋼ш벶д(乙) ◈=Proxy ⌬=Reflect ⏣=WeakMap
+
+{{! — Go — }}
+鑢ц꿸b(甲) =Go ⏣=goroutine ⊛=channel
+鑰п듾ц(乙) ⌬=Go interface ⏣=struct embedding ◇=composition
+鑞タ쁩ш(丙) ⊗=error handling ⌬=defer ⚡=panic/recover
+鑚ミ릊e(甲) ⏣=go module ⚙=go.mod ⊛=workspace
+鑷フ쨍ら(乙) ⚡=select ◈=context ◉=timeout
+鑵ル괡д(丙) ⏣=package ⌖=internal ⊕=exported
+
+{{! — PHP — }}
+鑁цき뭏(甲) =PHP ⏣=Composer ⊕=strict_types
+鑈п됗ш(乙) ⌬=trait ⏣=enum ◈=named argument
+鑊タ뵊e(丙) ⌬=attribute ⚡=fiber ◈=readonly
+鑌ミ쩔ら(甲) ⏣=PSR ⊕=autoloading ⚙=php.ini
+
+{{! — Ruby — }}
+鑐ц괛д(甲) =Ruby ⏣=gem ⚙=Bundler
+鑒п쪵b(乙) ⌬=block ⌬=Proc ⌬=lambda
+鑓タ놓ц(丙) ⌬=Ruby mixin ⏣=module include/extend ◈=method_missing
+鑕ミ됗ш(甲) ◈=symbol ⏣=Enumerable ⊕=frozen_string_literal
+鑗フ쩝e(乙) ⚡=IRB ⚡=Pry ⊜=RuboCop
+
+{{! — C — }}
+鑙ц괟ら(甲) =C ⏣=standard library ⊕=C99/C11
+鑛п뢴д(乙) ◈=pointer ⊛=reference ⊗=dangling pointer
+鑝タ읏b(丙) ◈=struct ⏣=union ⌬=typedef
+鑟ミ쭎ц(甲) ⚡=malloc ⚡=free ⊗=memory leak
+鑡フ쫄ш(乙) ⚙=Makefile ⊕=compiler flag ⊗=undefined behavior
+鑣ル괩e(丙) ⚙=preprocessor ⌬=macro ⊞=header file
+
+{{! — HTML — }}
+鑥цき훔(甲) =HTML ⏣=semantic element ⊕=accessibility
+鑧п벶ра(乙) ⎆=landmark ⊞=ARIA role ⊕=alt text
+鑩タ꿸д(丙) ⎆=HTML form ⊞=input ⊟=label
+鑫ミ듾b(甲) ⏣=Living Standard ⊕=W3C validation
+
+{{! — CSS — }}
+鑭ц쁩ц(甲) =CSS ⏣=Grid ⏣=Flexbox
+鑯п릊ш(乙) ◈=custom property ⏣=cascade layer ⊕=specificity
+鑱タ쨍e(丙) ⎆=media query ⎆=container query ⊕=responsive
+鑳ミ괡ら(甲) ⊕=animation ⊕=transition ⎆=transform
+鑵フき뭏д(乙) ⏣=BEM ⏣=utility-first ⊕=CSS design token
+
+{{! — cross-language verbs — }}
+鑷ц뢴(v) =type-check/infer
+鑹п괛(v) =compile/transpile
+鑻タ쪵(v) =interpret/evaluate
+鑽ミ놓(v) =garbage-collect/free memory
+鑿フ됗(v) =serialize/marshal
+钁ル쩝(v) =deserialize/unmarshal
+钃キ괟(v) =lint/format
+钅ш읏(v) =refactor/restructure

package/templates/partials/godd-core.hbs

@@ -0,0 +1,50 @@
+## Core Attitude (MUST — Applies to Every Action)
+
+- **Always ask "why" first** — Establish purpose, constraints, and measurable completion criteria before writing any code
+- **Treat abnormal paths equally** — Error cases, boundary values, and operational behavior are as important as the happy path
+- **Evaluate from multiple perspectives** — Technology, business, UX, security, and operations — every change must be assessed from all angles
+- **Never guess when less than 95% certain** — If a premise is not confirmed, ask questions to eliminate ambiguity before proceeding
+
+## Pre-work Analysis (MUST — Before Starting Any Implementation)
+
+Before writing code, complete and document the following analysis:
+
+1. **Goal & completion criteria** — Define in measurable terms (what does "done" look like?)
+2. **Existing structure, patterns & constraints** — Understand what's already there and what rules apply
+3. **Impact scope & risks** — Functional, performance, UX, security, operational impact
+4. **Implementation options** — At least two approaches (standard / conservative / bold), with comparison and recommended choice with reasoning
+5. **Open questions & unknowns** — List uncertainties; ask before assuming
+
+If any of items 1-5 are unclear, **stop and ask the user** before proceeding.
+
+## Development Methodology: ATDD (Acceptance Test Driven Development)
+
+### For New Features (MUST)
+1. Spec confirmed → Define acceptance criteria in **Given-When-Then** format
+2. **Write acceptance tests FIRST** (Red — tests fail because feature doesn't exist yet)
+3. Implement the feature (Green — make the tests pass)
+4. Refactor → Maintain tests as regression suite
+
+### For Bug Fixes
+1. **Write a reproduction test FIRST** (Red — test demonstrates the bug)
+2. Fix the bug (Green — reproduction test passes)
+3. Verify no regressions
+
+### For Refactoring
+1. If existing tests cover the area → Refactor with confidence
+2. If no tests exist → **Add characterization tests FIRST**, then refactor
+
+### Test Priority (All Agents — Absolute Rule)
+- **Never give up** until API tests and E2E tests pass. Investigate root causes, fix issues, and retry
+- If tests cannot be run (infrastructure/environment reasons): document the reason, alternative verification method, and remaining risks
+- Test layer priority: **unit** (domain/usecase) → **integration** (API/DB boundaries) → **e2e** (critical flows only)
+
+## Quality Culture
+
+- Implement **failure paths first** — validate inputs, handle errors, then write the happy path
+- Use **early returns** to keep nesting shallow and responsibilities clear
+- Apply **SOLID / KISS / YAGNI / DRY** as self-review criteria for every change
+- Type safety is non-negotiable: no `any`, no type suppression (`ts-ignore`, `type: ignore`)
+- External input is always `unknown` until validated
+- Logs and error messages must be specific, minimal, and never contain secrets
+- Avoid N+1 queries and unnecessary full-table scans; consider batching, caching, or differential fetching when needed

package/templates/partials/project-context.hbs

@@ -0,0 +1,52 @@
+## Project Information (Auto-detected)
+
+- **Project name**: {{project.name}}
+- **Root**: `{{project.root}}`
+{{#if project.detected_stacks.length}}
+- **Detected stacks**:
+{{#each project.detected_stacks}}
+  - {{this.label}} ({{this.evidence}})
+{{/each}}
+{{/if}}
+{{#if project.directories.length}}
+- **Directory structure**: {{#each project.directories}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if project.key_files.length}}
+- **Key files**: {{#each project.key_files}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if project.docker_services.length}}
+- **Docker services**: {{#each project.docker_services}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if project.env_templates.length}}
+- **Environment templates**: {{#each project.env_templates}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if project.scripts}}
+- **npm scripts**: {{#each project.scripts}}`{{@key}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if project.detected_tools.length}}
+
+## Detected Ecosystem Tools
+{{#each project.detected_tools}}
+- **{{this.label}}** ({{this.category}}): {{this.description}} ({{this.evidence}})
+{{/each}}
+{{/if}}
+{{#if tools.length}}
+
+## Recommended Tools & Guidance
+{{#each tools}}
+### {{this.label}} ({{this.category}})
+- {{this.description}}
+{{#if this.guidance}}- **Guidance**: {{this.guidance}}{{/if}}
+{{#if this.url}}- **Reference**: {{this.url}}{{/if}}
+{{/each}}
+{{/if}}
+{{#if project.vendor_items.length}}
+
+## Available Vendor / OSS Tools
+{{#each project.vendor_items}}
+### vendor/{{this.name}}
+- **Description**: {{this.description}}
+- **Runtime**: {{this.runtime}}
+- **Setup**: `{{this.setupHint}}`
+{{/each}}
+{{/if}}

package/templates/partials/ssot-header.hbs

@@ -0,0 +1,40 @@
+## Operational Rules (SSOT)
+- Always follow operational rules (no terminal needed / branch isolation / 1 commit = 1 responsibility / PR is the GitHub MCP source of truth)
+{{#each stacks}}
+- When working with {{this.label}}, follow the {{this.name}} mindset as SSOT
+{{/each}}
+
+### Absolute Rules (MUST)
+
+**MUST-1: Never require the human to use the terminal**
+- The developer's only actions are: "make a request in natural language" and "review on GitHub PR"
+- All command execution is the Agent's responsibility
+
+**MUST-2: Separate Front/Back branches when UI changes are involved**
+- Frontend branch: `feat/<slug>-frontend`
+- Backend branch: `feat/<slug>-backend`
+- When a task spans Front/Back: create **separate PRs** (one for each)
+
+**MUST-3: 1 commit = 1 responsibility (no mixed commits)**
+- Hard scope (mixing these in one commit = violation):
+  - `frontend/`: frontend code
+  - `backend/`: backend code
+  - repo-root: everything else
+- Soft scope (can coexist in one commit):
+  - `docs/documents/`: documentation
+  - `scripts/`: scripts
+- Example: frontend + docs = OK, frontend + backend = **NG**
+
+**MUST-4: PR creation uses GitHub MCP as the source of truth**
+- Actual PR creation is done by the Agent via GitHub MCP
+
+**MUST-5: Never create/edit/add CI/CD workflow files**
+- Quality assurance is done via local scripts only
+
+### SSOT Priority (When Conflicts Arise)
+
+1. **Product Spec SSOT**: Spec files and referenced documents
+2. **Operational SSOT**: These operational rules (branch/commit/PR/quality gate rules)
+3. **Everything else** (README, verbal, past messages, etc.)
+
+When a conflict is detected: **never guess**. Determine which SSOT to update, apply the change, then proceed.

package/templates/partials/ssot-rules.hbs

@@ -0,0 +1,30 @@
+## SSOT Update & Question Management Rules (MUST)
+
+### Handling Spec Changes
+- When the user communicates a new spec, **update the SSOT**
+- If the SSOT update contradicts other specs, **ask the user for clarification**
+
+### Question Management
+- When the user **does not clearly answer** a question (no answer / ambiguous answer), add the question to **`docs/003_requirements/questions.csv`** (path: `{{project.question_list_path}}`)
+- CSV columns: `id,category,question,context,answer,spec_file,status`
+- Status values:
+  - `unanswered` — not yet answered
+  - `answered` — user provided a clear answer
+  - `spec_reflected` — answer has been reflected in the spec document (hidden in Notes view)
+- When a question is answered: update `answer` column → reflect in spec → set status to `spec_reflected`
+- Create the file with header row if it does not exist
+
+### Implementation Decisions
+- When instructed to implement without answers to questions:
+  - **Apply the "common sense" approach**
+- When clear answers or specs are available:
+  - **Never guess** — implement exactly as specified
+
+### Question Template (Use This Format When Asking Questions)
+When you need to ask the user a question, structure it as follows:
+
+1. **Current understanding**: What you know so far
+2. **Unclear point**: What specifically is ambiguous
+3. **Options**: Available choices (if any)
+4. **Recommendation**: Your suggested approach and why
+5. **Additional info needed**: What would help you decide

package/templates/prompts/adr.hbs

@@ -0,0 +1,39 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-daily }}
+
+## Purpose
+Create an ADR (Architecture Decision Record) that records design decisions in a form where readers can later reach the same conclusion.
+An ADR must explain the **why** so thoroughly that a future reader can independently evaluate whether the decision still holds.
+
+## Input
+- What to decide (Decision)
+- Background (Context)
+- Alternatives (Options)
+
+## Output
+Markdown ADR with the following sections:
+- **Title**: Short, descriptive name for the decision
+- **Status**: Proposed / Accepted / Deprecated / Superseded
+- **Context**: What is the issue? What forces are at play? What constraints exist?
+- **Decision**: What was decided and why
+- **Alternatives Considered**: For each alternative:
+  - Description
+  - Pros and cons
+  - Why it was not chosen
+- **Consequences**: What becomes easier or harder as a result of this decision
+- **Trade-offs**: What was sacrificed and what was gained (be explicit)
+- **Rollback Plan**: How to reverse this decision if it proves wrong
+- **Related Decisions**: Links to related ADRs or Spec documents
+
+Always include **trade-offs** and **rollback plan** — these are the most valuable parts of an ADR.

package/templates/prompts/agent-dev-workflow.hbs

@@ -0,0 +1,34 @@
+{{> ssot-header }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+## Purpose (Terminal-free operation)
+Enable developers to complete the full cycle — from environment setup to implementation, testing, commit, push, and PR creation — simply by requesting in natural language, without ever touching a terminal.
+
+## Absolute Rules (Important)
+- **Default branch protection**: Before making any code changes, check the current branch. If on the default branch (main/master), **always create a new feature branch first**
+  - Branch naming: `feat/<slug-or-task-summary>-<YYYYMMDD>` (e.g. `feat/add-auth-20260212`)
+  - Never commit directly to the default branch
+- When **UI implementation is involved**, always separate into **frontend** and **backend branches**
+  - `feat/<slug>-frontend-<YYYYMMDD>` / `feat/<slug>-backend-<YYYYMMDD>`
+- **1 commit = 1 responsibility** (mixed Front/Back commits are prohibited)
+- **End-of-work commits**: When development is complete, group changes into logical commit units (by concern: schema, backend, frontend, tests, config, docs) — do NOT make a single monolithic commit
+- Humans review **only via GitHub PR diffs**
+
+## Canonical References
+- Spec: `documents/spec/`
+{{#if frontend}}- Frontend quality gate: `{{frontend.build_command}}`
+{{/if}}{{#if backend}}- Backend quality gate: `{{quality_gate.backend}}`
+{{/if}}
+
+## How to proceed (Important)
+- **The developer's (human) entry point is the `dev` prompt** (with @references + purpose + completion criteria)
+- The procedures and commands in this prompt are **Agent-internal execution methods** (reference only); humans do not need to memorize or execute them

package/templates/prompts/analyze-report.hbs

@@ -0,0 +1,36 @@
+{{> ssot-header }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-daily }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+## Purpose
+Produce a consistent report at task completion, following the template structure.
+
+## Output
+Fill in the following headings concisely, leaving no blanks (keep code blocks minimal).
+
+### Change Summary
+-
+
+### Impact Scope
+{{#if frontend}}- Frontend（`{{frontend.root_dir}}`）:
+{{/if}}{{#if backend}}- Backend（`{{backend.root_dir}}`）:
+{{/if}}- Other:
+
+### Verification Performed
+- Command/Result:
+
+### Compatibility / Migration
+- Breaking changes: Yes/No
+- Migration steps:
+- Rollback:
+
+### Remaining Risks / Open Items
+-

package/templates/prompts/auto-documentation.hbs

@@ -0,0 +1,37 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-daily }}
+
+## Purpose
+From the changes, comprehensively identify all documentation updates needed and draft the diffs.
+Documentation must stay in sync with implementation — stale docs are worse than no docs.
+
+## Input
+- Change details (target files / behavior diff)
+- Reason for change (purpose / completion criteria)
+
+## Document Types to Check
+Review whether each of these needs updating:
+- **Spec documents**: Feature specs, API specs, DB specs
+- **README files**: Project root and module-level READMEs
+- **Configuration docs**: Environment variables, setup instructions
+- **Tech stack docs**: Dependencies, versions, architecture decisions
+- **Operational docs**: Deployment, migration, rollback procedures
+- **SSOT documents**: Spec index, operational rules, question list
+- **ADR (Architecture Decision Records)**: If the change involves a design decision
+
+## Output
+1. **List of documents to update** (file paths, with priority)
+2. **Addition/modification points** for each document (bullet list with specific changes)
+3. **Broken-reference check** items (links / paths that may be invalidated by the change)
+4. **New documents needed** (if the change introduces a new feature/module with no documentation)

package/templates/prompts/check.hbs

@@ -0,0 +1,52 @@
+{{> ssot-header }}
+
+{{> godd-core }}
+
+{{> ssot-rules }}
+
+{{> project-context }}
+
+{{> cogito-grammar }}
+{{> cogito-root-core }}
+{{> cogito-particle }}
+{{> cogito-godd }}
+{{> cogito-root-dev }}
+
+## Purpose
+Check the "minimum quality gate" before submitting changes and identify any missing perspectives.
+This is the **last line of defense** — be thorough and systematic.
+
+## Checklist (Evaluate Every Item)
+
+- **Spec alignment**: Does the Spec need updates? If gaps exist, propose additions. If Spec is missing for the change, flag it.
+- **Impact scope**: Has the impact been analyzed? Are all affected modules identified?
+- **Test plan**: Is the test plan documented? Does it cover boundary values and error cases?
+- **Compatibility/Migration**: If breaking changes exist, is migration/rollback documented?
+- **Tests (highest priority)**: Continue improving until **API tests/E2E tests pass** within available test infrastructure
+  - If unable to run tests: document the **reason**, **alternative verification**, and **remaining risks**
+  - Test priority: unit → integration → e2e
+{{#if frontend}}
+- **Frontend (if changed)**: Run `{{frontend.build_command}}` — must pass
+{{/if}}
+{{#if backend}}
+- **Backend (if changed)**: Minimal backend verification (startup / main API endpoints respond)
+{{/if}}
+- **Security**: Ensure secrets are not exposed in logs, exceptions, or UI
+- **SSOT consistency**: Are all SSOT documents (Spec, operational rules) still consistent after this change?
+- **Commit hygiene**: 1 commit = 1 responsibility? No Front/Back mixed commits?
+
+## Output
+For each checklist item, report:
+- **Status**: PASS / FAIL / N/A
+- **Details**: What was checked, what was found
+- **Action needed**: If FAIL, what needs to be fixed
+
+{{#if frontend.mindset}}
+## Frontend Review Criteria
+{{{frontend.mindset}}}
+{{/if}}
+
+{{#if backend.mindset}}
+## Backend Review Criteria
+{{{backend.mindset}}}
+{{/if}}